103 lines
3.9 KiB
C++
103 lines
3.9 KiB
C++
/*
|
|
-------------------------------------------------------------------------------
|
|
|
|
2022.05.28 - On lambda expressions
|
|
I think it's not wise to add the multiline lambda expressions
|
|
As is the case with python it would require new alternative syntax.
|
|
The idea was to imply that the whitespace significant syntax is just
|
|
inserting '{' '}' ';' automatically and if you decide to write a brace
|
|
it stops being whitespace significant and you can type everything with semicolons and braces
|
|
Problem is first of all it's kind of weird to have a completly different syntax
|
|
in a language to solve something that is a minor inconvenience,
|
|
second of all it turned out to be kind of bad, maybe if it would be more
|
|
complicated then it would be ok but it implies that you have to semicolon end
|
|
a lot of thing unintuitively.
|
|
|
|
Probably single line lambdas should be ok. Currently braces turn off indentation
|
|
awareness. There might be something you can do by trying to turn that on
|
|
problem is that complicates parsing a lot cause you have to account for multiple
|
|
indent styles, which means error messages become bad.
|
|
|
|
-------------------------------------------------------------------------------
|
|
|
|
2022.05.30 - On constructors and compound expressions
|
|
I unified the compound expression syntax (Type){} with function call syntax Type().
|
|
It's differentiating on whether you used type. I think there is a benefit to the language
|
|
not having an idea of overloading the type constructor. You will always know what will happen.
|
|
Unlike C++ for example. It seems like a minefield that can fuck your mind up. So many corner cases
|
|
and variants. having the idea of compounds doing one thing is reassuring I think.
|
|
You can always do a constructor by writing a function with lower case type if you want that.
|
|
For now I don't thing it should be overloadable.
|
|
|
|
-------------------------------------------------------------------------------
|
|
|
|
@todo
|
|
[ ] - Init statements, different kinds [+=] [-=] etc.
|
|
[ ] - lvalue, rvalue concept so we cant assign value to some arbitrary weird expression
|
|
[ ] - More operators
|
|
[ ] - More for loop variations
|
|
[ ] - Fixing access to constants, in C we cant have constants inside of structs / functions so we need to rewrite the tree
|
|
[ ] - Default values in structs??? Should compound stmts bring values from default values?? Maybe not? Whats the alternative
|
|
[ ] - Write up on order independent declarations
|
|
[ ] - Switch
|
|
[ ] - More basic types
|
|
[ ] - Array of inferred size
|
|
[ ] - Lexer: Need to insert scope endings when hitting End of file
|
|
[ ] - Add single line lambda expressions
|
|
|
|
@ideas
|
|
|
|
|
|
@donzo
|
|
[x] - Access through struct names to constants Arena.CONSTANT
|
|
[x] - Enums
|
|
[x] - Initial for loop
|
|
[x] - Enum . access to values
|
|
[x] - Struct calls
|
|
[x] - Default values in calls
|
|
[x] - Resolving calls with default values
|
|
[x] - Pass statement
|
|
[x] - Resolving calls with named args, with indexed args
|
|
[x] - Structs
|
|
[x] - Struct field access
|
|
[x] - Struct field access with dots while compiling to arrows in c
|
|
[x] - Typespecs should probably be expressions so stuff like would be possible :: *[32]int
|
|
[x] - Initial order independence algorithm
|
|
[x] - Think about compound expressions, unify with calls - maybe Thing(a=1) instead of Thing{a=1}
|
|
*/
|
|
|
|
#include "base.cpp"
|
|
#include "base_unicode.cpp"
|
|
#include "new_lex.cpp"
|
|
#include "new_ast.cpp"
|
|
#include "new_parse.cpp"
|
|
#include "typecheck.h"
|
|
#include "typecheck.cpp"
|
|
#include "ccodegen.cpp"
|
|
int main(){
|
|
|
|
test_os_memory();
|
|
thread_ctx_init();
|
|
test_unicode();
|
|
test_types();
|
|
|
|
map_test();
|
|
test_array();
|
|
test_string_builder();
|
|
test_intern_table();
|
|
|
|
String result = {};
|
|
result = compile_file("globals.kl"_s);
|
|
printf("%s", result.str);
|
|
result = compile_file("enums.kl"_s);
|
|
printf("%s", result.str);
|
|
result = compile_file("lambdas.kl"_s);
|
|
printf("%s", result.str);
|
|
result = compile_file("order1.kl"_s);
|
|
printf("%s", result.str);
|
|
result = compile_file("order2.kl"_s);
|
|
printf("%s", result.str);
|
|
|
|
__debugbreak();
|
|
}
|