Rename files

core_main.cpp

@@ -0,0 +1,161 @@
+/*
+-------------------------------------------------------------------------------
+
+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.
+
+-------------------------------------------------------------------------------
+
+Imports
+We compile lot's of files, we keep track of them in Parse_Ctx, making sure we don't
+parse same thing twice. Files belong to a module, files can be loaded #load "file".
+All the files see all the decls from all the files in that module. We can import
+other modules using a different directive #import. #import perhaps should be lazily
+evaluated, making sure we don't resolve stuff we don't require. Currently probably
+want to export all the symbols, we can namespace them optionally.
+
+2022.06.26 - import revision
+Current design is a bit weird, there can be situations where you have colissions and stuff.
+That's not cool. I was thinking of bringing back this idea where you have modules, implicit or
+explicit(module directive at top of the file). Then each file that belongs to a module sees other
+decls in that module and stuff like that. Other modules would be imported using a single keyword.
+BUT on second thought I don't really like that design. It's not really clear how files that
+belong to a module are found and concatenated. Then you would need to specify a directory to
+compile instead of a single file and stuff like that which seems annoying! Current idea is
+to just disallow having same file loaded twice! It's the same result as with the module stuff,
+we cant reuse files, but we avoid file colissions where we load a file and a module we import loads
+a file. I like the load files approach to a module cause we specify which files to compile and load.
+Imports also could be this other thing where we load lazily and we decrease the amount of code
+that we output. Code in our project shouldn't be evaluated lazily cause that's counter intuitive.
+For modules it's a bit different cause they should be distributed as valid.
+
+-------------------------------------------------------------------------------
+
+@todo
+[ ] - Fix language_basics.kl string index error
+[ ] - Split Bc into builder and interpreter
+[ ] - Implement functions in the bytecode
+
+[ ] - Probably need to give Ast_Expr a Value field, then I can express Type nicely
+[ ] - I would love for String, slice, Any etc. to have their struct declarations in source files, I also would want for stuff like string.str to work without weird special cases
+[ ] - Var args with Any
+
+[ ] - #test construct that would gather all tests and run them on start of program or something
+[ ] - Foreign import that would link library
+[ ] - Builtin dynamic arrays
+[ ] - Kilobyte, Megabyte, Gigabyte
+[ ] - Cast from array to pointer?
+[ ] - Fix field access, cant cast, cant index
+[ ] - Add parent_scope to Ast_Type, Add name to Ast_Type?
+[ ] - Some way to take slice of data
+[ ] - Optional function renaming in codegen
+[ ] - Using in structs to embed members, then casting offsets to that embedded member
+
+[ ] - Comma notation when declaring variables thing1, thing2: S32 :: probably want to unify it with var unpacking
+[ ] - Add single line lambda expressions
+[ ] - Ternary operator
+[ ] - Disable ability to parse inner structs, functions, constants etc. ?
+[ ] - Write up on order independent declarations
+
+[ ] - Consider changing syntax of scopes to use braces { }
+[ ] - Order independent declarations in structs ?
+[ ] - constructor => thing :: (i: S32) -> {i = i, thing = 10}
+[ ] - Casting to basic types by call S64(x)
+[ ] - Default values in structs??? Should compound stmts bring values from default values?? Maybe not? Whats the alternative
+
+@ideas
+[ ] - Var args using Any array - args: []Any - delete vargs
+[ ] - [Using] keyword that brings in the struct enviroment into current scope etc.
+[ ] - Constant arrays that evaluate fully at compile time
+[ ] - Rust like enum where you associate values(other structs) with keys
+[ ] - Compound that zeros values - .{} , Compound that assumes defaults from struct definition - {}
+[ ] - Inject stack traces into the program
+[ ] - Conditional compilation #if
+[ ] - Polymorphism - create declaration of a polymorphic thing, when it's called just copy it, replace types and typecheck normally, when someone calls again you just search for the instantiation again
+
+*/
+
+#include "base.cpp"
+#include "base_unicode.cpp"
+#include "os_windows.cpp"
+#include "c3_big_int.cpp"
+#include "core_compiler.h"
+#include "core_lexing.cpp"
+#include "core_types.h"
+#include "core_ast.cpp"
+#include "core_parsing.cpp"
+#include "core_typechecking.h"
+#include "core_typechecking.cpp"
+#include "core_compiler.cpp"
+#include "core_codegen_c_language.cpp"
+
+
+int main(int argument_count, char **arguments){
+#if OS_WINDOWS
+  // Set output mode to handle virtual terminal sequences
+  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+  if (hOut == INVALID_HANDLE_VALUE) {
+    return GetLastError();
+  }
+
+  DWORD dwMode = 0;
+  if (!GetConsoleMode(hOut, &dwMode)) {
+    return GetLastError();
+  }
+
+  dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+  if (!SetConsoleMode(hOut, dwMode)) {
+    return GetLastError();
+  }
+#endif
+
+  test_os_memory();
+  thread_ctx_init();
+  test_unicode();
+
+  map_test();
+  test_array();
+  test_string_builder();
+  test_intern_table();
+
+  emit_line_directives = true;
+  String program_name = "examples/types_as_first_class_values.kl"_s;
+  if(argument_count > 1){
+    program_name = string_from_cstring(arguments[1]);
+  }
+
+  Scratch scratch;
+  Array<OS_File_Info> examples = os_list_dir(scratch, "examples"_s);
+  // compile_file("examples/language_basics.kl"_s, COMPILE_AND_RUN);
+  For(examples){
+    if(it.is_directory) continue;
+    compile_file(it.absolute_path, COMPILE_AND_RUN);
+  }
+
+  __debugbreak();
+}