├── .github
    └── workflows
    │   └── ccpp.yml
├── .gitignore
├── .gitmodules
├── CMakeLists.txt
├── LICENSE
├── README.md
├── comet
    ├── CMakeLists.txt
    ├── comet.h
    └── main.c
├── docs
    ├── CNAME
    ├── _config.yml
    ├── _layouts
    │   └── default.html
    ├── index.md
    ├── stdlib
    │   ├── argument_exception.md
    │   ├── boolean.md
    │   ├── csv.md
    │   ├── datetime.md
    │   ├── directory.md
    │   ├── duration.md
    │   ├── enum.md
    │   ├── env.md
    │   ├── exception.md
    │   ├── file.md
    │   ├── function.md
    │   ├── hash.md
    │   ├── image.md
    │   ├── index.md
    │   ├── iterable.md
    │   ├── json.md
    │   ├── list.md
    │   ├── module.md
    │   ├── nil.md
    │   ├── number.md
    │   ├── object.md
    │   ├── set.md
    │   ├── socket.md
    │   ├── string.md
    │   ├── string_builder.md
    │   ├── thread.md
    │   ├── thread_synchronisation.md
    │   └── unittest.md
    └── syntax
    │   └── index.md
├── grammar.md
├── sample.cmt
├── stdlib
    ├── CMakeLists.txt
    ├── _init.c
    ├── boolean.c
    ├── colour.cpp
    ├── comet
    │   ├── CMakeLists.txt
    │   ├── coverage.cmt
    │   ├── csv.cmt
    │   ├── json.cmt
    │   └── unittest.cmt
    ├── cometlib.h
    ├── datetime_unix.cpp
    ├── datetime_win.cpp
    ├── directory.cpp
    ├── duration.cpp
    ├── enum.cpp
    ├── env.cpp
    ├── exception.c
    ├── file_common.cpp
    ├── file_unix.cpp
    ├── file_win.cpp
    ├── function.c
    ├── hash.cpp
    ├── image.c
    ├── iterable.c
    ├── list.cpp
    ├── module.c
    ├── native_functions.c
    ├── nil.c
    ├── number.c
    ├── object.c
    ├── private
    │   ├── colour.h
    │   ├── comet_stdlib.h
    │   ├── comet_string.h
    │   ├── datetime.hpp
    │   ├── directory.hpp
    │   ├── file_common.h
    │   ├── list.h
    │   ├── string_builder.h
    │   └── thread_sync_common.h
    ├── process.cpp
    ├── set.cpp
    ├── socket.c
    ├── string.c
    ├── string_builder.c
    ├── system.c
    ├── test
    │   ├── CMakeLists.txt
    │   ├── main.c
    │   ├── test_list.c
    │   ├── test_string.c
    │   └── tests.h
    ├── thread.c
    ├── thread_synchronisation_common.c
    ├── thread_synchronisation_unix.c
    ├── thread_synchronisation_win.c
    └── unittest
    │   └── _init.cmt
├── test_scripts
    ├── argument_exception_test.cmt
    ├── attribute_test.cmt
    ├── boolean.cmt
    ├── class_inherits_constructor.cmt
    ├── class_inherits_imported_class.cmt
    ├── class_inherits_object.cmt
    ├── class_operator_overload.cmt
    ├── class_with_field.cmt
    ├── colour.cmt
    ├── complex_exception_with_finally.cmt
    ├── datetime_test.cmt
    ├── default_params.cmt
    ├── directory_test.cmt
    ├── duration_test.cmt
    ├── enum_declaration.cmt
    ├── env_test.cmt
    ├── exception_handler.cmt
    ├── file_test.cmt
    ├── for_loop_test.cmt
    ├── foreach_loops.cmt
    ├── hash_test.cmt
    ├── image.cmt
    ├── import_test.cmt
    ├── import_test
    │   ├── main.cmt
    │   └── secondary.cmt
    ├── is.cmt
    ├── json_test.cmt
    ├── lambda.cmt
    ├── list_test.cmt
    ├── main_test.cmt
    ├── native_field_accessor.cmt
    ├── numbers_test.cmt
    ├── object_test.cmt
    ├── process_test.cmt
    ├── rest_params_test.cmt
    ├── set_test.cmt
    ├── socket_threads.cmt
    ├── splat_test.cmt
    ├── string_builder_test.cmt
    ├── string_test.cmt
    ├── ternary_test.cmt
    ├── throw_exception.cmt
    ├── variables.cmt
    └── while_loop_test.cmt
└── vmlib
    ├── CMakeLists.txt
    ├── chunk.c
    ├── chunk.h
    ├── common.h
    ├── compiler
        ├── CMakeLists.txt
        ├── inc
        │   ├── compiler.h
        │   └── debug.h
        ├── src
        │   ├── compiler.c
        │   ├── compiler_defs.h
        │   ├── constants.c
        │   ├── constants.h
        │   ├── debug.c
        │   ├── declarations.c
        │   ├── declarations.h
        │   ├── emitter.c
        │   ├── emitter.h
        │   ├── expressions.c
        │   ├── expressions.h
        │   ├── source_files.c
        │   ├── sources.cmake
        │   ├── statements.c
        │   ├── statements.h
        │   ├── variables.c
        │   └── variables.h
        └── test
        │   ├── CMakeLists.txt
        │   ├── main.c
        │   ├── test_pratt_parser.c
        │   └── tests.h
    ├── import.cpp
    ├── import.h
    ├── lexer
        ├── CMakeLists.txt
        ├── inc
        │   └── scanner.h
        ├── src
        │   ├── scanner.c
        │   └── sources.cmake
        └── test
        │   ├── CMakeLists.txt
        │   ├── main.c
        │   ├── test_scanner.c
        │   └── tests.h
    ├── mem.c
    ├── mem.h
    ├── native.c
    ├── native.h
    ├── object_defs.h
    ├── objects.c
    ├── objects.h
    ├── table.c
    ├── table.h
    ├── test
        └── test_table.c
    ├── value.c
    ├── value.h
    ├── vm.c
    ├── vm.h
    └── vm_globals.c


/.github/workflows/ccpp.yml:
--------------------------------------------------------------------------------
 1 | name: C/C++ CI
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   build-linux:
 7 |     runs-on: ubuntu-latest
 8 | 
 9 |     steps:
10 |     - uses: actions/checkout@v4
11 |       with:
12 |         submodules: recursive
13 |     - name: build-test
14 |       shell: bash
15 |       run: |
16 |         cmake -B build -S .
17 |         cmake --build build --target all --target test --target stdlib_test
18 | 
19 | 
20 |   build-windows:
21 |     runs-on: windows-latest
22 | 
23 |     steps:
24 |       - uses: actions/checkout@v4
25 |         with:
26 |           submodules: recursive
27 |       - name: build-test 
28 |         run: |
29 |           cmake -B build -S . -DCMAKE_SYSTEM_VERSION="10.0.20348.0"
30 |           cmake --build build --target ALL_BUILD --target RUN_TESTS
31 |     # - run: cmake --build build --target ALL_BUILD --target RUN_TESTS --target stdlib_test
32 | 
33 | 
34 |   build-release-windows:
35 |     runs-on: windows-latest
36 | 
37 |     steps:
38 |     - uses: actions/checkout@v4
39 |       with:
40 |         submodules: recursive
41 |     - name: build
42 |       shell: bash
43 |       run: |
44 |         cmake -B release -S . -DCMAKE_BUILD_TYPE=Release -DCMAKE_SYSTEM_VERSION="10.0.20348.0" -DVERSION=${{ github.ref_name }}
45 |         cmake --build release --target ALL_BUILD --config Release
46 | 
47 |     - name: Create-Archive
48 |       shell: powershell
49 |       if: ${{ startsWith(github.ref, 'refs/tags/') }}
50 |       run: |
51 |         mkdir output
52 |         cp release\comet\Release\comet.exe output
53 |         cp stdlib\comet\*.cmt output
54 |         Compress-Archive -Path output\* -DestinationPath comet_windows_${{ github.ref_name }}.zip
55 | 
56 |     - name: Release-Windows
57 |       uses: softprops/action-gh-release@v0.1.15
58 |       if: ${{ startsWith(github.ref, 'refs/tags/') }}
59 |       with:
60 |         files: comet_windows_${{ github.ref_name }}.zip
61 | 
62 |   build-release-linux:
63 |     runs-on: ubuntu-latest
64 | 
65 |     steps:
66 |       - uses: actions/checkout@v4
67 |         with:
68 |           submodules: recursive
69 | 
70 |       - name: build
71 |         shell: bash
72 |         run: |
73 |           cmake -B release -S . -DCMAKE_BUILD_TYPE=Release -DVERSION=${{ github.ref_name }}
74 |           cmake --build release --target all
75 | 
76 |       - name: Create-Archive
77 |         if: ${{ startsWith(github.ref, 'refs/tags/') }}
78 |         shell: bash
79 |         run: zip -j comet_linux_${{ github.ref_name }}.zip release/comet/comet stdlib/comet/*.cmt
80 | 
81 |       - name: Release-Linux
82 |         uses: softprops/action-gh-release@v0.1.15
83 |         if: ${{ startsWith(github.ref, 'refs/tags/') }}
84 |         with:
85 |           files: comet_linux_${{ github.ref_name }}.zip


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | bin/
2 | .vscode/
3 | build/
4 | release/
5 | .vs/
6 | .coverage.json


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "date"]
 2 | 	path = date
 3 | 	url = https://github.com/HowardHinnant/date
 4 | [submodule "utf8proc"]
 5 | 	path = utf8proc
 6 | 	url = https://github.com/JuliaStrings/utf8proc
 7 | [submodule "stb"]
 8 | 	path = stb
 9 | 	url = https://github.com/nothings/stb
10 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.10)
 2 | project (comet)
 3 | enable_language(C)
 4 | enable_language(CXX)
 5 | enable_testing()
 6 | 
 7 | if (WIN32)
 8 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
 9 | elseif (CMAKE_BUILD_TYPE MATCHES DEBUG)
10 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -ggdb3 -Wall -Wextra -Werror")
11 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -ggdb3 -Wall -Wextra -Werror")
12 | endif ()
13 | 
14 | set(CMAKE_C_STANDARD 11 CACHE INTERNAL "Set C standard to C11")
15 | set(CMAKE_CXX_STANDARD 20 CACHE INTERNAL "Set C++ standard to C++20")
16 | set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS}")
17 | 
18 | find_package(Threads REQUIRED)
19 | SET( BUILD_SHARED_LIBS OFF CACHE INTERNAL "Build static libraries")
20 | SET( BUILD_TZ_LIB ON CACHE INTERNAL "Build the timezone library")
21 | SET( USE_SYSTEM_TZ_DB ON CACHE INTERNAL "Use the system TimeZone database, removing need for libcurl")
22 | SET(UTF8PROC_INSTALL OFF CACHE INTERNAL "Don't install the utf8proc lib")
23 | set(MEMORYCHECK_COMMAND_OPTIONS "--track-origins=yes --leak-check=full --errors-for-leak-kinds=all --error-exitcode=1 --log-fd=2")
24 | add_subdirectory(date)
25 | add_subdirectory(utf8proc)
26 | add_subdirectory(stdlib)
27 | add_subdirectory(vmlib)
28 | add_subdirectory(comet)


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # The Comet Programming Language
 2 | 
 3 | This is mostly built for fun and a way of taking things apart to see how they work.  It is based on the interpreter from [Crafting Interpreters](https://github.com/munificent/craftinginterpreters)
 4 | 
 5 | After programming for a while, there are specific things about the dynamic languages that I've
 6 | used that really annoy me, so I'm making my own language to improve some of those.  No doubt I will add things that are annoying.
 7 | 
 8 | It takes inspiration from the languages I've used most heavily:
 9 | 
10 | - C
11 | - JavaScript
12 | - Ruby
13 | - Python
14 | - C#
15 | 
16 | I don't have a firm idea of the syntax or semantics yet - I will be making those up as I go along.  I'd like to think that I'll document it, but it will likely be half-assed, and incomplete.  Have fun!
17 | 
18 | [Current working sample](sample.cmt)
19 | 


--------------------------------------------------------------------------------
/comet/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.10)
 2 | enable_language(C)
 3 | 
 4 | add_executable(comet main.c)
 5 | if (WIN32)
 6 | add_compile_definitions(WIN32=1)
 7 | target_link_libraries(comet PRIVATE stdlib vmlib)
 8 | SET_TARGET_PROPERTIES(comet PROPERTIES LINK_FLAGS "/link setargv.obj")
 9 | else()
10 | target_link_libraries(comet PRIVATE stdlib vmlib m c)
11 | endif (WIN32)
12 | target_include_directories(comet PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
13 | 
14 | install(TARGETS comet
15 |         RUNTIME DESTINATION bin
16 |         LIBRARY DESTINATION lib)
17 | 
18 | set (git_cmd "git")
19 | execute_process(COMMAND "git" "describe" "--tags"
20 |   WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
21 |   OUTPUT_VARIABLE VERSION)
22 | 
23 | target_compile_definitions(comet PRIVATE VERSION_STRING=${VERSION})
24 | 
25 | set (toplevel_source_dir "${CMAKE_CURRENT_SOURCE_DIR}/..")
26 | add_custom_target(stdlib_test
27 | ${CMAKE_COMMAND} -E env "COMET_LIB_DIR=${toplevel_source_dir}/stdlib/comet"
28 |   "$<TARGET_FILE:comet>"
29 |     "${toplevel_source_dir}/stdlib/comet/unittest.cmt"
30 |     "--coverage"
31 |     "${toplevel_source_dir}/test_scripts/*.cmt"
32 | WORKING_DIRECTORY "${toplevel_source_dir}"
33 | DEPENDS comet
34 | )
35 | 
36 | add_custom_target(memtest
37 | ${CMAKE_COMMAND} -E env "COMET_LIB_DIR=${toplevel_source_dir}/stdlib/comet"
38 |   "valgrind"
39 |   "$<TARGET_FILE:comet>"
40 |     "${toplevel_source_dir}/stdlib/comet/unittest.cmt"
41 |     "--coverage"
42 |     "${toplevel_source_dir}/test_scripts/*.cmt"
43 | WORKING_DIRECTORY "${toplevel_source_dir}"
44 | DEPENDS comet
45 | )


--------------------------------------------------------------------------------
/comet/comet.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_H_
 2 | #define _COMET_H_
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | 
 8 | #include "value.h"
 9 | #include "objects.h"
10 | #include "native.h"
11 | #include "mem.h"
12 | 
13 |     void init_comet(VM* vm);
14 |     void init_stdlib(VM* vm);
15 | 
16 |     VALUE obj_hash(VM* vm, VALUE self, int arg_count, VALUE* arguments);
17 | 
18 |     VALUE string_create(VM* vm, char* chars, int length);
19 |     int string_compare_to_cstr(VALUE self, const char* cstr);
20 |     const char* string_get_cstr(VALUE self);
21 |     VALUE string_hash(VM* vm, VALUE self, int arg_count, VALUE* arguments);
22 |     uint32_t string_hash_cstr(const char* string, int length);
23 | 
24 |     void exception_set_stacktrace(VM* vm, VALUE self, VALUE stacktrace);
25 |     VALUE exception_get_stacktrace(VM* vm, VALUE self);
26 |     VALUE exception_get_message(VM* vm, VALUE self, int arg_count, VALUE* arguments);
27 |     VALUE instanceof(VALUE self, VALUE klass);
28 | 
29 |     bool bool_is_falsey(Value value);
30 | 
31 |     VALUE create_number(VM* vm, double number);
32 |     double number_get_value(VALUE self);
33 |     VALUE number_operator(VM* vm, VALUE self, VALUE* arguments, OPERATOR op);
34 | 
35 |     VALUE list_create(VM* vm);
36 |     VALUE list_add(VM* vm, VALUE self, int arg_count, VALUE* arguments);
37 |     VALUE list_get_at(VM* vm, VALUE self, int arg_count, VALUE* arguments);
38 |     VALUE list_length(VM* vm, VALUE self, int arg_count, VALUE* arguments);
39 | 
40 |     VALUE hash_create(VM *vm);
41 |     VALUE hash_add(VM *vm, VALUE self, int arg_count, VALUE *arguments);
42 |     VALUE hash_has_key_q(VM* vm, VALUE self, int arg_count, VALUE* arguments);
43 |     VALUE hash_get(VM *vm, VALUE self, int arg_count, VALUE *arguments);
44 | 
45 |     void hash_mark_contents(VALUE self);
46 |     void list_mark_contents(VALUE self);
47 |     void set_mark_contents(VALUE self);
48 |     void enum_mark_contents(VALUE self);
49 |     void thread_mark_contents(VALUE self);
50 |     void module_mark_contents(VALUE self);
51 | 
52 |     VALUE module_create(VM* vm, const char* filename);
53 |     bool module_is_initialized(VALUE module);
54 |     void module_set_initialized(VALUE module);
55 |     const char* module_filename(VALUE module);
56 |     void module_set_main(VALUE module, ObjFunction* function);
57 |     ObjFunction* module_get_main(VALUE module);
58 |     VALUE module_functions(VM *vm, VALUE self, int arg_count, VALUE *arguments);
59 | 
60 |     VALUE duration_create(VM *vm, int64_t count);
61 | #ifdef __cplusplus
62 | }
63 | #endif
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/comet/main.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <string.h>
  4 | #include "common.h"
  5 | #include "chunk.h"
  6 | #include "debug.h"
  7 | #include "vm.h"
  8 | #include "cometlib.h"
  9 | #include "compiler.h"
 10 | #include "import.h"
 11 | 
 12 | #define stringify(s) #s
 13 | #define stringify_value(s) stringify(s)
 14 | 
 15 | static VM virtualMachine;
 16 | 
 17 | static int startingArg = 2;
 18 | 
 19 | static void repl()
 20 | {
 21 |     SourceFile source;
 22 |     char line[1024];
 23 |     source.source = line;
 24 |     source.path = "";
 25 |     for (;;)
 26 |     {
 27 |         printf("> ");
 28 | 
 29 |         if (!fgets(line, sizeof(line), stdin))
 30 |         {
 31 |             printf("\n");
 32 |             break;
 33 |         }
 34 | 
 35 |         Value module = compile(&source, &virtualMachine);
 36 |         if (module == NIL_VAL)
 37 |         {
 38 |             runtimeError(&virtualMachine, "compilation error");
 39 |         }
 40 |         else
 41 |         {
 42 |             interpret(&virtualMachine, module);
 43 |         }
 44 |     }
 45 | }
 46 | 
 47 | static void defineMain(Value main)
 48 | {
 49 |     Value main_varname = copyString(&virtualMachine, "__MAIN__", 8);
 50 |     push(&virtualMachine, main_varname);
 51 |     // This is the fully resolved, canonical path - the same as how __FILE__ will be defined
 52 |     // to_import might be relative or an unresolved library path
 53 |     const char *main_filename = module_filename(main);
 54 |     Value main_varvalue = copyString(&virtualMachine, main_filename, strlen(main_filename));
 55 |     push(&virtualMachine, main_varvalue);
 56 |     addGlobal(main_varname, main_varvalue);
 57 |     popMany(&virtualMachine, 2);
 58 | }
 59 | 
 60 | static void runFile(const char *path)
 61 | {
 62 |     Value to_import = copyString(&virtualMachine, path, strlen(path));
 63 |     push(&virtualMachine, to_import);
 64 |     Value main = import_from_file(&virtualMachine, NULL, to_import);
 65 |     defineMain(main);
 66 |     pop(&virtualMachine);
 67 | 
 68 |     InterpretResult result = interpret(&virtualMachine, main);
 69 | 
 70 |     if (result == INTERPRET_COMPILE_ERROR) exit(65);
 71 |     if (result == INTERPRET_RUNTIME_ERROR) exit(70);
 72 | }
 73 | 
 74 | void initArgv(VM *vm, int argc, const char **argv)
 75 | {
 76 |     VALUE argv_list = list_create(vm);
 77 |     push(vm, argv_list);
 78 |     for (int i = startingArg; i < argc; i++)
 79 |     {
 80 |         VALUE arg = copyString(vm, argv[i], strlen(argv[i]));
 81 |         push(vm, arg);
 82 |         list_add(vm, argv_list, 1, &arg);
 83 |         pop(vm);
 84 |     }
 85 |     addGlobal(copyString(vm, "ARGV", 4), argv_list);
 86 |     pop(vm);
 87 | }
 88 | 
 89 | int main(int argc, const char **argv)
 90 | {
 91 |     if (argc >= 2)
 92 |     {
 93 |         for (int i = 1; i < argc; i++)
 94 |         {
 95 |             if (strncmp(argv[i], "--version", 9) == 0)
 96 |             {
 97 |                 printf("comet programming language, %s\n", stringify_value(VERSION_STRING));
 98 |                 return 0;
 99 |             }
100 |         }
101 |     }
102 |     init_comet(&virtualMachine);
103 | 
104 |     initArgv(&virtualMachine, argc, argv);
105 |     const char *version_string = stringify_value(VERSION_STRING);
106 |     addGlobal(
107 |         copyString(&virtualMachine, "COMET_VERSION", 13),
108 |         copyString(&virtualMachine, version_string, strlen(version_string)));
109 | 
110 |     if (argc == 1)
111 |     {
112 |         repl();
113 |     }
114 |     else if (argc >= 2)
115 |     {
116 |         runFile(argv[startingArg-1]);
117 |     }
118 |     else
119 |     {
120 |         fprintf(stderr, "Usage: comet [path]\n");
121 |         exit(64);
122 |     }
123 | 
124 | #ifdef WIN32
125 |     socket_cleanup();
126 | #endif
127 |     finalizeGarbageCollection();
128 |     freeVM(&virtualMachine);
129 |     freeGlobals();
130 |     return 0;
131 | }


--------------------------------------------------------------------------------
/docs/CNAME:
--------------------------------------------------------------------------------
1 | cometlang.com


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
1 | remote_theme: pages-themes/dinky@v0.2.0
2 | plugins:
3 | - jekyll-remote-theme # add this line to the plugins list if you already have one
4 | github:
5 |   zip_url: https://github.com/cometlang/comet/releases/latest


--------------------------------------------------------------------------------
/docs/_layouts/default.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="{{ site.lang | default: "en-US" }}">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 | 
 7 | {% seo %}
 8 |     <link rel="stylesheet" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}">
 9 |     <script src="{{ '/assets/js/scale.fix.js' | relative_url }}"></script>
10 |     <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
11 |     <!--[if lt IE 9]>
12 |     <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
13 |     <![endif]-->
14 |     {% include head-custom.html %}
15 |   </head>
16 |   <body>
17 |     <div class="wrapper">
18 |       <header>
19 |         <h1 class="header">{{ site.title | default: site.github.repository_name }}</h1>
20 |         <p class="header">{{ site.description | default: site.github.project_tagline }}</p>
21 | 
22 |         <ul>
23 |           {% if site.show_downloads %}
24 |             <li class="download"><a class="buttons" href="{{ site.github.zip_url }}">Latest Release</a></li>
25 |           {% endif %}
26 |           <li><a class="buttons github" href="{{ site.github.repository_url }}">View On GitHub</a></li>
27 |         </ul>
28 | 
29 |         {% if site.github.is_project_page %}
30 |           <p class="header">This project is maintained by <a class="header name" href="{{ site.github.owner_url }}">{{ site.github.owner_name }}</a></p>
31 |         {% endif %}
32 | 
33 |         {% if site.github.is_user_page %}
34 |           <ul>
35 |             <li><a class="buttons github" href="{{ site.github.owner_url }}">GitHub Profile</a></li>
36 |           </ul>
37 |         {% endif %}
38 |       </header>
39 | 
40 |       <section>
41 |         {{ content }}
42 |       </section>
43 | 
44 |       <footer>
45 |         <p><small>Hosted on <a href="https://pages.github.com">GitHub Pages</a> using the Dinky theme</small></p>
46 |       </footer>
47 |     </div>
48 |     <!--[if !IE]><script>fixScale(document);</script><![endif]-->
49 |   </body>
50 | </html>
51 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
 1 | # The Comet Programming Language
 2 | 
 3 | # [Syntax](syntax/index.md)
 4 | # [Stdlib](stdlib/index.md)
 5 | 
 6 | Comet was created with the help of [Crafting Interpreters](https://www.craftinginterpreters.com) by Bob Nystrom
 7 | 
 8 | Comet is in the C family of languages and is object-oriented.  It liberally borrows from other languages, such as Python, Ruby, and JavaScript to name a few.  I've tried to keep the semantics unsurprising and the novelty-factor low.  So why would you want to use this instead of say, Python, Ruby or JavaScript?
 9 | 
10 | 1. It's small. At less than 2MB (including the standard libary in a single executable) it's ideal for an embedded environment
11 | 2. It's a self-contained language.  Many scripting languages require you to understand the low-level C programming
12 | techniques in order to use them (like the file modes for fopen, or the socket dance).  I've attempted to abstract
13 | those APIs into a more naturally comet style.
14 | 3. It's learned from (some of) the mistakes of some of its inspirational languages
15 |   - Ruby's heavy use of optional syntax often makes it difficult to understand what's happening
16 |   - Python attempts to search large portions of the filesystem when it imports modules
17 |   - JavaScript's type-coercion makes for error-prone code
18 |   - C's (lack of) memory management is one of the major sources of security bugs in the world
19 |   - Python's dogmatic approach to whitespace means that many useful constructs just aren't reasonable to implement
20 |   - C#'s empty `throw;` statement is often forgotten
21 |   - JavaScript's many exceptions to the rule make programming it very error-prone
22 |   - Java's verbose syntax make it very unfriendly to programmers and keyboards alike
23 |   - C++'s compilation rules and templating system make reasoning about programs very challenging
24 | 
25 | ## Drawbacks
26 | - Currently, the math operations are _very_ slow.  Because of how operator overloading is implemented, all math operations incur the cost of an object function call with virtual method resolution.
27 | - The garbage collection is pretty basic, naive and slow.  For every garbage collection, we iterate through every object in the system, which is _much_ more than necessary.  A relatively straight forward improvement would be to implement a generational system.  Also, all memory operations on all threads come to a halt when the GC is running (which essentially means all execution stops).
28 | 


--------------------------------------------------------------------------------
/docs/stdlib/argument_exception.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## ArgumentException
 4 | inherits [Exception](exception.md)
 5 | 
 6 | ### static methods
 7 | - `throw_if_nil()` throw an ArgumentException if the given value is `nil`
 8 | - `throw_if_empty()` throw an ArgumentException if the given value returns `true` to `empty?` (which `nil` does)
 9 | - `throw_if_nil_or_empty()` throw an ArgumentException if the given value is `nil` or returns `true` to `empty?`
10 | - `throw_if_nil_or_whitespace()` throw an ArgumentException if the given value is `nil`, returns `true` to `empty?` or is a string made up of entirely whitespace characters.  This will also throw an ArgumentException itself if the given value is neither `nil` nor a [String](string.md). 
11 | 


--------------------------------------------------------------------------------
/docs/stdlib/boolean.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Boolean
 4 | inherits [Object](object.md)
 5 | 
 6 | There are two singleton instances of Boolean in the interpreter accessible via the keywords `true` and `false`
 7 | 
 8 | ### constructor
 9 | Boolean(value)
10 | Takes a single argument, and converts to a boolean, based on the truthiness of the value.
11 | 
12 | ### methods
13 | - `to_string()` returns either "true" or "false"
14 | 
15 | ### static methods
16 | - `parse(value)` parses either a string (case insensitively) or an integer (following the C rules) or falling back to the truthiness of the value
17 | 
18 | ### operators
19 | - `==` compares by truthiness
20 | 


--------------------------------------------------------------------------------
/docs/stdlib/csv.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## csv
 4 | This is currently an aspirational csv parser.  It is aspirational, because the implementation
 5 | as it stands, is `string.split(',')`.  It will get better.
 6 | 
 7 | ### functions
 8 | 
 9 | - `parse_from_string(str, has_header = false)` parse the csv using an in-memory string
10 | - `parse_from_file(filename, has_header = false)` parse the csv using the given filename to open the file
11 | 
12 | Both of these functions return an iterable containing a `CsvRow` which is itself iterable, and will maintain
13 | the order as specified in the source.


--------------------------------------------------------------------------------
/docs/stdlib/datetime.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Datetime
 4 | inherits [Object](object.md)
 5 | 
 6 | ## methods
 7 | - `init([year],[month],[day],[hour],[minute],[seconds],[milliseconds])` Create a datetime in the current timezone from the given values.
 8 | - `to_string()` outputs a string representation of the datetime in a json-compliant ISO8601 format.  yyyy-mm-ddTHH:MM:ss.mmmZ
 9 | - `year()` get the year portion of the datetime
10 | - `month()` get the month portion of the datetime
11 | - `day()` get the day portion of the datetime
12 | - `hours()` get the hours portion of the datetime
13 | - `minutes()` get the minutes portion of the datetime
14 | - `seconds()` get the seconds portion of the datetime
15 | - `milliseconds()` get the milliseconds portion of the datetime
16 | 
17 | ### static methods
18 | - `now()` returns a DateTime representing the current local time
19 | - `parse('to_parse', ['format'])` parse a [String](string.md) into a DateTime. See [here](https://en.cppreference.com/w/cpp/chrono/parse) for format string specifiers.  `format` defaults to '%Y-%m-%dT%H:%M:%6S%z' which will parse the output of `DateTime::to_string()`
20 | 
21 | ### operators
22 | - `-` subtracts either a datetime or a duration to the existing datetime.  The returned type is the same as the operand.
23 | - `==` compares two datetimes and returns true if they both represent the same point in time
24 | 


--------------------------------------------------------------------------------
/docs/stdlib/directory.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Directory
 4 | inherits [Object](object.md)
 5 | 
 6 | ### methods
 7 | - `parent()` converts the directory to an absolute path and returns the parent Directory
 8 | - `absolute()` gets the Directory representing the absolute path
 9 | - `list()` returns a [List](list.md) of Directory objects containing the contents of the directory.  Does not include the pseudo paths of '.' and '..'
10 | - `to_string()` returns the path of the directory as a [String](string.md)
11 | 
12 | ### static methods
13 | - `list(path)` returns a [List](list.md) of Directory objects containing the contents of the directory.  Does not include the pseudo paths of '.' and '..'
14 | - `directory?(path)` returns a [Boolean](boolean.md) if the given path is a directory
15 | - `remove(path, [recursively])` deletes a directory from the filesystem, optionally deleting the contents first
16 | - `delete(path, [recursively])` alias for remove
17 | - `create(path)` creates the given directory and all parent directories required
18 | 


--------------------------------------------------------------------------------
/docs/stdlib/duration.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Duration
 4 | inherits [Object](object.md)
 5 | 
 6 | Represents a span of time, but not a point in time.
 7 | 
 8 | 
 9 | ### constructor
10 |  - `Duration([years], [months], [days], [hours], [minutes], [seconds], [milliseconds])` creates a duration representing the given time periods. If none of the time periods are given, a duration of 0 is created.   
11 | 
12 | ### methods
13 |  - `to_string()` returns a representation of the duration in nanoseconds with the ns unit appended
14 | 
15 | ### static methods
16 |  - `from_years(years)` creates a duration representing the number of years given
17 |  - `from_months(months)` creates a duration representing the number of months given
18 |  - `from_days(days)` creates a duration representing the number of days given
19 |  - `from_hours(hours)` creates a duration representing the number of hours given
20 |  - `from_minutes(minutes)` creates a duration representing the number of minutes given
21 |  - `from_seconds(seconds)` creates a duration representing the number of seconds given
22 |  - `from_milliseconds(milliseconds)` creates a duration representing the number of milliseconds given
23 | 
24 | ### operators
25 |  - `+` adds either a datetime or a duration to the existing duration.  The returned type is the same as the operand.
26 | 


--------------------------------------------------------------------------------
/docs/stdlib/enum.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Enum
 4 | inherits [Iterable](iterable.md)
 5 | 
 6 | Not intended to be instantiated directly, but rather through the `enum NAME {}` syntax
 7 | 
 8 | ### methods
 9 | - `add(name, value)` adds a value to the enum with the given name string and number value
10 | - `length()` returns the number of values in the enum
11 | - `contains?(value)` returns `true` if the given [EnumValue](#enumvalue) is part of this enum
12 | 
13 | ### static methods
14 | - `parse(value)` parses either an enum name, or an integer to the corresponding [EnumValue](#enumvalue).  Returns `nil` if no corresponding [EnumValue](#enumvalue) could be found in this enum.
15 | 
16 | 
17 | ## EnumValue
18 | inherits [Number](number.md)
19 | 
20 | Not intended to be instantiated directly.
21 | 
22 | Acts like a number, because that's pretty useful in an enum value, but has a couple of extra methods / fields.
23 | 
24 | ### constructor
25 | - `EnumValue(name, value)` sets the corresponding fields name and value, along with initialising the number
26 | 
27 | ### fields
28 | - `name` returns the [String](string.md) representing the enum name
29 | - `value` returns the [Number](number.md) representing the enum value
30 | 
31 | ### methods
32 | - `to_string()` returns a string of the form `[name]:[value]`, e.g. `my_enum_value:64`
33 | 


--------------------------------------------------------------------------------
/docs/stdlib/env.md:
--------------------------------------------------------------------------------
1 | [up](index.md)
2 | 
3 | ## ENV
4 | A singleton object that gives access to the environment variables in the system.
5 | 
6 | ## operators
7 | - `[varname]` returns a string with the value of the environment variable.  Throws an [Exception](exception.md) if there was no environment variable with that name.
8 | - `[varname]=value` Sets an environment variable of name `varname` to `value`.  Throws an [Exception](exception.md) if the value is not a [String](string.md). If `value` is [nil](nil.md) it unsets the environment variable


--------------------------------------------------------------------------------
/docs/stdlib/exception.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Exception
 4 | inherits [Object](object.md)
 5 | 
 6 | ### constructor
 7 | Exception(message)
 8 | 
 9 | ### fields
10 | - `stacktrace` the string representation of the stacktrace
11 | 
12 | ### methods
13 | - `message()` gets the message set in the constructor
14 | 
15 | ## Known Subclasses
16 |  - `AssertionException`
17 |  - [ArgumentException](argument_exception.md)
18 |  - `IOException`
19 |  - `SocketException`
20 |  - `TimeoutException`
21 |  - `KeyNotFoundException`
22 |  - `IndexOutOfBoundsException`
23 |  - `MethodNotFoundException`
24 |  - `ImportException`
25 |  - `ThreadException`
26 |  - `FormatException`
27 |  - `InvokeException`


--------------------------------------------------------------------------------
/docs/stdlib/file.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## File
 4 | inherits [Object](object.md)
 5 | 
 6 | ## Enum - FOPEN
 7 |  - `READ_ONLY`
 8 |  - `READ_WRITE`
 9 |  - `APPEND`
10 |  - `BINARY`
11 | 
12 | ### methods
13 | - `close()` closes the file
14 | - `write(value)` writes the value to the file
15 | - `read()` reads the entire content of the file into a [String](string.md) and return it
16 | - `sync()` calls the system call `fsync` to synchronize the filesystem into which the file is written
17 | - `flush()` calls the system call `fflush` to ensure the file buffers are written to the physical media
18 | 
19 | ### static methods
20 | - `open(path, flags)` opens a file with an FOPEN flag optionally bitwise-or'd with `FOPEN.BINARY` (binary is not implemented correctly and will still attempt to return a string)
21 | - `exists?(path)` returns a [Boolean](boolean.md) value if the current process can see the existence of the path, per the rules of the OS/filesystem
22 | - `file?(path)` returns a [Boolean](boolean.md) if the given path is a regular file
23 | - `read_all_lines(path)` opens the path for reading as text, returning a [List](list.md) of the individual lines, closing the file when finished
24 | - `delete(path)` deletes the file at the path 
25 | - `join_path(path, [components]*)` joins the path and the following path components with the OS-dependent path separator and returns a string representation of it
26 | 


--------------------------------------------------------------------------------
/docs/stdlib/function.md:
--------------------------------------------------------------------------------
1 | [up](index.md)
2 | 
3 | ## Function
4 | A class representing comet Functions defined
5 | 
6 | ## methods
7 | - `name()` returns a [String](string.md) with the name of the function object 
8 | - `attributes()` returns a [List](list.md) of any attributes declared on the function


--------------------------------------------------------------------------------
/docs/stdlib/hash.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Hash
 4 | inherits [Iterable](iterable.md)
 5 | final
 6 | 
 7 | This is known collectively as a Hash, Hash Table, Dictionary and probably other names.  It can be instantiated with a literal `{}` or statically initalized with `{key: value, ...}`
 8 | 
 9 | ### methods
10 | - `add(key, value)` add a value to the hash with key
11 | - `remove(key)` removes the value and key from the hash
12 | - `to_string()` returns a String representation of the hash
13 | - `get(key, default=nil)` returns the value found by `key` otherwise returns the default value if key doesn't have an entry in the hash.
14 | - `has_key?(key)` returns a boolean for whether the hash has the given key
15 | 
16 | ### operators
17 | - `==` iterates through the keys and values of each hash and returns true if they have the same contents (or are the same instance)
18 | - `[]` takes an object as the key and returns the associated value, e.g. `hash[some_object]`
19 | - `[]=` assigns a value to the given key, e.g. `hash[some_object] = "some string"`
20 | 


--------------------------------------------------------------------------------
/docs/stdlib/image.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Image
 4 | inherits [Object](object.md)
 5 | 
 6 | The coordinate system for the images starts with 0,0 at the bottom-left and ends with (width-1),(height-1) at the top-right.  It is always in 24-bit colour, 8 bits per channel and does not currently support an alpha channel.  Jpegs are written at a constant 90 quality.
 7 | 
 8 | ## Enum - IMAGE_FORMAT
 9 |  - `PNG`
10 |  - `JPEG`
11 |  - `BMP`
12 | 
13 | ### constructor
14 |  - `Image(width, height)` creates an image of width x height pixels
15 | 
16 | ### methods
17 |  - `set_pixel(x, y, r, g, b)` sets the pixel colour at coordinates x, y to the colour values (0-255) of r,g,b
18 |  - `write_to_file(filename, format)` writes the image to the filename, in the given format (a value of the `IMAGE_FORMAT` enum)
19 |  - `width()` gets the number of pixels in the x axis of the image
20 |  - `height()` gets the number of pixels in the y axis of the image
21 | 
22 | ### static methods
23 |  - `read(filename)` reads the image
24 | 


--------------------------------------------------------------------------------
/docs/stdlib/index.md:
--------------------------------------------------------------------------------
 1 | [up](../index.md)
 2 | 
 3 | # Classes
 4 | 
 5 | - [Object](object.md)
 6 | - [ArgumentException](argument_exception.md)
 7 | - [Boolean](boolean.md)
 8 | - [Datetime](datetime.md)
 9 | - [Directory](directory.md)
10 | - [Duration](duration.md)
11 | - [Enum](enum.md)
12 | - [ENV](env.md)
13 | - [Exception](exception.md)
14 | - [File](file.md)
15 | - [Function](function.md)
16 | - [Hash](hash.md)
17 | - [Image](image.md)
18 | - [Iterable](iterable.md)
19 | - [List](list.md)
20 | - [Module](module.md)
21 | - [Nil](nil.md)
22 | - [Number](number.md)
23 | - [Set](set.md)
24 | - [Socket](socket.md)
25 | - [String](string.md)
26 | - [StringBuilder](string_builder.md)
27 | - [Thread](thread.md)
28 | - [Thread Synchronisation Primitives](thread_synchronisation.md)
29 | - [UnitTest](unittest.md)
30 | 
31 | # Modules
32 | - [csv](csv.md)
33 | - [json](json.md)
34 | - [unittest](unittest.md)
35 | 
36 | # Functions
37 | ## clock
38 | - `clock()` returns a [Number](number.md) representing the fractional number of seconds of CPU time the process has used
39 | 
40 | ## print
41 | - `print([...])` print every argument by first calling `to_string()` on it first, ending with a newline
42 | 
43 | ## print_to
44 | - `print_to(STD_STREAM, [...])` print every argument by first calling `to_string()` on it first, ending with a newline.  It will print it to the given stream.  The options are STD_STREAM.OUT and STD_STREAM.ERR
45 | 
46 | ## input
47 | - `input([prompt])` print the prompt (no newline) if given and then wait for a line of input, returning it as a [String](string.md).  Gets a maximum of 512 bytes in one line.
48 | 
49 | ## get_password
50 | - `get_password([prompt])` print the prompt (no newline) if given and then wait for a line of input, returning it as a [String](string.md).  Does not echo the input.  Gets a maximum of 512 bytes in one line.
51 | 
52 | ## assert
53 | - `assert(value)` if value is falsy, then an AssertionException is thrown
54 | 
55 | ## callable?
56 | - `callable?(value)` returns `true` if the value can be called (like a function)
57 | 
58 | ## sleep
59 | - `sleep(time)` stops the execution of the current thread for at least the fractional seconds provided.
60 | 
61 | ## exit
62 | - `exit(exit_status)` simple wrapper for the C function to exit the program with the given return code.  Makes no attempt to clean anything up.
63 | 
64 | ## get_imported_modules
65 | - `get_imported_modules()` gets all of the [Modules](module.md) currently imported to the interpreter
66 | 
67 | ## call_function
68 | - `call_function(receiver, method, [arguments, ...])` calls the method on the receiver.  If the method is a function object, then the receiver may be `nil`.  If the method is a name of a method (a string), then the receiver must be an instance.
69 | 


--------------------------------------------------------------------------------
/docs/stdlib/iterable.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Iterable
 4 | inherits [Object](object.md)
 5 | 
 6 | Functions as an abstract class in other languages, where it has only minimal functionality and relies on the concrete implementation
 7 | to provide the basic methods.
 8 | 
 9 | ### methods
10 | - `contains?(value)` (abstract) returns `true` if the value is contained in the iterable
11 | - `empty?()` (abstract) returns `true` if the iterable has no items
12 | - `iterator()` (abstract) returns an [Iterator](#iterator)
13 | - `min()` returns the minimum value as determined by the `<` operator
14 | - `max()` returns the maximum value as determined by the `<` operator
15 | 
16 | ## Iterator
17 | inherits [Object](object.md)
18 | 
19 | This is just an interface, but shows what should be returned by the `iterator` method of [Iterable](#iterable)
20 | 
21 | ### methods
22 | - `has_next?()` (abstract) returns `true` if there is another item in the sequence
23 | - `get_next()` (abstract) returns the next item in the sequence
24 | 


--------------------------------------------------------------------------------
/docs/stdlib/json.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## json
 4 | This is a pure comet json parser.  It might one day grow to include a json serialiser.
 5 | 
 6 | ### functions
 7 | 
 8 | - `parse_from_string(str)` parse the json using an in-memory string
 9 | - `parse_from_file(filename)` parse the json using the given filename to open the file
10 | 
11 | Both of these functions return a hash for objects and a list for arrays.  It does NOT detect datetimes
12 | and parse those - they will be returned as strings.


--------------------------------------------------------------------------------
/docs/stdlib/list.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## List
 4 | inherits [Iterable](iterable.md)
 5 | final
 6 | 
 7 | This is technically an ArrayList, i.e. the memory is contiguous which makes indexing faster, at the cost of adding to the list might trigger a reallocation and that performance will linearly degrade as the list size increases.  It can be instantiated with a literal `[]` or statically initialized with `[value, "some string", ...]`
 8 | 
 9 | ### constructor
10 | - `List([initial_capacity])`
11 | If given an `initial_capactiy` then the list will be pre-allocated to contain that number of values.  This means the index-assign operator can then be used to sparsely populate the list.
12 | 
13 | ### methods
14 | - `add(value)` appends the value(s) to the end of the list - takes multiple arguments and will add them all to the list, in order.
15 | - `push(value)` alias for `add`
16 | - `pop()` removes and returns the value at the end of the list
17 | - `get_at(index)` returns the value at the given index, but does not remove it from the list
18 | - `to_string()` returns a string representation of the list
19 | - `size()` returns the number of items stored in the list
20 | - `length()` alias for `size()`
21 | - `sort()` sorts the list in-place and returns a reference to the list. It uses Timsort, a stable sort running in O(n log n) time.
22 | - `filter()` takes a callable object which is called with every item, returning `true` if the item should be part of the list returned.  The list returned is a new object and the initial list is left unchanged.
23 | - `map(lambda)` returns a list of values as mapped by the lambda, which is called with each item in the list
24 | - `reduce(initial, lambda)` given an intial value, the lambda is called with the current reduction, each item in the list, and the index in the list, e.g. `list.reduce(0, |current, item, index| { return curent + 1 })`
25 | 
26 | ### operators
27 | - `==` compares the contents of the list to another list to see if the contents (and order!) are identical
28 | - `[]` returns the value at the given index (must be an integer)
29 | - `[]=` assigns the given value to the given index (which must be an integer)
30 | - `+` appends all the items in the argument list to the original


--------------------------------------------------------------------------------
/docs/stdlib/module.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Module
 4 | inherits [Object](object.md)
 5 | final
 6 | 
 7 | Not intended to be instantiated directly.  All imported modules will be an instance of this class.
 8 | 
 9 | ### methods
10 | - `functions()` returns a [List](list.md) of the functions defined in the module.  This is defined as all fields that are callable and everything defined with the `function` keyword.  Does not include classes, even though they are considered callable.
11 | - `fields()` returns a [List](list.md) of names ([Strings](string.md)) of the fields defined in the module.
12 | - `filename()` returns a [String](string.md) representing the absolute path of the module
13 | 
14 | ### operators
15 | - `[key]` an index to the fields and functions using the name of the function (as a string) as the key
16 | 


--------------------------------------------------------------------------------
/docs/stdlib/nil.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Nil
 4 | inherits [Iterable](iterable.md)
 5 | final
 6 | 
 7 | Nil is a special class with exactly one instance - it cannot be instantiated.  It can be treated as a permanently empty iterable that will never have contents to iterate, but does not require checking for nil? before using in a foreach loop.
 8 | 
 9 | ### methods
10 | - `nil?()` Returns true
11 | - `to_string()` Returns the empty string "" (because checking for `nil?` can be cumbersome)
12 | - `empty?()` returns true
13 | 
14 | ### iterable
15 | Nil is an iterable that is permanently empty (because checking for `nil?` can be cumbersome)
16 | 


--------------------------------------------------------------------------------
/docs/stdlib/number.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Number
 4 | inherits [Object](object.md)
 5 | final
 6 | 
 7 | A number is a 64 bit floating point number.
 8 | 
 9 | ### methods
10 | - `to_string()` returns a [String](string.md) representing the number
11 | - `square_root()` returns the square root of the number
12 | - `even?()` returns `true` if the number is evenly divisible by 2 
13 | - `floor()` returns the nearest whole integer, searching lower numbers
14 | - `ceiling()` returns the nearest whole integer, searching higher numbers
15 | - `power(n)` returns number raised to the power of `n`
16 | 
17 | ### static methods
18 | - `parse()` takes a string and parses it into a `Number`.  Returns [nil](nil.md) if the string couldn't be parsed into a number.
19 | - `max(n, m)` returns the maximum value between `n` and `m` or `m` if they are the same
20 | - `min(n, m)` returns the minimum value between `n` and `m` or `m` if they are the same
21 | - `random([seed])` returns a random value between 0 and 1.0 - this is NOT suitable for cryptography. Optionally
22 | allows a seed to be specified. The seed should be able to fit into a 32 bit integer.
23 | 
24 | ### operators
25 | - `==` compares the two objects to see if they're the same instance
26 | - `-`  performs the mathmatical subtraction operation
27 | - `+`  performs the mathmatical addition operation
28 | - `*`  performs the mathmatical multiplication operation
29 | - `/`  performs the mathmatical division operation (floating point)
30 | - `%`  performs the mathmatical remainder operation (casts both operands to uint64_t)
31 | - `>`  performs the strict greater than comparision
32 | - `>=` performs the greater than or equal to comparision
33 | - `<`  performs the strict less than comparision
34 | - `<=` performs the less than or equal to comparision
35 | - `~` bitwise negates the number
36 | - `<<` bitwise left shift the argument number of bits
37 | - `>>` bitwise right shift the argument number of bits
38 | - `|` bitwise inclusive or
39 | - `&` bitwise and
40 | - `^` bitwise exclusive or
41 | 
42 | All bitwise operations are performed as though the number is a signed 64 bit integer


--------------------------------------------------------------------------------
/docs/stdlib/object.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Object
 4 | The base class for all Objects
 5 | 
 6 | ### methods
 7 | - `nil?()` Returns a Boolean as to whether the instance is nil or not
 8 | - `hash()` Returns a hash value for this object
 9 | - `to_string()` Returns a String representation of this object
10 | - `methods()` Returns a [List](list.md) of [Strings](string.md) with the names of all callables on the object
11 | - `fields()` Returns a [List](list.md) of [Strings](string.md) of all the fields on the object
12 | 
13 | ### static methods
14 | - `to_string()` Returns a string representation of the class
15 | - `hash()` This is identical to the non-static method, but added such that classes can be used as a key to a hash
16 | 
17 | ### operators
18 | - `==` compares if the two objects are the same instance
19 | 


--------------------------------------------------------------------------------
/docs/stdlib/set.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Set
 4 | inherits [Iterable](iterable.md)
 5 | final
 6 | 
 7 | WARNING: known to be broken
 8 | 
 9 | ### methods
10 | - `add(value)` adds a value to a set.  Returns `true` if the value was added, `false` if the value was already contained in the set
11 | - `remove(value)` removes a value from a set. Silently does nothing if the value was never in the set
12 | - `union(set)` Returns a new Set with the combined values of both sets
13 | - `intersect(set)` Returns a new Set containing the values that were in both sets
14 | - `difference(set)` Returns a new Set with the values in the callee that are not in the argument Set
15 | - `to_list()` Returns a list of the values in the Set. Not guaranteed to be in any specific order
16 | - `to_string()` Returns a string representation of the Set.
17 | - `empty?()` Returns `true` if there are no values in the Set.
18 | - `count()` Returns the number of values in the Set.`
19 | 
20 | ### operators
21 | - `|` performs a union
22 | - `&` performs an intersection
23 | - `-` performs a difference
24 | 
25 | 


--------------------------------------------------------------------------------
/docs/stdlib/socket.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Enum - SOCKET_TYPE
 4 |  - `TCP`
 5 |  - `UDP`
 6 |  - `RAW`
 7 | 
 8 | ## Enum - ADDRESS_FAMILY
 9 |  - `UNIX`
10 |  - `IPv4`
11 |  - `IPv6`
12 |  - `NETLINK`
13 | 
14 | ## Socket
15 | 
16 | ### constructor
17 | Socket(SOCKET_TYPE, ADDRESS_FAMILY)
18 | 
19 | ## static methods
20 |  - `open(SOCKET_TYPE, ADDRESS_FAMILY)`
21 | 
22 | ## methods
23 |  - `close()` Closes the socket
24 |  - `bind(address, port)` binds the socket to an address and port. `address` is a string-based representation of the address.  The format must match the address family specified when creating the socket.
25 |  - `accept()` accepts incoming connections, returning a new [Socket](#socket) for each successful connection
26 |  - `listen(queue_length)` marks the socket as listening, ready to `accept` incoming connections.
27 |  - `connect(address, port)` make an outbound connection to a specific endpoint
28 |  - `read()` returns a [String](string.md) of any values read
29 |  - `write(string)` writes a [String](string.md) to the socket
30 | 


--------------------------------------------------------------------------------
/docs/stdlib/string.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## String
 4 | inherits [Iterable](iterable.md)
 5 | final
 6 | 
 7 | All strings are UTF-8 encoded
 8 | 
 9 | ### methods
10 | - `left_trim()` returns a new string with all whitespace characters from the left of the string removed
11 | - `right_trim()` returns a new string with all whitespace characters from the right of the string removed
12 | - `trim()` returns a new string with all whitespace characters from the left and right sides removed
13 | - `split(str)` returns a [List](list.md) of the string portions in between any instances of `str`
14 | - `replace(value, replacement)` returns a new string with all instances of `value` replaced by `replacement`
15 | - `starts_with?(value)` returns `true` if the string begins exactly with value, otherwise `false`
16 | - `ends_with?(value)` returns `true` if the string ends exactly with value, otherwise `false`
17 | - `to_lower()` returns a new string with all uppercase letters replaced with their lowercase counterparts
18 | - `to_upper()` returns a new string with all lowercase letters replaced with their uppercase counterparts
19 | - `to_string()` returns self
20 | - `value()` returns the numerical value of the string.  e.g. `'a'.value()` returns `97`
21 | - `substring(start, [length])` returns the substring starting at the (zero-based) index of the codepoint of either the length specified or to the end of the string
22 | - `length()` returns the number of codepoints (~letters) in the string.
23 | - `count()` alias of length()
24 | - `number?()` returns true if the string _only_ contains characters that can be parsed into a single number
25 | - `whitespace?()` returns true if the string _only_ contains whitespace characters
26 | 
27 | ### static methods
28 | - `format(msg, ...)` formats a string, replacing instances of `{n}` with the nth (zero-based) index of
29 |     argument after msg.  e.g. `String.format('this is {0} string with {0} replacement', 'a')` results in
30 |     `'this is a string with a replacement'`
31 |     a `{` or `}` can be escaped by doubling them up.  e.g. `String.format('this is {{0}} string with {0} replacement', a)` results in `'this is {0} string with a replacement'`
32 | 
33 | ### operators
34 | - `==` compares if the two strings are equal in a case-sensitive manner
35 | - `+` concatenates an object (calling its `to_string()` method) onto this string, returning a new String.  The existing string is left unchanged
36 | - `[]` gets the character (codepoint) at the given index, returned as a new string


--------------------------------------------------------------------------------
/docs/stdlib/string_builder.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## String
 4 | inherits [Object](object.md)
 5 | final
 6 | 
 7 | A StringBuilder is a way of creating a string that can be appended to without the overhead of extra allocations and general interning that each regular string will incur.
 8 | 
 9 | ### methods
10 | - `append()` concatenates a [String](string.md) onto this string builder in place
11 | 
12 | ### operators
13 | - `+` concatenates a [String](string.md) onto this string builder in place
14 | 


--------------------------------------------------------------------------------
/docs/stdlib/thread.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | WARNING:
 4 | Threads are known to not work particularly well.  They cause problems with the Garbage Collection, so
 5 | random segfaults that don't occur with non-threaded code, is likely because of threads.  One day I might
 6 | re-write the GC to be reference-counted, so this issue will go away.
 7 | 
 8 | ## Thread
 9 | inherits [Object](object.md)
10 | final
11 | 
12 | This is a real Thread with all the problems and performance that come with that.  See also [Thread Synchronisation](thread_synchronisation.md)
13 | 
14 | ### methods
15 | - `start(callable, arg)` starts a new OS thread by calling the callable with the argument
16 | - `join()` waits until the thread finishes and collects the thread
17 | 


--------------------------------------------------------------------------------
/docs/stdlib/thread_synchronisation.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## Mutex
 4 | inherits [Object](object.md)
 5 | 
 6 | A mutual exclusion thread synchronisation primitive.  If locked, then only the thread holding the lock may enter the critical section, safeguarding against multiple threads mutating the state simultaneously.
 7 | 
 8 | ### methods
 9 |  - `lock()` block until the lock can be obtained
10 |  - `timed_lock(timeout)` block for (timeout) seconds (may be fractional) and either the lock is obtained or a `TimeoutException` is thrown.
11 |  - `unlock()` release the lock, allowing the next waiting thread to gain the lock.  The thread owning the lock must call unlock.
12 |  - `try_lock()`  Attempt to get the lock or immediately return.  A [Boolean](boolean.md) value will be returned indicating whether the lock was gained successfully.
13 | 
14 | 
15 | ## ConditionVariable
16 | inherits [Object](object.md)
17 | 
18 | ### methods
19 |  - `wait()` Waits until the condition is signalled (blocking) 
20 |  - `signal_one()` signals a single waiting thread that the condition is met
21 |  - `signal_all()` signals all waiting threads that the condition is met.  The kernel scheduler will determine which thread gains the lock.
22 |  - `timed_wait(timeout)` Wait for a limited amount of fraction seconds.  A `TimeoutException` is thrown if the interval elapses before the condition is signalled.
23 | 
24 | 


--------------------------------------------------------------------------------
/docs/stdlib/unittest.md:
--------------------------------------------------------------------------------
 1 | [up](index.md)
 2 | 
 3 | ## unittest
 4 | A basic unit testing framework
 5 | 
 6 | Can be run as a script to run other tests.  All `function`s in the module that start with the name `test_` are determined to be tests to run.
 7 | 
 8 | test_script.cmt:
 9 | ```
10 | import 'unittest' as unittest
11 | 
12 | function test_a_thing() {
13 |     unittest.Assert.that('this is a string').is_not_nil()
14 | }
15 | ```
16 | 
17 | `comet unittest [--coverage] test_script.cmt`
18 | 
19 | The script will exit with a non-zero exit code if any of the tests fail.
20 | 
21 | If the `--coverage` parameter is specified, then a json document with the count of the number of times each line was executed, along with the per-function and per-file totals and percentages called `.coverage.json` in the current directory is created.
22 | 
23 | ### classes
24 | - `Assert`
25 | 
26 | #### static methods
27 | - `that(value)` returns an instance of `Assert`, initialised with the value to be tested against
28 | - `fail([message])` fails the test, optionally giving a message for why the test failed
29 | - `pass()`
30 | 
31 | #### methods
32 | - `is_nil(message)` asserts that the value is nil, optionally giving a message when the assertion fails
33 | - `is_not_nil(message)` asserts that the value is not nil, optionally giving a message when the assertion fails
34 | - `is_equal_to(expected, message)` asserts that the value is equal to (as determined by the `==` operator) to the expected, optionally giving a message when the assertion fails
35 | - `is_not_equal_to(expected, message)` asserts that the value is not equal to (as determined by the negation of the `==` operator) to the expected, optionally giving a message when the assertion fails
36 | - `is_true(message)` asserts that the value is true, optionally giving a message when the assertion fails
37 | - `is_false(message)` asserts that the value is false, optionally giving a message when the assertion fails
38 | - `contains(expected, message)` asserts that the value contains the expected (as determined by calling `value.contains?(expected)`), optionally giving a message when the assertion fails
39 | - `does_not_contain(expected, message)` asserts that the value does not contain the expected (as determined by calling `!value.contains?(expected)`), optionally giving a message when the assertion fails
40 | - `matches(expected, message)` asserts that the value matches the expect.  Determined by either calling expected if the expected is callable, returning a boolean or falling back to the `==` operator, optionally giving a message when the assertion fails
41 | - `throws(message)` asserts that the value throws an exception (other than an AssertionException) when it is called, optionally giving a message when the assertion fails. Throws an ArgumentException itself if the value is not callable.
42 | - `does_not_throw(message)` asserts that the value does not throw an exception when called, optionally giving a message when the assertion fails. Throws an ArgumentException itself if the value is not callable.
43 | - `is_of_type(type, message)` asserts that the value `is` the given type, optionally giving a message for when the assertion fails
44 | - `is_empty(message)` asserts that the value returns `true` to `empty?()`, optionally giving a message for when the assertion fails
45 | - `is_not_empty(message)` asserts that the value returns `false` to `empty?()`, optionally giving a message for when the assertion fails
46 | - `is_callable(message)` asserts that the value is callable 
47 | 
48 | 


--------------------------------------------------------------------------------
/grammar.md:
--------------------------------------------------------------------------------
 1 | ```
 2 | program        → declaration* EOF ;
 3 | 
 4 | declaration    → classDecl
 5 |                | funDecl
 6 |                | varDecl
 7 |                | statement ;
 8 | 
 9 | classDecl      → "class" IDENTIFIER ( "<" IDENTIFIER )?
10 |                  "{" method* "}" ;
11 | funDecl        → "fun" function ;
12 | varDecl        → "var" IDENTIFIER ( "=" expression )? EOL ;
13 | 
14 | statement      → exprStmt
15 |                | forStmt
16 |                | ifStmt
17 |                | printStmt
18 |                | returnStmt
19 |                | whileStmt
20 |                | throwStmt
21 |                | block ;
22 | 
23 | exprStmt       → expression EOL ;
24 | forStmt        → "for" "(" ( varDecl | exprStmt | ";" )
25 |                            expression? ";"
26 |                            expression? ")" EOL? statement ;
27 | ifStmt         → "if" "(" expression ")" statement ( "else" statement )? ;
28 | printStmt      → "print" expression EOL ;
29 | returnStmt     → "return" expression? EOL ;
30 | whileStmt      → "while" "(" expression ")" statement EOL? ;
31 | throwStmt      → "throw" expression EOL ;
32 | block          → "{" declaration* "}" ;
33 | 
34 | expression     → assignment ;
35 | 
36 | assignment     → ( call "." )? IDENTIFIER "=" assignment
37 |                | logic_or;
38 | 
39 | logic_or       → logic_and ( "or" logic_and )* ;
40 | logic_and      → equality ( "and" equality )* ;
41 | equality       → comparison ( ( "!=" | "==" ) comparison )* ;
42 | comparison     → addition ( ( ">" | ">=" | "<" | "<=" ) addition )* ;
43 | addition       → multiplication ( ( "-" | "+" ) multiplication )* ;
44 | multiplication → unary ( ( "/" | "*" ) unary )* ;
45 | 
46 | unary          → ( "!" | "-" ) unary | call ;
47 | call           → primary ( "(" arguments? ")" | "." IDENTIFIER  | "[" arguments? "]")* ;
48 | primary        → "true" | "false" | "nil" | "self"
49 |                | NUMBER | STRING | IDENTIFIER | "(" expression ")"
50 |                | "super" "." IDENTIFIER ;
51 | 
52 | method         → scope function
53 | function       → IDENTIFIER "(" parameters? ")" block ;
54 | parameters     → IDENTIFIER ( "," IDENTIFIER )* ;
55 | arguments      → expression ( "," expression )* ;
56 | 
57 | scope          → private | protected | public
58 | 
59 | NUMBER         → DIGIT+ ( "." DIGIT+ )? ;
60 | STRING         → '"' <any char except '"'>* '"' ;
61 | IDENTIFIER     → ALPHA ( ALPHA | DIGIT )* ;
62 | ALPHA          → 'a' ... 'z' | 'A' ... 'Z' | '_' ;
63 | DIGIT          → '0' ... '9' ;
64 | EOL            → '\n'
65 | ```
66 | 


--------------------------------------------------------------------------------
/sample.cmt:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/comet
 2 | import 'module' as Module
 3 | 
 4 | class MyClass : SomeOtherClass
 5 | {
 6 |     init(a)
 7 |     {
 8 |         self.a = a
 9 |         self.list = []
10 |         self.hash = {}
11 |         self.set = Set()
12 |     }
13 | 
14 |     this_is_a_method()
15 |     {
16 |         print("interpolated string ${self.a}")
17 |         print('literal string')
18 |     }
19 | 
20 |     this_is_a_different_method(a, b=1, c=nil)
21 |     {
22 |         while (expression)
23 |         {
24 |             self.my_iterative_method((|something|) {
25 |                 print(something)
26 |             })
27 |         }
28 |     }
29 | 
30 |     this_method_is_destructive!()
31 |     {
32 | 
33 |     }
34 | 
35 |     this_method_returns_a_bool?()
36 |     {
37 |         return false
38 |     }
39 | 
40 |     operator [] (arg)
41 |     {
42 |         print('This overloads how the operator identifier[1] will function')
43 |     }
44 | 
45 |     my_iterative_method(func)
46 |     {
47 |         foreach(var item in self.list)
48 |         {
49 |             func(item)
50 |         }
51 |     }
52 | }


--------------------------------------------------------------------------------
/stdlib/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.10)
 2 | enable_language(C)
 3 | enable_language(CXX)
 4 | project (stdlib)
 5 | 
 6 | include_directories(
 7 |   "${CMAKE_CURRENT_SOURCE_DIR}"
 8 |   ../comet
 9 |   ../vmlib
10 |   ../eral
11 |   ../stb)
12 | 
13 | set(SOURCE
14 |   _init.c
15 |   boolean.c
16 |   directory.cpp
17 |   duration.cpp
18 |   enum.cpp
19 |   env.cpp
20 |   exception.c
21 |   file_common.cpp
22 |   function.c
23 |   hash.cpp
24 |   image.c
25 |   iterable.c
26 |   list.cpp
27 |   module.c
28 |   native_functions.c
29 |   nil.c
30 |   number.c
31 |   object.c
32 |   process.cpp
33 |   set.cpp
34 |   socket.c
35 |   string.c
36 |   string_builder.c
37 |   system.c
38 |   thread.c
39 |   thread_synchronisation_common.c
40 |   colour.cpp
41 | )
42 | 
43 | if (WIN32)
44 | add_compile_definitions(WIN32=1)
45 | list(APPEND SOURCE file_win.cpp thread_synchronisation_win.c datetime_win.cpp)
46 | else()
47 | list(APPEND SOURCE file_unix.cpp thread_synchronisation_unix.c datetime_unix.cpp)
48 | endif()
49 | 
50 | add_library(stdlib STATIC "${SOURCE}")
51 | 
52 | if (WIN32)
53 | target_link_libraries(stdlib vmlib utf8proc ws2_32 date date-tz)
54 | else()
55 | target_link_libraries(stdlib vmlib utf8proc m date date-tz)
56 | endif (WIN32)
57 | 
58 | target_include_directories(stdlib PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/private" Threads::Threads)
59 | target_include_directories(stdlib PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
60 | 
61 | add_subdirectory(test)
62 | 
63 | add_subdirectory(comet)
64 | 


--------------------------------------------------------------------------------
/stdlib/_init.c:
--------------------------------------------------------------------------------
 1 | #include "comet.h"
 2 | #include "cometlib.h"
 3 | 
 4 | void init_comet(VM* vm)
 5 | {
 6 |     initGlobals();
 7 |     initVM(vm);
 8 |     init_stdlib(vm);
 9 |     common_strings[STRING_INIT] = copyString(vm, "init", 4);
10 |     common_strings[STRING_HASH] = copyString(vm, "hash", 4);
11 |     common_strings[STRING_TO_STRING] = copyString(vm, "to_string", 9);
12 |     common_strings[STRING_LAMBDA] = copyString(vm, "(|lambda|)", 10);
13 |     common_strings[STRING_EMPTY_Q] = copyString(vm, "empty?", 6);
14 |     common_strings[STRING_NUMBER] = copyString(vm, "Number", 6);
15 |     common_strings[STRING_SCRIPT] = copyString(vm, "<script>", 8);
16 |     common_strings[STRING_FUNCTION] = copyString(vm, "Function", 8);
17 |     common_strings[STRING_ADD] = copyString(vm, "add", 3);
18 | }
19 | 
20 | void init_stdlib(VM *vm)
21 | {
22 |     VALUE obj_klass = bootstrapNativeClass(vm, "Object", NULL, NULL, CLS_OBJECT, 0, false);
23 |     bootstrap_number(vm);
24 |     bootstrap_iterable(vm);
25 |     init_string(vm, obj_klass);
26 |     complete_number(vm);
27 |     init_nil(vm);
28 |     init_enum(vm);
29 |     init_boolean(vm);
30 |     init_exception(vm);
31 |     init_file(vm);
32 |     init_module(vm);
33 |     init_functions(vm);
34 |     init_list(vm);
35 |     init_hash(vm);
36 |     init_colour(vm);
37 |     init_image(vm);
38 |     init_datetime(vm);
39 |     init_duration(vm);
40 |     init_socket(vm);
41 |     init_thread(vm);
42 |     init_thread_sync(vm);
43 |     init_env(vm);
44 |     init_set(vm);
45 |     init_directory(vm);
46 |     init_string_builder(vm);
47 |     init_function(vm);
48 |     init_process(vm);
49 | }
50 | 


--------------------------------------------------------------------------------
/stdlib/boolean.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #if defined(_WIN32) || defined(_WIN64) 
 3 | #  include <string.h>
 4 | #  define strcasecmp _stricmp 
 5 | #  define strncasecmp _strnicmp 
 6 | #else
 7 | #  include <strings.h>
 8 | #endif
 9 | 
10 | 
11 | #include "cometlib.h"
12 | #include "comet_stdlib.h"
13 | 
14 | typedef struct {
15 |     ObjInstance obj;
16 |     bool value;
17 | } BooleanData_t;
18 | 
19 | static BooleanData_t _true;
20 | static BooleanData_t _false;
21 | 
22 | ObjInstance *boolean_true = (ObjInstance *) &_true;
23 | ObjInstance *boolean_false = (ObjInstance *) &_false;
24 | 
25 | static VALUE bool_class;
26 | 
27 | VALUE boolean_to_string(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
28 | {
29 |     BooleanData_t *data = GET_NATIVE_INSTANCE_DATA(BooleanData_t, self);
30 |     if (data->value)
31 |         return copyString(vm, "true", 4);
32 |     return copyString(vm, "false", 5);
33 | }
34 | 
35 | VALUE boolean_parse(VM UNUSED(*vm), VALUE UNUSED(klass), int UNUSED(arg_count), VALUE *arguments)
36 | {
37 |     const char *to_comp = string_get_cstr(arguments[0]);
38 |     if (strcasecmp(to_comp, "true") == 0) {
39 |         return TRUE_VAL;
40 |     }
41 |     else if (strcasecmp(to_comp, "false") == 0) {
42 |         return FALSE_VAL;
43 |     }
44 |     throw_exception_native(vm, "ArgumentException", "Can't parse %s to a boolean", to_comp);
45 |     return NIL_VAL;
46 | }
47 | 
48 | static void init_instance(VM *vm, BooleanData_t *instance, ObjClass *klass, bool value)
49 | {
50 |     instance->obj.obj.type = OBJ_NATIVE_INSTANCE;
51 | #if !REF_COUNT_MEM_MANAGEMENT
52 |     instance->obj.obj.isMarked = false; // doesn't matter, it's static memory anyway
53 | #endif
54 |     instance->obj.klass = klass;
55 |     instance->value = value;
56 |     initTable(&instance->obj.fields);
57 |     if (value)
58 |         push(vm, copyString(vm, "true", 4));
59 |     else
60 |         push(vm, copyString(vm, "false", 5));
61 |     addGlobal(peek(vm, 0), OBJ_VAL(instance));
62 |     pop(vm);
63 | }
64 | 
65 | bool bool_get_value(VALUE value)
66 | {
67 |     DEBUG_ASSERT(instanceof(value, bool_class));
68 |     BooleanData_t *data = GET_NATIVE_INSTANCE_DATA(BooleanData_t, value);
69 |     return (bool)data->value;
70 | }
71 | 
72 | bool bool_is_falsey(VALUE value)
73 | {
74 |     if (IS_NIL(value))
75 |         return true;
76 |     if (instanceof(value, bool_class) && !bool_get_value(value))
77 |         return true;
78 | 
79 |     return false;
80 | }
81 | 
82 | void init_boolean(VM *vm)
83 | {
84 |     bool_class = defineNativeClass(vm, "Boolean", NULL, NULL, NULL, NULL, CLS_BOOLEAN, sizeof(BooleanData_t), true);
85 |     defineNativeMethod(vm, bool_class, &boolean_to_string, "to_string", 0, false);
86 |     defineNativeMethod(vm, bool_class, &boolean_parse, "parse", 1, true);
87 |     init_instance(vm, &_true, AS_CLASS(bool_class), true);
88 |     init_instance(vm, &_false, AS_CLASS(bool_class), false);
89 | }


--------------------------------------------------------------------------------
/stdlib/comet/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | 
2 | SET(SOURCE
3 |     json.cmt
4 |     csv.cmt
5 |     unittest.cmt
6 |     coverage.cmt
7 | )
8 | 
9 | install(FILES ${SOURCE} DESTINATION lib/comet)


--------------------------------------------------------------------------------
/stdlib/comet/coverage.cmt:
--------------------------------------------------------------------------------
 1 | import 'json' as json
 2 | 
 3 | var output_filename = '.coverage.json'
 4 | 
 5 | function generate() {
 6 |     if (File.exists?(output_filename)) {
 7 |         File.delete(output_filename)
 8 |     }
 9 | 
10 |     var output = {}
11 |     var modules = get_imported_modules()
12 |     foreach (var module in modules) {
13 |         var counts = module.get_execution_counts()
14 |         var module_lines_total = 0
15 |         var module_lines_hit = 0
16 |         var module_coverage = {
17 |             'functions': {}
18 |         }
19 |         foreach (var func_key in counts) {
20 |             var func = counts[func_key]
21 |             var func_lines = func.values()
22 |             var lines_hit = func_lines.filter((|x|) {
23 |                 return x != 0
24 |             }).count()
25 |             var func_lines_total = func_lines.count()
26 |             var func_coverage = (lines_hit / func_lines_total) * 100
27 |             module_lines_total += func_lines_total
28 |             module_lines_hit += lines_hit
29 |             func['coverage'] = {
30 |                 'total': func_lines_total,
31 |                 'hit': lines_hit,
32 |                 'percentage': func_coverage,
33 |             }
34 |         }
35 |         counts['coverage'] = {
36 |             'total': module_lines_total,
37 |             'hit': module_lines_hit,
38 |             'percentage': (module_lines_hit / module_lines_total) * 100,
39 |         }
40 |         output[module.filename()] = counts
41 |     }
42 | 
43 |     json.to_json_file(output, output_filename)
44 | }


--------------------------------------------------------------------------------
/stdlib/comet/csv.cmt:
--------------------------------------------------------------------------------
 1 | class CsvRowIterator : Iterator {
 2 |     init(fields) {
 3 |         self.fields = fields
 4 |         self.index = 0
 5 |     }
 6 | 
 7 |     get_next() {
 8 |         var index = self.index
 9 |         self.index += 1
10 |         return self.fields[index]
11 |     }
12 | 
13 |     has_next?() {
14 |         return self.index < self.fields.length()
15 |     }
16 | }
17 | 
18 | class CsvRow : Iterable {
19 |     init(fields) {
20 |         self.fields = fields
21 |     }
22 | 
23 |     operator [] (index) {
24 |         return self.fields[index]
25 |     }
26 | 
27 |     iterator() {
28 |         return CsvRowIterator(self.fields)
29 |     }
30 | 
31 |     empty?() {
32 |         return self.fields.length() == 0
33 |     }
34 | 
35 |     contains?(item) {
36 |         foreach (var field in self.fields) {
37 |             if (field == item) {
38 |                 return true
39 |             }
40 |         }
41 |         return false
42 |     }
43 | }
44 | 
45 | function _parse_line(line) {
46 |     var fields = line.trim().split(',')
47 |     return CsvRow(fields)
48 | }
49 | 
50 | function _parse_all_lines(lines, has_header) {
51 |     var result = []
52 |     var header_row = nil
53 |     var index = 0
54 |     if (has_header) {
55 |         header_row = _parse_line(lines[0])
56 |         index += 1
57 |     }
58 |     for (; index < lines.length(); index += 1) {
59 |         result.append(_parse_line(lines[index]))
60 |     }
61 |     return result
62 | }
63 | 
64 | function parse_from_string(str, has_header = false) {
65 |     var lines = str.split('\n')
66 |     return _parse_all_lines(lines)
67 | }
68 | 
69 | function parse_from_file(filename, has_header = false) {
70 |     var contents = File.read_all_lines(filename)
71 |     return _parse_all_lines(contents, has_header)
72 | }


--------------------------------------------------------------------------------
/stdlib/cometlib.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_LIB_H_
 2 | #define _COMET_LIB_H_
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | #include "comet.h"
 8 | 
 9 | #define MILLI_SECONDS_PER_SECOND 1000
10 | #define NANO_SECONDS_PER_SECOND 1000000000
11 | 
12 |     void init_object(VM* vm, VALUE klass);
13 |     void init_string(VM* vm, VALUE obj_klass);
14 |     void init_exception(VM* vm);
15 |     void init_file(VM* vm);
16 |     void init_datetime(VM* vm);
17 |     void init_duration(VM *vm);
18 |     void init_functions(VM* vm);
19 |     void init_hash(VM* vm);
20 |     void init_colour(VM *vm);
21 |     void init_image(VM* vm);
22 |     void init_list(VM* vm);
23 |     void init_module(VM* vm);
24 |     void init_nil(VM* vm);
25 |     void init_boolean(VM* vm);
26 |     void init_socket(VM* vm);
27 |     void init_thread(VM* vm);
28 |     void init_thread_sync(VM* vm);
29 |     void init_enum(VM* vm);
30 |     void init_set(VM* vm);
31 |     void init_env(VM* vm);
32 |     void init_directory(VM* vm);
33 |     void bootstrap_number(VM* vm);
34 |     void complete_number(VM* vm);
35 |     void bootstrap_iterable(VM* vm);
36 |     void complete_iterable(VM* vm);
37 |     void init_string_builder(VM *vm);
38 |     void init_function(VM *vm);
39 |     void init_process(VM *vm);
40 | 
41 |     VALUE callable_p(VM* vm, int arg_count, VALUE* args);
42 | 
43 | #ifdef WIN32
44 |     void socket_cleanup(void);
45 | #endif
46 | 
47 | #ifdef __cplusplus
48 | }
49 | #endif
50 | 
51 | #endif
52 | 


--------------------------------------------------------------------------------
/stdlib/env.cpp:
--------------------------------------------------------------------------------
 1 | #include "comet.h"
 2 | #include "cometlib.h"
 3 | 
 4 | #include <cstdlib>
 5 | #include <cerrno>
 6 | #include <cstring>
 7 | 
 8 | #ifdef WIN32
 9 | #include <processenv.h>
10 | #endif
11 | 
12 | extern "C" {
13 | 
14 | VALUE env_set_value(VM *vm, VALUE UNUSED(self), int UNUSED(arg_count), VALUE *arguments)
15 | {
16 | #ifndef WIN32
17 |     if (arguments[1] == NIL_VAL)
18 |     {
19 |         unsetenv(string_get_cstr(arguments[0]));
20 |         return NIL_VAL;
21 |     }
22 | #endif
23 |     if (!isObjOfStdlibClassType(arguments[0], CLS_STRING) ||
24 |         !isObjOfStdlibClassType(arguments[1], CLS_STRING))
25 |     {
26 |         throw_exception_native(vm, "ArgumentException", "Environment variable names and values can only be strings");
27 |         return NIL_VAL;
28 |     }
29 | #ifndef WIN32
30 |     if (setenv(string_get_cstr(arguments[0]), string_get_cstr(arguments[1]), true) != 0)
31 |     {
32 |         throw_exception_native(vm, "Exception", "Could not set environment variable: %s", strerror(errno));
33 |     }
34 | #else
35 |     if (!SetEnvironmentVariableA(string_get_cstr(arguments[0]), string_get_cstr(arguments[1])))
36 |     {
37 |         throw_exception_native(vm, "Exception", "Could not set environment variable: %s", strerror(errno));
38 |     }
39 | #endif
40 |     return NIL_VAL;
41 | }
42 | 
43 | VALUE env_get_value(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE *arguments)
44 | {
45 |     const char *env_var = string_get_cstr(arguments[0]);
46 |     char *value = std::getenv(env_var);
47 |     if (value == NULL)
48 |     {
49 |         throw_exception_native(vm, "Exception", "Environment variable %s did not exist", env_var);
50 |         return NIL_VAL;
51 |     }
52 | 
53 |     return copyString(vm, value, strlen(value));
54 | }
55 | 
56 | void init_env(VM *vm)
57 | {
58 |     VALUE klass = defineNativeClass(vm, "EnvVars", NULL, NULL, NULL, NULL, CLS_ENV, 0, false);
59 |     defineNativeOperator(vm, klass, &env_set_value, 2, OPERATOR_INDEX_ASSIGN);
60 |     defineNativeOperator(vm, klass, &env_get_value, 1, OPERATOR_INDEX);
61 |     VALUE instance = OBJ_VAL(newInstance(vm, AS_CLASS(klass)));
62 |     push(vm, instance);
63 |     addGlobal(copyString(vm, "ENV", 3), instance);
64 |     pop(vm);
65 | }
66 | 
67 | }


--------------------------------------------------------------------------------
/stdlib/file_common.cpp:
--------------------------------------------------------------------------------
 1 | #include <filesystem>
 2 | #include <stdio.h>
 3 | 
 4 | #include "comet.h"
 5 | #include "cometlib.h"
 6 | #include "comet_stdlib.h"
 7 | #include "directory.hpp"
 8 | #include "file_common.h"
 9 | 
10 | 
11 | extern "C" {
12 | 
13 | VALUE fopen_params;
14 | 
15 | VALUE file_static_rename(VM UNUSED(*vm), VALUE UNUSED(klass), int UNUSED(arg_count), VALUE *arguments)
16 | {
17 |     const char *old_name = string_get_cstr(arguments[0]);
18 |     const char *new_name = string_get_cstr(arguments[1]);
19 |     rename(old_name, new_name);
20 |     return NIL_VAL;
21 | }
22 | 
23 | VALUE file_static_dirname(VM *vm, VALUE UNUSED(klass), int UNUSED(arg_count), VALUE *arguments)
24 | {
25 |     const char *path = string_get_cstr(arguments[0]);
26 |     return directory_create(vm, std::filesystem::path(path).parent_path());
27 | }
28 | 
29 | VALUE file_static_join_path(VM *vm, VALUE UNUSED(klass), int arg_count, VALUE *arguments)
30 | {
31 |     auto path = std::filesystem::path(string_get_cstr(arguments[0]));
32 |     for (int i = 1; i < arg_count; i++)
33 |     {
34 |         path = path / std::filesystem::path(string_get_cstr(arguments[i]));
35 |     }
36 |     auto path_string = path.string();
37 |     return copyString(vm, path_string.c_str(), path_string.length());
38 | }
39 | 
40 | void init_file(VM* vm)
41 | {
42 |     VALUE klass = defineNativeClass(vm, "File", &file_constructor, &file_destructor, NULL, "Object", CLS_FILE, sizeof(FileData), true);
43 |     defineNativeMethod(vm, klass, &file_static_open, "open", 2, true);
44 |     defineNativeMethod(vm, klass, &file_close, "close", 0, false);
45 |     defineNativeMethod(vm, klass, &file_write, "write", 1, false);
46 |     defineNativeMethod(vm, klass, &file_write_line, "write_line", 1, false);
47 |     defineNativeMethod(vm, klass, &file_read, "read", 0, false);
48 |     defineNativeMethod(vm, klass, &file_read_line, "read_line", 0, false);
49 |     defineNativeMethod(vm, klass, &file_sync, "sync", 0, false);
50 |     defineNativeMethod(vm, klass, &file_flush, "flush", 0, false);
51 |     defineNativeMethod(vm, klass, &file_static_exists_q, "exists?", 1, true);
52 |     defineNativeMethod(vm, klass, &file_static_file_q, "file?", 1, true);
53 |     defineNativeMethod(vm, klass, &file_static_read_all_lines, "read_all_lines", 1, true);
54 |     defineNativeMethod(vm, klass, &file_static_delete, "delete", 1, true);
55 |     defineNativeMethod(vm, klass, &file_static_rename, "rename", 2, true);
56 |     defineNativeMethod(vm, klass, &file_static_copy, "copy", 2, true);
57 |     defineNativeMethod(vm, klass, &file_static_dirname, "directory", 1, true);
58 |     defineNativeMethod(vm, klass, &file_static_join_path, "join_path", 1, true);
59 | 
60 |     fopen_params = enum_create(vm);
61 |     push(vm, fopen_params);
62 |     addGlobal(copyString(vm, "FOPEN", 5), fopen_params);
63 |     enum_add_value(vm, fopen_params, "READ_ONLY", FOPEN_READ_ONLY);
64 |     enum_add_value(vm, fopen_params, "READ_WRITE", FOPEN_READ_WRITE);
65 |     enum_add_value(vm, fopen_params, "APPEND", FOPEN_APPEND);
66 |     enum_add_value(vm, fopen_params, "BINARY", FOPEN_BINARY);
67 |     pop(vm);
68 | }
69 | 
70 | }


--------------------------------------------------------------------------------
/stdlib/function.c:
--------------------------------------------------------------------------------
 1 | #include "comet.h"
 2 | 
 3 | VALUE function_name(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 4 | {
 5 |     ObjFunction *func = AS_CLOSURE(self)->function;
 6 |     return func->name;
 7 | }
 8 | 
 9 | VALUE function_attributes(VM *vm, VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
10 | {
11 |     ObjFunction *func = AS_CLOSURE(self)->function;
12 |     VALUE list = list_create(vm);
13 |     push(vm, list);
14 |     list_add(vm, list, func->attributeCount, func->attributes);
15 |     return pop(vm);
16 | }
17 | 
18 | void init_function(VM *vm)
19 | {
20 |     VALUE klass = defineNativeClass(vm, "Function", NULL, NULL, NULL, NULL, CLS_FUNCTION, 0, true);
21 |     defineNativeMethod(vm, klass, &function_attributes, "attributes", 0, false);
22 |     defineNativeMethod(vm, klass, &function_name, "name", 0, false);
23 | }


--------------------------------------------------------------------------------
/stdlib/iterable.c:
--------------------------------------------------------------------------------
  1 | #include "cometlib.h"
  2 | #include "comet.h"
  3 | #include <string.h>
  4 | #include <stdio.h>
  5 | 
  6 | static VALUE iterable_klass;
  7 | static VALUE iterator_klass;
  8 | 
  9 | VALUE iterable_contains_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 10 | {
 11 |     return FALSE_VAL;
 12 | }
 13 | 
 14 | VALUE iterable_empty_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 15 | {
 16 |     return FALSE_VAL;
 17 | }
 18 | 
 19 | VALUE iterable_iterator(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 20 | {
 21 |     return FALSE_VAL;
 22 | }
 23 | 
 24 | VALUE iterable_count(VM *vm, VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 25 | {
 26 |     return create_number(vm, 0);
 27 | }
 28 | 
 29 | VALUE iterator_has_next_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 30 | {
 31 |     return FALSE_VAL;
 32 | }
 33 | 
 34 | VALUE iterator_get_next(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 35 | {
 36 |     return FALSE_VAL;
 37 | }
 38 | 
 39 | VALUE iterable_compare(VM* vm, VALUE self, int arg_count, VALUE* arguments, OPERATOR op)
 40 | {
 41 |     VALUE iterator_func_name = copyString(vm, "iterator", strlen("iterator"));
 42 |     push(vm, iterator_func_name);
 43 |     VALUE has_next_name = copyString(vm, "has_next?", strlen("has_next?"));
 44 |     push(vm, has_next_name);
 45 |     VALUE get_next_name = copyString(vm, "get_next", strlen("get_next"));
 46 |     push(vm, get_next_name);
 47 |     call_function(vm, self, iterator_func_name, 0, NULL);
 48 |     VALUE iterator = peek(vm, 0);
 49 |     call_function(vm, iterator, has_next_name, 0, NULL);
 50 |     VALUE has_next = peek(vm, 0);
 51 |     VALUE current = NIL_VAL;
 52 |     while (has_next == TRUE_VAL) {
 53 |         call_function(vm, iterator, get_next_name, 0, NULL);
 54 |         VALUE item = peek(vm, 0);
 55 |         if (current == NIL_VAL) {
 56 |             current = item;
 57 |         }
 58 |         else {
 59 |             VALUE val = item;
 60 |             if (arg_count == 1) {
 61 |                 call_function(vm, item, arguments[0], 1, &item);
 62 |                 swapTop(vm);
 63 |                 pop(vm);
 64 |                 val = peek(vm, 0);
 65 |             }
 66 |             VALUE compare_func = AS_INSTANCE(val)->klass->operators[op];
 67 |             call_function(vm, val, compare_func, 1, &current);
 68 |             VALUE result = peek(vm, 0);
 69 |             if (result == TRUE_VAL) {
 70 |                 current = val;
 71 |             }
 72 |         }
 73 |         popMany(vm, 2);
 74 |         call_function(vm, iterator, has_next_name, 0, NULL);
 75 |         has_next = peek(vm, 0);
 76 |     }
 77 |     popMany(vm, 5);
 78 |     return current;
 79 | }
 80 | 
 81 | VALUE iterable_max(VM *vm, VALUE self, int arg_count, VALUE *arguments)
 82 | {
 83 |     return iterable_compare(vm, self, arg_count, arguments, OPERATOR_GREATER_THAN);
 84 | }
 85 | 
 86 | VALUE iterable_min(VM* vm, VALUE self, int arg_count, VALUE* arguments)
 87 | {
 88 |     return iterable_compare(vm, self, arg_count, arguments, OPERATOR_LESS_THAN);
 89 | }
 90 | 
 91 | void bootstrap_iterable(VM *vm)
 92 | {
 93 |     iterable_klass = bootstrapNativeClass(vm, "Iterable", NULL, NULL, CLS_ITERABLE, 0, false);
 94 |     iterator_klass = bootstrapNativeClass(vm, "Iterator", NULL, NULL, CLS_ITERATOR, 0, false);
 95 | }
 96 | 
 97 | void complete_iterable(VM *vm)
 98 | {
 99 |     completeNativeClassDefinition(vm, iterable_klass, NULL);
100 |     defineNativeMethod(vm, iterable_klass, &iterable_contains_q, "contains?", 1, false);
101 |     defineNativeMethod(vm, iterable_klass, &iterable_empty_q, "empty?", 0, false);
102 |     defineNativeMethod(vm, iterable_klass, &iterable_iterator, "iterator", 0, false);
103 |     defineNativeMethod(vm, iterable_klass, &iterable_count, "count", 0, false);
104 |     defineNativeMethod(vm, iterable_klass, &iterable_max, "max", 0, false);
105 |     defineNativeMethod(vm, iterable_klass, &iterable_min, "min", 0, false);
106 | 
107 |     completeNativeClassDefinition(vm, iterator_klass, NULL);
108 |     defineNativeMethod(vm, iterator_klass, &iterator_has_next_q, "has_next?", 0, false);
109 |     defineNativeMethod(vm, iterator_klass, &iterator_get_next, "get_next", 0, false);
110 | }
111 |  


--------------------------------------------------------------------------------
/stdlib/nil.c:
--------------------------------------------------------------------------------
 1 | #include <stdint.h>
 2 | #include "comet.h"
 3 | 
 4 | ObjInstance nil_instance;
 5 | VALUE nil_iterator_class;
 6 | 
 7 | VALUE nil_iterator_has_next_p(VM UNUSED(*vm), VALUE UNUSED(klass), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 8 | {
 9 |     return FALSE_VAL;
10 | }
11 | 
12 | VALUE nil_iterator_get_next(VM UNUSED(*vm), VALUE UNUSED(klass), int UNUSED(arg_count), VALUE UNUSED(*arguments))
13 | {
14 |     return NIL_VAL;
15 | }
16 | 
17 | VALUE nil_nil_q(VM UNUSED(*vm), VALUE UNUSED(klass), int UNUSED(arg_count), VALUE UNUSED(*arguments))
18 | {
19 |     return TRUE_VAL;
20 | }
21 | 
22 | VALUE nil_to_string(VM *vm, VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
23 | {
24 |     return copyString(vm, "", 0);
25 | }
26 | 
27 | VALUE nil_iterable_empty_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
28 | {
29 |     return TRUE_VAL;
30 | }
31 | 
32 | VALUE nil_iterable_iterator(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
33 | {
34 |     return OBJ_VAL(newInstance(vm, AS_CLASS(nil_iterator_class)));
35 | }
36 | 
37 | VALUE nil_iterable_contains_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
38 | {
39 |     return FALSE_VAL;
40 | }
41 | 
42 | VALUE nil_iterable_count(VM *vm, VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
43 | {
44 |     return create_number(vm, 0);
45 | }
46 | 
47 | void init_nil(VM *vm)
48 | {
49 |     VALUE klass = defineNativeClass(vm, "Nil", NULL, NULL, NULL, "Iterable", CLS_NIL, 0, true);
50 |     defineNativeMethod(vm, klass, &nil_nil_q, "nil?", 0, false);
51 |     defineNativeMethod(vm, klass, &nil_to_string, "to_string", 0, false);
52 |     defineNativeMethod(vm, klass, &nil_iterable_contains_q, "contains?", 1, false);
53 |     defineNativeMethod(vm, klass, &nil_iterable_iterator, "iterator", 0, false);
54 |     defineNativeMethod(vm, klass, &nil_iterable_count, "count", 0, false);
55 |     nil_instance.obj.type = OBJ_NATIVE_INSTANCE;
56 | #if !REF_COUNT_MEM_MANAGEMENT
57 |     nil_instance.obj.isMarked = false; // doesn't matter, it's static memory anyway
58 | #endif
59 |     nil_instance.klass = AS_CLASS(klass);
60 |     initTable(&nil_instance.fields);
61 |     push(vm, copyString(vm, "nil", 3));
62 |     addGlobal(peek(vm, 0), NIL_VAL);
63 |     pop(vm);
64 | 
65 |     nil_iterator_class = defineNativeClass(vm, "NilIterator", NULL, NULL, NULL, "Iterator", CLS_ITERATOR, 0, true);
66 |     defineNativeMethod(vm, nil_iterator_class, &nil_iterator_has_next_p, "has_next?", 0, false);
67 |     defineNativeMethod(vm, nil_iterator_class, &nil_iterator_get_next, "get_next", 0, false);
68 | }
69 | 


--------------------------------------------------------------------------------
/stdlib/object.c:
--------------------------------------------------------------------------------
  1 | #include <string.h>
  2 | #include <stdio.h>
  3 | 
  4 | #include "comet.h"
  5 | #include "cometlib.h"
  6 | 
  7 | VALUE instanceof(VALUE self, VALUE klass)
  8 | {
  9 |     if ((IS_INSTANCE(self) || IS_NATIVE_INSTANCE(self)) &&
 10 |         (IS_CLASS(klass) || IS_NATIVE_CLASS(klass)))
 11 |     {
 12 |         ObjInstance *instance = AS_INSTANCE(self);
 13 |         if (instance->klass == AS_CLASS(klass))
 14 |         {
 15 |             return TRUE_VAL;
 16 |         }
 17 |         ObjClass *current_klass = instance->klass->super_;
 18 |         while (current_klass != NULL)
 19 |         {
 20 |             if (current_klass == AS_CLASS(klass))
 21 |                 return TRUE_VAL;
 22 |             current_klass = current_klass->super_;
 23 |         }
 24 |     }
 25 |     else if (IS_NUMBER(self) && IS_NATIVE_CLASS(klass)) {
 26 |         if (AS_CLASS(klass)->classType == CLS_NUMBER) {
 27 |             return TRUE_VAL;
 28 |         }
 29 |     }
 30 |     return FALSE_VAL;
 31 | }
 32 | 
 33 | VALUE obj_compare_to(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE *arguments)
 34 | {
 35 |     if (self == arguments[0])
 36 |         return create_number(vm, 0);
 37 |     return NIL_VAL;
 38 | }
 39 | 
 40 | VALUE obj_equals(VM *vm, VALUE self, int arg_count, VALUE *arguments)
 41 | {
 42 |     VALUE result = obj_compare_to(vm, self, arg_count, arguments);
 43 |     if (result == NIL_VAL)
 44 |         return FALSE_VAL;
 45 |     return TRUE_VAL;
 46 | }
 47 | 
 48 | VALUE obj_hash(VM *vm, VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 49 | {
 50 |     uint32_t hash = 2166136261u;
 51 |     uintptr_t address = (uintptr_t) AS_OBJ(self);
 52 | 
 53 |     for (size_t i = 0; i < sizeof(uintptr_t); i++)
 54 |     {
 55 |         hash ^= (address >> i) & 0xFF;
 56 |         hash *= 16777619;
 57 |     }
 58 | 
 59 |     return create_number(vm, (double) hash);
 60 | }
 61 | 
 62 | // A placeholder such that anyone can call "super.init()"
 63 | VALUE obj_init(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
 64 | {
 65 |     return NIL_VAL;
 66 | }
 67 | 
 68 | VALUE obj_to_string(VM *vm, VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 69 | {
 70 |     if (IS_NUMBER(self))
 71 |     {
 72 |         return copyString(vm, "Number instance", 15);
 73 |     }
 74 |     ObjInstance *instance = AS_INSTANCE(self);
 75 | #ifdef WIN32
 76 | #define string_len 256
 77 | #else
 78 |     size_t string_len = strlen(instance->klass->name) + strlen(" instance") + 1;
 79 | #endif
 80 |     char string[string_len];
 81 |     snprintf(string, string_len, "%s instance", instance->klass->name);
 82 |     return copyString(vm, string, string_len);
 83 | }
 84 | 
 85 | VALUE cls_to_string(VM *vm, VALUE klass, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 86 | {
 87 |     if (IS_NUMBER(klass))
 88 |     {
 89 |         return copyString(vm, "Number class", 12);
 90 |     }
 91 | #ifdef WIN32
 92 | #define string_len 256
 93 | #else
 94 |     size_t string_len = strlen(AS_CLASS(klass)->name) + strlen(" class") + 1;
 95 | #endif
 96 |     char string[string_len];
 97 |     snprintf(string, string_len, "%s class", AS_CLASS(klass)->name);
 98 |     return copyString(vm, string, string_len);
 99 | }
100 | 
101 | VALUE obj_nil_q(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
102 | {
103 |     return FALSE_VAL;
104 | }
105 | 
106 | VALUE obj_methods(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
107 | {
108 |     VALUE list = list_create(vm);
109 |     push(vm, list);
110 |     ObjClass *klass = AS_INSTANCE(self)->klass;
111 |     tableGetKeys(&klass->methods, vm, list);
112 |     return pop(vm);
113 | }
114 | 
115 | VALUE obj_fields(VM UNUSED(*vm), VALUE UNUSED(self), int UNUSED(arg_count), VALUE UNUSED(*arguments))
116 | {
117 |     VALUE list = list_create(vm);
118 |     push(vm, list);
119 |     ObjInstance *obj = AS_INSTANCE(self);
120 |     tableGetKeys(&obj->fields, vm, list);
121 |     return pop(vm);
122 | }
123 | 
124 | VALUE obj_attributes(VM UNUSED(*vm), VALUE klass, int UNUSED(arg_count), VALUE UNUSED(*arguments))
125 | {
126 |     VALUE list = list_create(vm);
127 |     push(vm, list);
128 |     ObjClass *klass_obj = AS_CLASS(klass);
129 |     list_add(vm, list, klass_obj->attributeCount, klass_obj->attributes);
130 |     return pop(vm);
131 | }
132 | 
133 | void init_object(VM *vm, VALUE klass)
134 | {
135 |     defineNativeMethod(vm, klass, &obj_hash, "hash", 0, false);
136 |     defineNativeMethod(vm, klass, &obj_init, "init", 0, false);
137 |     defineNativeMethod(vm, klass, &obj_to_string, "to_string", 0, false);
138 |     defineNativeMethod(vm, klass, &obj_to_string, "class_name", 0, false);
139 |     defineNativeMethod(vm, klass, &cls_to_string, "to_string", 0, true);
140 |     defineNativeMethod(vm, klass, &obj_hash, "hash", 0, true);
141 |     defineNativeMethod(vm, klass, &obj_nil_q, "nil?", 0, false);
142 |     defineNativeMethod(vm, klass, &obj_compare_to, "compare_to", 1, false);
143 |     defineNativeMethod(vm, klass, &obj_methods, "methods", 0, false);
144 |     defineNativeMethod(vm, klass, &obj_fields, "fields", 0, false);
145 |     defineNativeMethod(vm, klass, &obj_attributes, "attributes", 0, true);
146 |     defineNativeOperator(vm, klass, &obj_equals, 1, OPERATOR_EQUALS);
147 | }
148 | 


--------------------------------------------------------------------------------
/stdlib/private/colour.h:
--------------------------------------------------------------------------------
 1 | #ifndef _colour_hpp_
 2 | #define _colour_hpp_
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | 
 8 | #include "comet.h"
 9 | 
10 | typedef struct {
11 |     ObjInstance obj;
12 |     uint8_t r;
13 |     uint8_t g;
14 |     uint8_t b;
15 | } ColourData_t;
16 | 
17 | VALUE colour_create(VM *vm, uint8_t r, uint8_t g, uint8_t b);
18 | 
19 | #ifdef __cplusplus
20 | }
21 | #endif
22 | 
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/stdlib/private/comet_stdlib.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_STDLIB_H_
 2 | #define _COMET_STDLIB_H_
 3 | #include "comet.h"
 4 | 
 5 | #define GET_NATIVE_INSTANCE_DATA(type_, self) ((type_ *) AS_NATIVE_INSTANCE(self))
 6 | 
 7 | #ifdef __cplusplus
 8 | extern "C" {
 9 | #endif
10 | 
11 | VALUE enum_create(VM *vm);
12 | void enum_add_value(VM *vm, VALUE enum_instance, const char *name, uint64_t value);
13 | uint64_t enumvalue_get_value(VALUE instance);
14 | VALUE enum_get_from_value(VALUE enum_instance, uint64_t value);
15 | 
16 | #ifdef __cplusplus
17 | }
18 | #endif
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/stdlib/private/comet_string.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_STRING_H_
 2 | #define _COMET_STRING_H_
 3 | 
 4 | #include "comet.h"
 5 | #include "utf8proc.h"
 6 | 
 7 | typedef struct
 8 | {
 9 |     ObjInstance obj;
10 |     size_t length;
11 |     char *chars;
12 |     uint32_t hash;
13 | } StringData;
14 | 
15 | typedef struct
16 | {
17 |     ObjInstance obj;
18 |     StringData *string;
19 |     utf8proc_int32_t current_codepoint;
20 |     utf8proc_ssize_t remaining;
21 |     utf8proc_ssize_t offset;
22 | } StringIterator;
23 | 
24 | bool string_iter_get_next(StringIterator *iter);
25 | VALUE string_iterator(VM *vm, VALUE self, int arg_count, VALUE *arguments);
26 | 
27 | #endif


--------------------------------------------------------------------------------
/stdlib/private/datetime.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef _datetime_hpp_
 2 | #define _datetime_hpp_
 3 | #include <chrono>
 4 | 
 5 | #ifndef WIN32
 6 | #include "date/date.h"
 7 | #include "date/tz.h"
 8 | #endif
 9 | #include "comet.h"
10 | 
11 | extern "C" {
12 | #ifdef WIN32
13 |     VALUE create_datetime(VM *vm, std::chrono::time_point<std::chrono::local_t, std::chrono::nanoseconds> time_point, const std::chrono::time_zone *time_zone);
14 | #else
15 |     VALUE create_datetime(VM* vm, std::chrono::time_point<date::local_t, std::chrono::nanoseconds> time_point, const date::time_zone* time_zone);
16 | #endif
17 | }
18 | 
19 | #ifdef WIN32
20 | std::chrono::zoned_time<std::chrono::nanoseconds> datetime_get_value(VALUE datetime);
21 | #else
22 | date::zoned_time<std::chrono::nanoseconds> datetime_get_value(VALUE datetime);
23 | #endif
24 | std::chrono::nanoseconds duration_get_value(VALUE duration);
25 | 
26 | #endif


--------------------------------------------------------------------------------
/stdlib/private/directory.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef _directory_hpp_
 2 | #define _directory_hpp_
 3 | #include <filesystem>
 4 | #include "comet.h"
 5 | 
 6 | extern "C" {
 7 |     VALUE directory_create(VM *vm, const std::filesystem::path& path);
 8 | }
 9 | 
10 | #endif


--------------------------------------------------------------------------------
/stdlib/private/file_common.h:
--------------------------------------------------------------------------------
 1 | #ifndef COMET_FILE_COMMON_H_
 2 | #define COMET_FILE_COMMON_H_
 3 | 
 4 | #ifdef __cplusplus
 5 | extern "C" {
 6 | #endif
 7 | 
 8 | #ifdef WIN32
 9 | #include <Windows.h>
10 | #else
11 | #include <stdio.h>
12 | #endif
13 | #include "comet.h"
14 | 
15 | extern VALUE fopen_params;
16 | 
17 | #define FOPEN_READ_ONLY 1
18 | #define FOPEN_READ_WRITE 2
19 | #define FOPEN_APPEND 4
20 | #define FOPEN_BINARY 8
21 | 
22 | 
23 | typedef struct fileData
24 | {
25 |     ObjInstance obj;
26 | #ifdef WIN32
27 |     HANDLE fp;
28 |     bool is_binary;
29 | #else
30 |     FILE* fp;
31 |     VALUE open_flags;
32 | #endif
33 | } FileData;
34 | 
35 | 
36 | void file_constructor(void* instanceData);
37 | void file_destructor(void* data);
38 | 
39 | VALUE file_static_open(VM* vm, VALUE klass, int arg_count, VALUE *arguments);
40 | VALUE file_static_exists_q(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
41 | VALUE file_static_file_q(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
42 | VALUE file_static_read_all_lines(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
43 | VALUE file_static_delete(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
44 | VALUE file_static_rename(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
45 | VALUE file_static_copy(VM* vm, VALUE klass, int arg_count, VALUE* arguments);
46 | 
47 | VALUE file_close(VM* vm, VALUE self, int arg_count, VALUE* arguments);
48 | VALUE file_write(VM* vm, VALUE self, int arg_count, VALUE* arguments);
49 | VALUE file_write_line(VM *vm, VALUE self, int UNUSED(arg_count), VALUE *arguments);
50 | VALUE file_read(VM* vm, VALUE self, int arg_count, VALUE* arguments);
51 | VALUE file_sync(VM* vm, VALUE self, int arg_count, VALUE* arguments);
52 | VALUE file_flush(VM* vm, VALUE self, int arg_count, VALUE* arguments);
53 | VALUE file_read_line(VM* vm, VALUE self, int arg_count, VALUE* arguments);
54 | 
55 | #ifdef __cplusplus
56 | }
57 | #endif
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/stdlib/private/list.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_STDLIB_PRIVATE_LIST_H_
 2 | #define _COMET_STDLIB_PRIVATE_LIST_H_
 3 | #include "cometlib.h"
 4 | 
 5 | VALUE list_iterator_has_next_p(VM *vm, VALUE self, int arg_count, VALUE *arguments);
 6 | VALUE list_iterator_get_next(VM *vm, VALUE self, int arg_count, VALUE *arguments);
 7 | VALUE list_iterable_iterator(VM *vm, VALUE self, int arg_count, VALUE *arguments);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/stdlib/private/string_builder.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_STDLIB_STRING_BUILDER_H_
 2 | #define _COMET_STDLIB_STRING_BUILDER_H_
 3 | #include "comet.h"
 4 | #include "utf8proc.h"
 5 | 
 6 | VALUE create_string_builder(VM *vm);
 7 | 
 8 | void string_builder_add_codepoint(VALUE self, utf8proc_int32_t codepoint);
 9 | 
10 | VALUE string_builder_to_string(VM *vm, VALUE self, int arg_count, VALUE *arguments);
11 | 
12 | void string_builder_add_cstr(VM *vm, VALUE self, const char *cstr);
13 | 
14 | #endif


--------------------------------------------------------------------------------
/stdlib/private/thread_sync_common.h:
--------------------------------------------------------------------------------
 1 | #ifndef COMET_STDLIB_THREAD_SYNC_COMMON_H_
 2 | #define COMET_STDLIB_THREAD_SYNC_COMMON_H_
 3 | #ifdef WIN32
 4 | #include <Windows.h>
 5 | #else
 6 | #include <pthread.h>
 7 | #endif
 8 | #include "comet_stdlib.h"
 9 | 
10 | typedef struct {
11 |     ObjInstance obj;
12 | #ifdef WIN32
13 |     CONDITION_VARIABLE cond_var;
14 |     CRITICAL_SECTION critical_section;
15 | #else
16 |     pthread_cond_t cond_var;
17 |     pthread_mutex_t lock;
18 | #endif
19 | } CondVarData;
20 | 
21 | void cond_var_constructor(void *instanceData);
22 | void cond_var_destructor(void *data);
23 | VALUE cond_var_signal_one(VM *vm, VALUE self, int arg_count, VALUE *arguments);
24 | VALUE cond_var_signal_all(VM *vm, VALUE self, int arg_count, VALUE *arguments);
25 | VALUE cond_var_wait(VM *vm, VALUE self, int arg_count, VALUE *arguments);
26 | VALUE cond_var_timed_wait(VM *vm, VALUE self, int arg_count, VALUE *arguments);
27 | 
28 | typedef struct {
29 |     ObjInstance obj;
30 | #ifdef WIN32
31 |     HANDLE mutex;
32 | #else
33 |     pthread_mutex_t mutex;
34 | #endif
35 | } MutexData;
36 | 
37 | void mutex_constructor(void *instanceData);
38 | void mutex_destructor(void *data);
39 | VALUE mutex_unlock(VM *vm, VALUE self, int arg_count, VALUE *arguments);
40 | VALUE mutex_lock(VM *vm, VALUE self, int arg_count, VALUE *arguments);
41 | VALUE mutex_try_lock(VM *vm, VALUE self, int arg_count, VALUE *arguments);
42 | VALUE mutex_timed_lock(VM *vm, VALUE self, int arg_count, VALUE *arguments);
43 | 
44 | #endif


--------------------------------------------------------------------------------
/stdlib/process.cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdlib>
 2 | #include <cstdio>
 3 | #include <cerrno>
 4 | #include <sstream>
 5 | 
 6 | #ifdef WIN32
 7 | #define popen _popen
 8 | #define pclose _pclose
 9 | #endif
10 | 
11 | #ifdef __cplusplus
12 | extern "C" {
13 | #endif
14 | 
15 | #include "comet.h"
16 | #include "cometlib.h"
17 | 
18 | typedef struct {
19 |     ObjInstance obj;
20 | } process_data_t;
21 | 
22 | typedef struct {
23 |     ObjInstance obj;
24 | } process_run_result_t;
25 | 
26 | static VALUE result_klass;
27 | 
28 | 
29 | VALUE process_static_run(VM *vm, VALUE UNUSED(self), int UNUSED(arg_count), VALUE *arguments)
30 | {
31 |     const char *cmd = string_get_cstr(arguments[0]);
32 |     FILE *cmd_file = popen(cmd, "r");
33 |     if (cmd_file == nullptr)
34 |     {
35 |         throw_exception_native(vm, "Exception", "Could not run a process: %s", strerror(errno));
36 |     }
37 |     VALUE proc_result = OBJ_VAL(newInstance(vm, AS_CLASS(result_klass)));
38 |     push(vm, proc_result);
39 |     std::stringstream stream;
40 |     char buffer[256];
41 |     while (!feof(cmd_file)) {
42 |         int numChars = fread(buffer, 1, 255, cmd_file);
43 |         buffer[numChars] = 0;
44 |         stream << buffer;
45 |     }
46 |     int result = pclose(cmd_file);
47 |     setNativeProperty(vm, proc_result, "status_code", create_number(vm, result));
48 |     std::string output = stream.str();
49 |     setNativeProperty(vm, proc_result, "output", copyString(vm, output.c_str(), output.length()));
50 |     setNativeProperty(vm, proc_result, "command", arguments[0]);
51 |     return pop(vm);
52 | }
53 | 
54 | void init_process(VM *vm)
55 | {
56 |     VALUE klass = defineNativeClass(vm, "Process", nullptr, nullptr, nullptr, nullptr, CLS_PROCESS, sizeof(process_data_t), true);
57 |     defineNativeMethod(vm, klass, &process_static_run, "run", 1, true);
58 | 
59 |     result_klass = defineNativeClass(vm, "ProcessRunResult", nullptr, nullptr, nullptr, nullptr, CLS_PROCESS_RUN_RESULT, sizeof(process_run_result_t), true);
60 | }
61 | 
62 | #ifdef __cplusplus
63 | }
64 | #endif


--------------------------------------------------------------------------------
/stdlib/string_builder.c:
--------------------------------------------------------------------------------
  1 | #include "utf8proc.h"
  2 | 
  3 | #include "cometlib.h"
  4 | #include "comet_stdlib.h"
  5 | #include "comet_string.h"
  6 | #include "string_builder.h"
  7 | 
  8 | #define BASE_CODEPOINT_ALLOCATION 16
  9 | 
 10 | typedef struct {
 11 |     ObjInstance obj;
 12 |     utf8proc_int32_t *codepoints;
 13 |     size_t size;
 14 |     size_t index;
 15 | } StringBuilderData_t;
 16 | 
 17 | static VALUE string_builder_klass;
 18 | 
 19 | static void string_builder_constructor(void *data)
 20 | {
 21 |     StringBuilderData_t *builder = (StringBuilderData_t *)data;
 22 |     builder->codepoints = NULL;
 23 |     builder->size = 0;
 24 |     builder->index = 0;
 25 | }
 26 | 
 27 | static void string_builder_destructor(void *data)
 28 | {
 29 |     StringBuilderData_t *builder = (StringBuilderData_t *)data;
 30 |     if (builder->codepoints != NULL)
 31 |     {
 32 |         FREE_ARRAY(StringBuilderData_t, builder->codepoints, builder->size);
 33 |         builder->codepoints = NULL;
 34 |         builder->size = 0;
 35 |         builder->index = 0;
 36 |     }
 37 | }
 38 | 
 39 | void string_builder_add_codepoint(VALUE self, utf8proc_int32_t codepoint)
 40 | {
 41 |     StringBuilderData_t *data = GET_NATIVE_INSTANCE_DATA(StringBuilderData_t, self);
 42 |     if (data->index == data->size)
 43 |     {
 44 |         size_t new_size = data->size + (BASE_CODEPOINT_ALLOCATION * sizeof(utf8proc_int32_t));
 45 |         data->codepoints = GROW_ARRAY(data->codepoints, utf8proc_int32_t, data->size, new_size);
 46 |         data->size = new_size;
 47 |     }
 48 |     data->codepoints[data->index++] = codepoint;
 49 | }
 50 | 
 51 | VALUE string_builder_to_string(VM *vm, VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 52 | {
 53 |     StringBuilderData_t *data = GET_NATIVE_INSTANCE_DATA(StringBuilderData_t, self);
 54 |     utf8proc_uint8_t temp[4];
 55 |     size_t length = 0;
 56 |     for (size_t i = 0; i < data->index; i++)
 57 |     {
 58 |         utf8proc_ssize_t char_size = utf8proc_encode_char(data->codepoints[i], &temp[0]);
 59 |         length += char_size;
 60 |     }
 61 |     char *output = ALLOCATE(char, length + 1);
 62 |     int output_offset = 0;
 63 |     for (int j = 0; j < data->index; j++)
 64 |     {
 65 |         output_offset += utf8proc_encode_char(data->codepoints[j], (utf8proc_uint8_t *)&output[output_offset]);
 66 |     }
 67 |     output[output_offset] = 0;
 68 |     return takeString(vm, output, length);
 69 | }
 70 | 
 71 | VALUE string_builder_append(VM *vm, VALUE self, int UNUSED(arg_count), VALUE *arguments)
 72 | {
 73 |     push(vm, string_iterator(vm, arguments[0], 0, NULL));
 74 |     StringIterator *iter = GET_NATIVE_INSTANCE_DATA(StringIterator, peek(vm, 0));
 75 |     while (string_iter_get_next(iter))
 76 |     {
 77 |         string_builder_add_codepoint(self, iter->current_codepoint);
 78 |     }
 79 |     pop(vm);
 80 |     return self;
 81 | }
 82 | 
 83 | void string_builder_add_cstr(VM *vm, VALUE self, const char *cstr)
 84 | {
 85 |     int offset = 0;
 86 |     size_t remaining = strlen(cstr);
 87 |     utf8proc_ssize_t bytes_read = 0;
 88 |     utf8proc_int32_t codepoint = 0;
 89 |     while (bytes_read > 0)
 90 |     {
 91 |         bytes_read = utf8proc_iterate((const utf8proc_uint8_t *)&cstr[offset], remaining, &codepoint);
 92 |         offset += bytes_read;
 93 |         remaining -= bytes_read;
 94 |         string_builder_add_codepoint(self, codepoint);
 95 |     }
 96 | }
 97 | 
 98 | VALUE string_builder_pop(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 99 | {
100 |     StringBuilderData_t *data = GET_NATIVE_INSTANCE_DATA(StringBuilderData_t, self);
101 |     if (data->index > 0)
102 |     {
103 |         data->index--;
104 |     }
105 |     return NIL_VAL;
106 | }
107 | 
108 | VALUE create_string_builder(VM *vm)
109 | {
110 |     VALUE builder = OBJ_VAL(newInstance(vm, AS_CLASS(string_builder_klass)));
111 |     push(vm, builder);
112 |     StringBuilderData_t *data = GET_NATIVE_INSTANCE_DATA(StringBuilderData_t, builder);
113 |     string_builder_constructor(data);
114 |     return pop(vm);
115 | }
116 | 
117 | void init_string_builder(VM *vm)
118 | {
119 |     string_builder_klass = defineNativeClass(
120 |         vm,
121 |         "StringBuilder",
122 |         &string_builder_constructor,
123 |         &string_builder_destructor,
124 |         NULL,
125 |         NULL,
126 |         CLS_STRING_BUILDER,
127 |         sizeof(StringBuilderData_t),
128 |         true);
129 |     defineNativeMethod(vm, string_builder_klass, &string_builder_to_string, "to_string", 0, false);
130 |     defineNativeMethod(vm, string_builder_klass, &string_builder_append, "append", 1, false);
131 |     defineNativeMethod(vm, string_builder_klass, &string_builder_pop, "pop", 0, false);
132 |     
133 |     defineNativeOperator(vm, string_builder_klass, &string_builder_append, 1, OPERATOR_PLUS);
134 | }


--------------------------------------------------------------------------------
/stdlib/system.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cometlang/comet/e3a93ea6ad83b14bc0566dc09d9889773433f845/stdlib/system.c


--------------------------------------------------------------------------------
/stdlib/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | enable_testing()
 2 | 
 3 | set(COMET_STDLIB_TEST_SOURCES
 4 |     main.c
 5 |     test_list.c
 6 | )
 7 | 
 8 | add_executable(stdlib_tests "${COMET_STDLIB_TEST_SOURCES}")
 9 | target_link_libraries(stdlib_tests PRIVATE vmlib stdlib)
10 | target_include_directories(stdlib_tests PRIVATE
11 |     "${CMAKE_CURRENT_SOURCE_DIR}/../src"
12 |     "${CMAKE_CURRENT_SOURCE_DIR}/../"
13 | )
14 | 
15 | add_test(stdlib_tests stdlib_tests)
16 | 


--------------------------------------------------------------------------------
/stdlib/test/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | 
 3 | #include "common.h"
 4 | #include "tests.h"
 5 | 
 6 | int main(int UNUSED(argc), char UNUSED(**argv))
 7 | {
 8 |     test_list_setup();
 9 | 
10 |     test_list_sort_already_sorted();
11 |     test_list_sort_reverse_sorted();
12 |     test_list_sort_jumbled();
13 | 
14 |     test_list_teardown();
15 | 
16 |     return EXIT_SUCCESS;
17 | }


--------------------------------------------------------------------------------
/stdlib/test/test_list.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "tests.h"
  3 | #include "comet.h"
  4 | 
  5 | #define LIST_SIZE 64
  6 | 
  7 | static VM vm;
  8 | static VALUE already_sorted;
  9 | static VALUE reverse_sorted;
 10 | static VALUE jumbled;
 11 | 
 12 | static VALUE sort_func_name_string;
 13 | 
 14 | static int jumbled_ints[LIST_SIZE] = {
 15 |     35, 13, 10, 41, 64, 36, 12, 51,
 16 |      3, 42, 56, 34, 55, 19,  9, 31,
 17 |     24,  8,  6, 21, 40, 54, 17, 61,
 18 |     58, 47, 18, 11,  4, 26, 48, 14,
 19 |     53, 30, 57, 52, 45, 20, 29, 46,
 20 |     63, 27, 59, 49, 43, 16,  2,  1,
 21 |     23, 39, 38,  7,  5, 37, 28, 44,
 22 |     33, 62, 32, 22, 15, 60, 50, 25,
 23 | };
 24 | 
 25 | void test_list_setup(void)
 26 | {
 27 |     init_comet(&vm);
 28 |     VALUE created;
 29 |     already_sorted = list_create(&vm);
 30 |     push(&vm, already_sorted);
 31 |     for (int i = 0; i < LIST_SIZE; i++) {
 32 |         created = create_number(&vm, i + 1);
 33 |         push(&vm, created);
 34 |         list_add(&vm, already_sorted, 1, &created);
 35 |         pop(&vm);
 36 |     }
 37 | 
 38 |     reverse_sorted = list_create(&vm);
 39 |     push(&vm, reverse_sorted);
 40 |     for (int i = LIST_SIZE; i > 0; i--) {
 41 |         created = create_number(&vm, i);
 42 |         push(&vm, created);
 43 |         list_add(&vm, reverse_sorted, 1, &created);
 44 |         pop(&vm);
 45 |     }
 46 | 
 47 |     jumbled = list_create(&vm);
 48 |     push(&vm, jumbled);
 49 |     for (int i = 0; i < LIST_SIZE; i++) {
 50 |         created = create_number(&vm, jumbled_ints[i]);
 51 |         push(&vm, created);
 52 |         list_add(&vm, jumbled, 1, &created);
 53 |         pop(&vm);
 54 |     }
 55 | 
 56 |     sort_func_name_string = string_create(&vm, "sort", 4);
 57 |     push(&vm, sort_func_name_string);
 58 | }
 59 | 
 60 | void test_list_teardown(void)
 61 | {
 62 |     already_sorted = NIL_VAL;
 63 |     reverse_sorted = NIL_VAL;
 64 |     jumbled = NIL_VAL;
 65 |     sort_func_name_string = NIL_VAL;
 66 |     deregister_thread(&vm);
 67 | }
 68 | 
 69 | static void assert_list_is_sorted(VALUE list)
 70 | {
 71 |     for (int i = 0; i < LIST_SIZE; i++)
 72 |     {
 73 |         VALUE index = create_number(&vm, i);
 74 |         push(&vm, index);
 75 |         VALUE num = list_get_at(&vm, list, 1, &index);
 76 |         pop(&vm);
 77 |         int UNUSED(num_val) = number_get_value(num);
 78 |         DEBUG_ASSERT((i + 1) == num_val);
 79 |     }
 80 | }
 81 | 
 82 | void test_list_sort_already_sorted(void)
 83 | {
 84 |     // act
 85 |     call_function(&vm, already_sorted, sort_func_name_string, 0, NULL);
 86 | 
 87 |     //assert
 88 |     assert_list_is_sorted(already_sorted);
 89 | }
 90 | 
 91 | void test_list_sort_reverse_sorted(void)
 92 | {
 93 |     // act
 94 |     call_function(&vm, reverse_sorted, sort_func_name_string, 0, NULL);
 95 | 
 96 |     //assert
 97 |     assert_list_is_sorted(reverse_sorted);
 98 | }
 99 | 
100 | void test_list_sort_jumbled(void)
101 | {
102 |     // act
103 |     call_function(&vm, jumbled, sort_func_name_string, 0, NULL);
104 | 
105 |     //assert
106 |     assert_list_is_sorted(jumbled);
107 | }
108 | 


--------------------------------------------------------------------------------
/stdlib/test/test_string.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cometlang/comet/e3a93ea6ad83b14bc0566dc09d9889773433f845/stdlib/test/test_string.c


--------------------------------------------------------------------------------
/stdlib/test/tests.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_STDLIB_TESTS_H_
 2 | #define _COMET_STDLIB_TESTS_H_
 3 | 
 4 | void test_list_setup(void);
 5 | void test_list_teardown(void);
 6 | 
 7 | void test_list_sort_already_sorted(void);
 8 | void test_list_sort_reverse_sorted(void);
 9 | void test_list_sort_jumbled(void);
10 | 
11 | #endif


--------------------------------------------------------------------------------
/stdlib/thread.c:
--------------------------------------------------------------------------------
  1 | #include <errno.h>
  2 | #include <stdio.h>
  3 | #include <string.h>
  4 | #include "comet.h"
  5 | #include "comet_stdlib.h"
  6 | #include "cometlib.h"
  7 | #ifdef WIN32
  8 | #include <Windows.h>
  9 | #include <conio.h>
 10 | #include <process.h>
 11 | #else
 12 | #include <pthread.h>
 13 | #endif
 14 | 
 15 | typedef struct {
 16 |     ObjInstance obj;
 17 | #ifdef WIN32
 18 |     HANDLE thread_handle;
 19 |     DWORD thread_id;
 20 | #else
 21 |     pthread_t thread_id;
 22 | #endif
 23 |     VALUE self;
 24 |     VALUE start_routine;
 25 |     VALUE arg;
 26 | } ThreadData;
 27 | 
 28 | void thread_constructor(void *instanceData)
 29 | {
 30 |     ThreadData *data = (ThreadData *)instanceData;
 31 |     data->start_routine = NIL_VAL;
 32 |     data->arg = NIL_VAL;
 33 |     data->self = NIL_VAL;
 34 |     data->thread_id = -1;
 35 | }
 36 | 
 37 | void *thread_runner(void *arg)
 38 | {
 39 |     VM *vm = ALLOCATE(VM, 1);
 40 |     initVM(vm);
 41 |     ThreadData *data = (ThreadData *)arg;
 42 |     call_function(vm, data->self, data->start_routine, 1, &data->arg);
 43 |     void *result = (void *)(uintptr_t)pop(vm);
 44 |     deregister_thread(vm);
 45 |     FREE(VM, vm);
 46 |     return result;
 47 | }
 48 | 
 49 | VALUE thread_start(VM *vm, VALUE self, int arg_count, VALUE *arguments)
 50 | {
 51 |     ThreadData *data = GET_NATIVE_INSTANCE_DATA(ThreadData, self);
 52 |     data->self = self;
 53 |     data->start_routine = arguments[0];
 54 |     data->arg = arg_count > 1 ? arguments[1] : NIL_VAL;
 55 |     int status = 0;
 56 |     if (callable_p(vm, 1, arguments) == FALSE_VAL)
 57 |     {
 58 |         throw_exception_native(vm, "ArgumentException", "The first argument to Thread::start was not callable");
 59 |         return NIL_VAL;
 60 |     }
 61 | #ifdef WIN32
 62 |     data->thread_handle = CreateThread(NULL, 0, &thread_runner, data, 0, &data->thread_id);
 63 |     status = data->thread_handle == NULL ? -1 : 0;
 64 | #else
 65 |     pthread_attr_t thread_attributes;
 66 |     pthread_attr_init(&thread_attributes);
 67 |     status = pthread_create(&data->thread_id, &thread_attributes, &thread_runner, data);
 68 | #endif
 69 |     if (status != 0)
 70 |     {
 71 |         throw_exception_native(vm, "ThreadException", "Unable to start thread");
 72 |     }
 73 | #ifndef WIN32
 74 |     pthread_attr_destroy(&thread_attributes);
 75 | #endif
 76 |     return NIL_VAL;
 77 | }
 78 | 
 79 | VALUE thread_join(VM *vm, VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 80 | {
 81 |     ThreadData *data = GET_NATIVE_INSTANCE_DATA(ThreadData, self);
 82 |     void *result = NULL;
 83 |     int status = 0;
 84 | #ifdef WIN32
 85 |     status = WaitForSingleObject(data->thread_handle, INFINITE) == WAIT_OBJECT_0 ? 0 : -1;
 86 |     CloseHandle(data->thread_handle);
 87 | #else
 88 |     status = pthread_join(data->thread_id, &result);
 89 | #endif
 90 |     if (status != 0)
 91 |     {
 92 |         throw_exception_native(vm, "ThreadException", "Unable to join thread");
 93 |     }
 94 |     if (result != NULL)
 95 |     {
 96 |         return OBJ_VAL(result);
 97 |     }
 98 |     return NIL_VAL;
 99 | }
100 | 
101 | void thread_mark_contents(VALUE self)
102 | {
103 |     ThreadData *data = GET_NATIVE_INSTANCE_DATA(ThreadData, self);
104 |     markValue(data->start_routine);
105 |     markValue(data->arg);
106 | }
107 | 
108 | void init_thread(VM *vm)
109 | {
110 |     VALUE klass = defineNativeClass(
111 |         vm,
112 |         "Thread",
113 |         thread_constructor,
114 |         NULL,
115 |         thread_mark_contents,
116 |         NULL,
117 |         CLS_THREAD,
118 |         sizeof(ThreadData),
119 |         true);
120 |     defineNativeMethod(vm, klass, &thread_start, "start", 1, false);
121 |     defineNativeMethod(vm, klass, &thread_join, "join", 0, false);
122 | }


--------------------------------------------------------------------------------
/stdlib/thread_synchronisation_common.c:
--------------------------------------------------------------------------------
 1 | #include "cometlib.h"
 2 | #include "thread_sync_common.h"
 3 | #include "comet.h"
 4 | 
 5 | void init_thread_sync(VM *vm)
 6 | {
 7 |     VALUE cond_var_class = defineNativeClass(
 8 |         vm, "ConditionVariable", &cond_var_constructor, &cond_var_destructor, NULL, NULL, CLS_COND_VAR, sizeof(CondVarData), false);
 9 |     defineNativeMethod(vm, cond_var_class, &cond_var_signal_one, "signal_one", 0, false);
10 |     defineNativeMethod(vm, cond_var_class, &cond_var_signal_all, "signal_all", 0, false);
11 |     defineNativeMethod(vm, cond_var_class, &cond_var_wait, "wait", 0, false);
12 |     defineNativeMethod(vm, cond_var_class, &cond_var_timed_wait, "timed_wait", 1, false);
13 | 
14 |     VALUE mutex_class = defineNativeClass(vm, "Mutex", &mutex_constructor, &mutex_destructor, NULL, NULL, CLS_MUTEX, sizeof(MutexData), false);
15 |     defineNativeMethod(vm, mutex_class, &mutex_lock, "lock", 0, false);
16 |     defineNativeMethod(vm, mutex_class, &mutex_timed_lock, "timed_lock", 1, false);
17 |     defineNativeMethod(vm, mutex_class, &mutex_unlock, "unlock", 0, false);
18 |     defineNativeMethod(vm, mutex_class, &mutex_try_lock, "try_lock", 0, false);
19 | }
20 | 


--------------------------------------------------------------------------------
/stdlib/thread_synchronisation_unix.c:
--------------------------------------------------------------------------------
  1 | #include <errno.h>
  2 | #include <math.h>
  3 | #include <pthread.h>
  4 | #include <time.h>
  5 | #include "comet_stdlib.h"
  6 | #include "cometlib.h"
  7 | #include "thread_sync_common.h"
  8 | 
  9 | void cond_var_constructor(void *instanceData)
 10 | {
 11 |     CondVarData *data = (CondVarData *)instanceData;
 12 |     pthread_cond_init(&data->cond_var, NULL);
 13 |     pthread_mutex_init(&data->lock, NULL);
 14 | }
 15 | 
 16 | void cond_var_destructor(void *data)
 17 | {
 18 |     CondVarData *cond_var = (CondVarData *)data;
 19 |     pthread_cond_destroy(&cond_var->cond_var);
 20 |     pthread_mutex_destroy(&cond_var->lock);
 21 | }
 22 | 
 23 | VALUE cond_var_signal_one(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 24 | {
 25 |     CondVarData *data = GET_NATIVE_INSTANCE_DATA(CondVarData, self);
 26 |     pthread_cond_signal(&data->cond_var);
 27 |     return NIL_VAL;
 28 | }
 29 | 
 30 | VALUE cond_var_signal_all(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 31 | {
 32 |     CondVarData *data = GET_NATIVE_INSTANCE_DATA(CondVarData, self);
 33 |     pthread_cond_broadcast(&data->cond_var);
 34 |     return NIL_VAL;
 35 | }
 36 | 
 37 | VALUE cond_var_wait(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 38 | {
 39 |     CondVarData *data = GET_NATIVE_INSTANCE_DATA(CondVarData, self);
 40 |     pthread_mutex_lock(&data->lock);
 41 |     pthread_cond_wait(&data->cond_var, &data->lock);
 42 |     pthread_mutex_unlock(&data->lock);
 43 |     return NIL_VAL;
 44 | }
 45 | 
 46 | static void get_wait_time(struct timespec *time, double wait_interval_s)
 47 | {
 48 |     clock_gettime(CLOCK_REALTIME, time);
 49 |     double wait_increment = wait_interval_s;
 50 |     long wait_s = floor(wait_increment);
 51 |     long wait_ns = (wait_increment - wait_s) * NANO_SECONDS_PER_SECOND;
 52 |     time->tv_sec += wait_s;
 53 |     time->tv_nsec += wait_ns;
 54 | }
 55 | 
 56 | VALUE cond_var_timed_wait(VM *vm, VALUE self, int UNUSED(arg_count), VALUE *arguments)
 57 | {
 58 |     CondVarData *data = GET_NATIVE_INSTANCE_DATA(CondVarData, self);
 59 |     pthread_mutex_lock(&data->lock);
 60 |     struct timespec wait_time;
 61 |     get_wait_time(&wait_time, number_get_value(arguments[0]));
 62 |     int result = pthread_cond_timedwait(&data->cond_var, &data->lock, &wait_time);
 63 |     pthread_mutex_unlock(&data->lock);
 64 |     if (result == ETIMEDOUT)
 65 |     {
 66 |         throw_exception_native(vm, "TimeoutException", "Interval elapsed");
 67 |     }
 68 |     return NIL_VAL;
 69 | }
 70 | 
 71 | void mutex_constructor(void *instanceData)
 72 | {
 73 |     MutexData *data = (MutexData *)instanceData;
 74 |     pthread_mutex_init(&data->mutex, NULL);
 75 | }
 76 | 
 77 | void mutex_destructor(void *data)
 78 | {
 79 |     pthread_mutex_destroy(&((MutexData *)data)->mutex);
 80 | }
 81 | 
 82 | VALUE mutex_unlock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 83 | {
 84 |     MutexData *data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
 85 |     pthread_mutex_unlock(&data->mutex);
 86 |     return NIL_VAL;
 87 | }
 88 | 
 89 | VALUE mutex_lock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 90 | {
 91 |     MutexData *data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
 92 |     pthread_mutex_lock(&data->mutex);
 93 |     return NIL_VAL;
 94 | }
 95 | 
 96 | VALUE mutex_try_lock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
 97 | {
 98 |     MutexData *data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
 99 |     if (pthread_mutex_trylock(&data->mutex) == 0)
100 |         return TRUE_VAL;
101 |     return FALSE_VAL;
102 | }
103 | 
104 | VALUE mutex_timed_lock(VM *vm, VALUE self, int UNUSED(arg_count), VALUE *arguments)
105 | {
106 |     MutexData *data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
107 |     struct timespec wait_time;
108 |     get_wait_time(&wait_time, number_get_value(arguments[0]));
109 |     int result = pthread_mutex_timedlock(&data->mutex, &wait_time);
110 |     if (result == ETIMEDOUT)
111 |     {
112 |         throw_exception_native(vm, "TimeoutException", "Interval elapsed");
113 |     }
114 |     return NIL_VAL;
115 | }
116 | 


--------------------------------------------------------------------------------
/stdlib/thread_synchronisation_win.c:
--------------------------------------------------------------------------------
 1 | #include <errno.h>
 2 | #include <math.h>
 3 | #include <time.h>
 4 | #include "comet_stdlib.h"
 5 | #include "cometlib.h"
 6 | #include "thread_sync_common.h"
 7 | #include <Windows.h>
 8 | 
 9 | void cond_var_constructor(void *instanceData)
10 | {
11 |     CondVarData* data = (CondVarData *)instanceData;
12 |     InitializeConditionVariable(&data->cond_var);
13 |     InitializeCriticalSection(&data->critical_section);
14 | }
15 | 
16 | void cond_var_destructor(void* data)
17 | {
18 |     CondVarData* cond_var = (CondVarData*)data;
19 |     DeleteCriticalSection(&cond_var->critical_section);
20 | }
21 | 
22 | VALUE cond_var_signal_one(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments)) { return NIL_VAL; }
23 | VALUE cond_var_signal_all(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments)) { return NIL_VAL; }
24 | VALUE cond_var_wait(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments)) { return NIL_VAL; }
25 | VALUE cond_var_timed_wait(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments)) { return NIL_VAL; }
26 | 
27 | void mutex_constructor(void *instanceData)
28 | {
29 |     MutexData* data = (MutexData *)instanceData;
30 |     data->mutex = CreateMutex(NULL, FALSE, NULL);
31 | }
32 | 
33 | void mutex_destructor(void* data)
34 | {
35 |     MutexData* cond_var = (MutexData*)data;
36 |     CloseHandle(cond_var->mutex);
37 | }
38 | 
39 | VALUE mutex_lock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
40 | {
41 |     MutexData* data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
42 |     WaitForSingleObject(data->mutex, INFINITE);
43 |     return NIL_VAL;
44 | }
45 | 
46 | VALUE mutex_timed_lock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
47 | {
48 |     MutexData* data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
49 |     DWORD wait_time = (DWORD)number_get_value(arguments[0]) * MILLI_SECONDS_PER_SECOND;
50 |     if (WaitForSingleObject(data->mutex, wait_time) == WAIT_TIMEOUT)
51 |         throw_exception_native(vm, "TimeoutException", "Interval elapsed");
52 |     return NIL_VAL;
53 | }
54 | 
55 | VALUE mutex_unlock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
56 | {
57 |     MutexData* data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
58 |     if (!ReleaseMutex(data->mutex))
59 |     {
60 |         throw_exception_native(vm, "Exception", "Could not unlock the mutex");
61 |     }
62 |     return NIL_VAL;
63 | }
64 | 
65 | VALUE mutex_try_lock(VM UNUSED(*vm), VALUE self, int UNUSED(arg_count), VALUE UNUSED(*arguments))
66 | {
67 |     MutexData* data = GET_NATIVE_INSTANCE_DATA(MutexData, self);
68 |     if (WaitForSingleObject(data->mutex, 0L) == WAIT_OBJECT_0)
69 |         return TRUE_VAL;
70 |     return FALSE_VAL;
71 | }
72 | 


--------------------------------------------------------------------------------
/stdlib/unittest/_init.cmt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cometlang/comet/e3a93ea6ad83b14bc0566dc09d9889773433f845/stdlib/unittest/_init.cmt


--------------------------------------------------------------------------------
/test_scripts/argument_exception_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_argument_nil_throws_when_nil() {
 4 |     unittest.Assert.that((||) {
 5 |         ArgumentException.throw_if_nil(nil)
 6 |     }).throws()
 7 | }
 8 | 
 9 | function test_argument_nil_does_not_throw_when_not_nil() {
10 |     unittest.Assert.that((||) {
11 |         ArgumentException.throw_if_nil("this is not nil")
12 |     }).does_not_throw()
13 | }
14 | 
15 | function test_throw_if_nil_or_whitespace_nil_throws() {
16 |     unittest.Assert.that((||) {
17 |         ArgumentException.throw_if_nil_or_whitespace(nil)
18 |     }).throws()
19 | }
20 | 
21 | function test_throw_if_nil_or_whitespace_whitespace_throws() {
22 |     unittest.Assert.that((||) {
23 |         ArgumentException.throw_if_nil_or_whitespace("   \n\t")
24 |     }).throws()
25 | }
26 | 
27 | function test_throw_if_nil_or_whitespace_empty_string_throws() {
28 |     unittest.Assert.that((||) {
29 |         ArgumentException.throw_if_nil_or_whitespace("")
30 |     }).throws()
31 | }
32 | 
33 | function test_throw_if_nil_or_whitespace_not_nil_does_not_throw() {
34 |     unittest.Assert.that((||) {
35 |         ArgumentException.throw_if_nil_or_whitespace("this is not nil")
36 |     }).does_not_throw()
37 | }
38 | 
39 | 
40 | function test_throw_if_nil_or_empty_nil_throws() {
41 |     unittest.Assert.that((||) {
42 |         ArgumentException.throw_if_nil_or_empty("this is not nil")
43 |     }).does_not_throw()
44 | }
45 | 
46 | function test_throw_if_nil_or_empty_empty_throws() {
47 |     unittest.Assert.that((||) {
48 |         ArgumentException.throw_if_nil_or_whitespace("")
49 |     }).throws()
50 | }
51 | 
52 | function test_throw_if_nil_or_empty_empty_collection_throws() {
53 |     unittest.Assert.that((||) {
54 |         ArgumentException.throw_if_nil_or_whitespace([])
55 |     }).throws()
56 | }
57 | 
58 | function test_throw_if_nil_or_empty_not_empty_does_not_throw() {
59 |     unittest.Assert.that((||) {
60 |         ArgumentException.throw_if_nil_or_empty("this is not empty")
61 |     }).does_not_throw()
62 | }
63 | 
64 | function test_throw_if_nil_or_empty_whitespace_does_not_throw() {
65 |     unittest.Assert.that((||) {
66 |         ArgumentException.throw_if_nil_or_empty("   \n\t")
67 |     }).does_not_throw()
68 | }
69 | 
70 | function test_throw_if_empty_empty_throws() {
71 |     unittest.Assert.that((||) {
72 |         ArgumentException.throw_if_empty("")
73 |     }).throws()
74 | }
75 | 
76 | function test_throw_if_empty_empty_collection_throws() {
77 |     unittest.Assert.that((||) {
78 |         ArgumentException.throw_if_empty({})
79 |     }).throws()
80 | }
81 | 
82 | function test_throw_if_empty_nil_does_not_throw() {
83 |     unittest.Assert.that((||) {
84 |         ArgumentException.throw_if_empty(nil)
85 |     }).does_not_throw()
86 | }
87 | 
88 | function test_throw_if_empty_not_empty_does_not_throw() {
89 |     unittest.Assert.that((||) {
90 |         ArgumentException.throw_if_empty(["this is a string"])
91 |     }).does_not_throw()
92 | }
93 | 


--------------------------------------------------------------------------------
/test_scripts/attribute_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class Attribute {
 4 |     init(str) {
 5 |         self.str = str
 6 |     }
 7 | }
 8 | 
 9 | @Attribute('This is a function attribute')
10 | function attribute_function() {
11 | }
12 | 
13 | @Attribute('This is a class attribute')
14 | class Something {
15 | 
16 |     @Attribute('this is a method attribute')
17 |     some_method() {
18 | 
19 |     }
20 | 
21 |     @Attribute('this is a static method attribute')
22 |     static some_static_method() {
23 | 
24 |     }
25 | 
26 | }
27 | 
28 | function test_class_attribute() {
29 |     var attributes = Something.attributes()
30 |     unittest.Assert.that(attributes).has_count(1)
31 |     unittest.Assert.that(attributes[0]).is_of_type(Attribute)
32 | }
33 | 
34 | function test_function_attribute() {
35 |     var attributes = attribute_function.attributes()
36 |     unittest.Assert.that(attributes).has_count(1)
37 |     unittest.Assert.that(attributes[0]).is_of_type(Attribute)
38 | }
39 | 


--------------------------------------------------------------------------------
/test_scripts/boolean.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_literal_bools() {
 4 |     unittest.Assert.that(true).is_true()
 5 |     unittest.Assert.that(false).is_false()
 6 |     unittest.Assert.that(true == false).is_false()
 7 | }
 8 | 
 9 | function test_parse_true() {
10 |     var test_true = [
11 |         'true', 'True', 'tRue', 'trUe', 'truE',
12 |         'TRue', 'tRUe', 'trUE', 'TrUe', 'tRuE', 'TruE',
13 |         'TRUe', 'TRuE', 'TRUE'
14 |     ]
15 |     foreach (var test in test_true) {
16 |         var result = Boolean.parse(test)
17 |         unittest.Assert.that(result).is_true()
18 |     }
19 | }
20 | 
21 | function test_parse_false() {
22 |     var test_false = [
23 |         'False', 'false', 'FALSE', 'fAlse'
24 |     ]
25 |     foreach (var test in test_false) {
26 |         var result = Boolean.parse(test)
27 |         unittest.Assert.that(result).is_false()
28 |     }
29 | }
30 | 
31 | function test_parse_gibberish() {
32 |     unittest.Assert.that((||) {
33 |         Boolean.parse('gibberish')
34 |     }).throws()
35 | }
36 | 


--------------------------------------------------------------------------------
/test_scripts/class_inherits_constructor.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | var made_it_to_super = false
 4 | var param_correct = false
 5 | 
 6 | class SomeClass
 7 | {
 8 |     init(param) {
 9 |         made_it_to_super = true
10 |         param_correct = (param == "hello")
11 |     }
12 | }
13 | 
14 | class final FinalClass : SomeClass
15 | {
16 |     init(param) {
17 |         self.made_it_to_super = false
18 |         self.param_correct = false
19 |         super.init(param)
20 |     }
21 | }
22 | 
23 | function test_class_inherits_constructor() {
24 |     var instance = FinalClass("hello")
25 |     unittest.Assert.that(made_it_to_super).is_true()
26 |     unittest.Assert.that(param_correct).is_true()
27 | }
28 | 


--------------------------------------------------------------------------------
/test_scripts/class_inherits_imported_class.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | import 'class_inherits_object' as imported
 3 | 
 4 | class final SomeOtherClass : imported.SomeClass {
 5 | 
 6 | }
 7 | 
 8 | 
 9 | function test_class_can_inherit_imported_class() {
10 |     var instance = SomeOtherClass()
11 |     unittest.Assert.that(instance).is_of_type(imported.SomeClass)
12 | }
13 | 
14 | 


--------------------------------------------------------------------------------
/test_scripts/class_inherits_object.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class SomeClass
 4 | {
 5 | }
 6 | 
 7 | 
 8 | class final FinalClass
 9 | {
10 | }
11 | 
12 | function test_object_inheritance() {
13 |     var instance = SomeClass()
14 |     unittest.Assert.that(instance).is_of_type(Object)
15 |     unittest.Assert.that(instance.hash()).is_of_type(Number)
16 |     unittest.Assert.that(instance.to_string()).is_of_type(String)
17 |     unittest.Assert.that(instance).is_not_nil()
18 | }
19 | 


--------------------------------------------------------------------------------
/test_scripts/class_operator_overload.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class TestClass
 4 | {
 5 |     init()
 6 |     {
 7 |         self.items = []
 8 |     }
 9 | 
10 |     operator[] (index)
11 |     {
12 |         return self.items[index]
13 |     }
14 | 
15 |     append(item)
16 |     {
17 |         self.items.push(item)
18 |     }
19 | }
20 | 
21 | function test_class_with_operator() {
22 |     var test = TestClass()
23 |     test.append("hello")
24 | 
25 |     unittest.Assert.that(test[0]).is_equal_to("hello")
26 | }
27 | 


--------------------------------------------------------------------------------
/test_scripts/class_with_field.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class TestClass
 4 | {
 5 |     init()
 6 |     {
 7 |         self.item = "initializer"
 8 |         self.prop = 0
 9 |     }
10 | 
11 |     do_thing()
12 |     {
13 |         self.prop += 1
14 |     }
15 | 
16 |     get_item()
17 |     {
18 |         return self.item
19 |     }
20 | }
21 | 
22 | function test_class_with_field() {
23 |     var test = TestClass()
24 |     test.do_thing()
25 |     unittest.Assert.that(test.get_item()).is_equal_to("initializer")
26 |     unittest.Assert.that(test.prop).is_equal_to(1)
27 | }


--------------------------------------------------------------------------------
/test_scripts/colour.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | @unittest.test_case(Colour(0, 0, 0), COLOUR_CATEGORY.BLACK)
 4 | @unittest.test_case(Colour(255, 255, 255), COLOUR_CATEGORY.WHITE)
 5 | @unittest.test_case(Colour(128, 128, 128), COLOUR_CATEGORY.GREY)
 6 | @unittest.test_case(Colour(255, 0, 0), COLOUR_CATEGORY.RED)
 7 | @unittest.test_case(Colour(255, 128, 0), COLOUR_CATEGORY.ORANGE)
 8 | @unittest.test_case(Colour(255, 255, 0), COLOUR_CATEGORY.YELLOW)
 9 | @unittest.test_case(Colour(0, 255, 0), COLOUR_CATEGORY.GREEN)
10 | @unittest.test_case(Colour(0, 255, 255), COLOUR_CATEGORY.CYAN)
11 | @unittest.test_case(Colour(0, 0, 255), COLOUR_CATEGORY.BLUE)
12 | @unittest.test_case(Colour(255, 0, 255), COLOUR_CATEGORY.MAGENTA)
13 | function test_colour_categorise(colour, category) {
14 |     unittest.Assert.that(colour.categorise()).is_equal_to(category)
15 | }


--------------------------------------------------------------------------------
/test_scripts/complex_exception_with_finally.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class Exception_a : Exception {}
 4 | 
 5 | class Exception_b : Exception {}
 6 | 
 7 | var exception_a_handler_hit = false
 8 | var exception_a_finally_hit = false
 9 | var exception_b_finally_hit = false
10 | 
11 | 
12 | function function_a()
13 | {
14 |     try
15 |     {
16 |         function_b()
17 |     }
18 |     catch (Exception_a as ex)
19 |     {
20 |         exception_a_handler_hit = true
21 |     }
22 |     finally
23 |     {
24 |         exception_a_finally_hit = true
25 |     }
26 | }
27 | 
28 | function function_b()
29 | {
30 |     try
31 |     {
32 |         function_c()
33 |     }
34 |     catch (Exception_b)
35 |     {
36 |         unittest.Assert.fail()
37 |     }
38 |     finally
39 |     {
40 |         exception_b_finally_hit = true
41 |     }
42 | }
43 | 
44 | function function_c()
45 | {
46 |     throw Exception_a()
47 | }
48 | 
49 | 
50 | function test_complex_exceptions() {
51 |     function_a()
52 |     unittest.Assert.that(exception_a_handler_hit).is_true()
53 |     unittest.Assert.that(exception_a_finally_hit).is_true()
54 |     unittest.Assert.that(exception_b_finally_hit).is_true()
55 | }
56 | 


--------------------------------------------------------------------------------
/test_scripts/datetime_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_create_from_integers() {
 4 |     var datetime = DateTime(2023, 3, 7, 18, 15, 35, 102)
 5 |     unittest.Assert.that(datetime.year()).is_equal_to(2023, "year")
 6 |     unittest.Assert.that(datetime.month()).is_equal_to(3, "month")
 7 |     unittest.Assert.that(datetime.day()).is_equal_to(7, "day")
 8 |     unittest.Assert.that(datetime.hours()).is_equal_to(18)
 9 |     unittest.Assert.that(datetime.minutes()).is_equal_to(15)
10 |     unittest.Assert.that(datetime.seconds()).is_equal_to(35)
11 |     unittest.Assert.that(datetime.milliseconds()).is_equal_to(102)
12 | }
13 | 
14 | # @unittest.ignore('Failing on the linux build')
15 | function x_test_can_parse_from_default_to_string() {
16 |     var datetime = DateTime.now()
17 |     var parsed = DateTime.parse(datetime.to_string())
18 | 
19 |     unittest.Assert.that(datetime.year()).is_equal_to(parsed.year(), "year")
20 |     unittest.Assert.that(datetime.month()).is_equal_to(parsed.month(), "month")
21 |     unittest.Assert.that(datetime.day()).is_equal_to(parsed.day(), "day")
22 |     unittest.Assert.that(datetime.hours()).is_equal_to(parsed.hours(), "hours")
23 |     unittest.Assert.that(datetime.minutes()).is_equal_to(parsed.minutes(), "minutes")
24 |     unittest.Assert.that(datetime.seconds()).is_equal_to(parsed.seconds(), "seconds")
25 |     unittest.Assert.that(datetime.milliseconds()).is_equal_to(parsed.milliseconds(), "milliseconds")
26 | }
27 | 
28 | @unittest.ignore('Failing on the linux build')
29 | function x_test_can_parse_non_standard_format_with_format_string() {
30 |     var to_parse = '2023-07-20 16:36:01.6543'
31 | 
32 |     var result = DateTime.parse(to_parse, '%Y-%m-%d %H:%M:%6S')
33 | 
34 |     unittest.Assert.that(result.year()).is_equal_to(2023)
35 |     unittest.Assert.that(result.month()).is_equal_to(7)
36 |     unittest.Assert.that(result.day()).is_equal_to(20)
37 |     unittest.Assert.that(result.hours()).is_equal_to(16)
38 |     unittest.Assert.that(result.minutes()).is_equal_to(36)
39 |     unittest.Assert.that(result.seconds()).is_equal_to(1)
40 | }
41 | 
42 | function test_parse_throws_exception_when_datetime_cannot_be_parsed() {
43 |     var to_parse = 'this is not a date'
44 | 
45 |     unittest.Assert.that((||) {
46 |         var result = DateTime.parse(to_parse)
47 |     }).throws()
48 | }


--------------------------------------------------------------------------------
/test_scripts/default_params.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_default_params(number=1234, string='string', bool=false, list=[], hash={})
 4 | {
 5 |     unittest.Assert.that(number).is_equal_to(1234)
 6 |     unittest.Assert.that(string).is_equal_to('string')
 7 |     unittest.Assert.that(bool).is_equal_to(false)
 8 |     unittest.Assert.that(list).is_empty()
 9 |     unittest.Assert.that(hash).is_empty()
10 | }
11 | 


--------------------------------------------------------------------------------
/test_scripts/directory_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | var TEST_DIR_NAME = 'test_dir'
 4 | 
 5 | function test_directory_creation_and_deletion() {
 6 |     unittest.Assert.that(Directory.directory?(TEST_DIR_NAME)).is_false('directory should not exist before the test')
 7 |     Directory.create(TEST_DIR_NAME)
 8 |     unittest.Assert.that(Directory.directory?(TEST_DIR_NAME)).is_true('directory should have been created')
 9 |     Directory.remove(TEST_DIR_NAME)
10 |     unittest.Assert.that(Directory.directory?(TEST_DIR_NAME)).is_false('directory should have been deleted')
11 | }
12 | 
13 | function test_directory_absolute_path() {
14 |     var dir = Directory('.')
15 |     unittest.Assert.that(dir.absolute().to_string()).is_not_equal_to('.')
16 | }


--------------------------------------------------------------------------------
/test_scripts/duration_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | var start = DateTime(2023, 4, 4, 6, 7, 33)
 4 | var end = DateTime(2023, 4, 4, 6, 8, 12)
 5 | 
 6 | var duration = end - start
 7 | 
 8 | function test_duration_creation() {
 9 |     unittest.Assert.that(duration.nanoseconds).is_equal_to(39_000_000_000)
10 |     unittest.Assert.that(duration.milliseconds).is_equal_to(39_000)
11 |     unittest.Assert.that(duration.seconds).is_equal_to(39)
12 | }
13 | 
14 | function test_duration_to_string() {
15 |     unittest.Assert.that(duration.to_string()).is_equal_to('39000000000ns')
16 | }


--------------------------------------------------------------------------------
/test_scripts/enum_declaration.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | enum MY_ENUM {
 4 |     zero,
 5 |     one,
 6 |     two = 2,
 7 |     four = 4,
 8 |     five,
 9 | }
10 | 
11 | function test_enum_to_string() {
12 |     unittest.Assert.that(MY_ENUM.one.to_string()).is_equal_to('one:1')
13 | }
14 | 
15 | function test_enum_value() {
16 |     unittest.Assert.that(MY_ENUM.two.value).is_equal_to(2)
17 | }
18 | 
19 | function test_enum_name() {
20 |     unittest.Assert.that(MY_ENUM.two.name).is_equal_to('two')
21 | }
22 | 
23 | function test_enum_parse_string() {
24 |     unittest.Assert.that(MY_ENUM.parse('four')).is_equal_to(MY_ENUM.four)
25 | }
26 | 
27 | function test_enum_parse_number() {
28 |     unittest.Assert.that(MY_ENUM.parse(5)).is_equal_to(MY_ENUM.five)
29 | }
30 | 
31 | function test_enum_count() {
32 |     unittest.Assert.that(MY_ENUM.count()).is_equal_to(5)
33 | }
34 | 
35 | function test_enum_contains() {
36 |     unittest.Assert.that(MY_ENUM).contains(MY_ENUM.four)
37 | }


--------------------------------------------------------------------------------
/test_scripts/env_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_env_vars() {
 4 |     var value = 'other'
 5 | 
 6 |     # set the variable
 7 |     ENV['something'] = value
 8 | 
 9 |     # get the variable
10 |     var result = ENV['something']
11 | 
12 |     unittest.Assert.that(result).is_equal_to(value)
13 |     
14 |     # unset the variable
15 |     ENV['something'] = nil
16 | 
17 |     # assert that the environment variable is no longer set
18 |     unittest.Assert.that((||) {
19 |         ENV['something']
20 |     }).throws()
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/test_scripts/exception_handler.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function first_function()
 4 | {
 5 |     try
 6 |     {
 7 |         second_function()
 8 |     }
 9 |     catch (Exception as ex)
10 |     {
11 |         unittest.Assert.that(ex.message()).is_equal_to('My exception has a message')
12 |         rethrow ex
13 |     }
14 | }
15 | 
16 | function second_function()
17 | {
18 |     throw Exception("My exception has a message")
19 | }
20 | 
21 | function test_empty_try_finally() {
22 |     try {
23 |         var message = "inside the try"
24 |     }
25 |     finally {
26 |         var message = 'finally after try'
27 |     }
28 | }
29 | 
30 | function test_exception_handling() {
31 |     unittest.Assert.that(first_function).throws()
32 | }
33 | 


--------------------------------------------------------------------------------
/test_scripts/file_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | var FILE_NAME = 'test.txt'
 3 | 
 4 | function test_files() {
 5 |     var file = File.open(FILE_NAME, FOPEN.READ_WRITE)
 6 |     file.write("This is a test file")
 7 |     file.close()
 8 |     unittest.Assert.that(File.exists?(FILE_NAME)).is_true()
 9 | 
10 |     var lines = File.read_all_lines(FILE_NAME)
11 |     foreach (var line in lines)
12 |     {
13 |         unittest.Assert.that(line).is_equal_to('This is a test file')
14 |     }
15 | 
16 |     File.delete(FILE_NAME)
17 |     unittest.Assert.that(File.exists?(FILE_NAME)).is_false()
18 | }
19 | 
20 | function test_read_line() {
21 |     var file = File.open(FILE_NAME, FOPEN.READ_WRITE)
22 |     file.write("This is a test file\n")
23 |     file.write("This is a test file")
24 |     file.close()
25 |     unittest.Assert.that(File.exists?(FILE_NAME)).is_true()
26 | 
27 |     file = File.open(FILE_NAME, FOPEN.READ_ONLY)
28 |     var line = file.read_line()
29 |     unittest.Assert.that(line).is_equal_to('This is a test file')
30 |     line = file.read_line()
31 |     unittest.Assert.that(line).is_equal_to('This is a test file')
32 | 
33 |     File.delete(FILE_NAME)
34 |     unittest.Assert.that(File.exists?(FILE_NAME)).is_false()
35 | }
36 | 
37 | 


--------------------------------------------------------------------------------
/test_scripts/for_loop_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | var list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 4 | 
 5 | function test_for_loop() {
 6 |     for(var i = 0; i < 10; i += 1) {
 7 |         unittest.Assert.that(i).is_equal_to(list[i])
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/test_scripts/foreach_loops.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_foreach_loop() {
 4 |     var list = []
 5 | 
 6 |     var str = "T H I S"
 7 |     foreach(var char in str)
 8 |     {
 9 |         if (char == ' ')
10 |         {
11 |             next
12 |         }
13 |         else
14 |         {
15 |             list.push(char)
16 |         }
17 |     }
18 | 
19 |     foreach (var char in list) {
20 |         unittest.Assert.that(char).is_not_equal_to(' ')
21 |     }
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/test_scripts/hash_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_static_hash_inititalisation() {
 4 |     var some_hash = {
 5 |         "key": "value",
 6 |         "other key" : "other value",
 7 |     }
 8 | 
 9 |     unittest.Assert.that(some_hash['key']).is_equal_to('value')
10 | }
11 | 
12 | function test_hash_with_number_keys() {
13 |     var some_hash = {
14 |         123: 'value',
15 |         456: 'other value',
16 |     }
17 | 
18 |     unittest.Assert.that(some_hash[123]).is_equal_to('value')
19 | }
20 | 
21 | function test_hash_contains_string() {
22 |     var some_hash = {
23 |         "key": "value",
24 |         "other key" : "other value",
25 |     }
26 | 
27 |     unittest.Assert.that(some_hash).contains('value')
28 | }
29 | 
30 | function test_hash_contains_number() {
31 |     var some_hash = {
32 |         "key": 123,
33 |         "other key" : 456,
34 |     }
35 | 
36 |     unittest.Assert.that(some_hash).contains(123)
37 | }
38 | 
39 | function test_hash_contains_mixed() {
40 |     var some_hash = {
41 |         'key': 1234,
42 |         567: 'other value',
43 |         true: DateTime.now(),
44 |     }
45 | 
46 |     unittest.Assert.that(some_hash).contains(1234)
47 | }
48 | 
49 | function test_hash_values() {
50 |     var some_hash = {
51 |         'key': 1234,
52 |         567: 'other value',
53 |         true: false,
54 |     }
55 | 
56 |     var result = some_hash.values()
57 | 
58 |     unittest.Assert.that(result).has_count(3)
59 |     unittest.Assert.that(result).contains(1234)
60 |     unittest.Assert.that(result).contains('other value')
61 |     unittest.Assert.that(result).contains(false)
62 | }
63 | 
64 | function test_hash_key_with_nonobject() {
65 |     var obj = Object()
66 |     var some_hash = {
67 |         Object: obj,
68 |     }
69 | 
70 |     unittest.Assert.that(some_hash[Object]).is_equal_to(obj)
71 | }
72 | 
73 | function test_hash_keys() {
74 |     var some_hash = {
75 |         'other_key': 1234,
76 |         'key': 4321,
77 |         'my key': 1423,
78 |     }
79 | 
80 |     var keys = some_hash.keys()
81 |     keys.sort()
82 | 
83 |     unittest.Assert.that(keys).has_count(3)
84 |     unittest.Assert.that(keys[0]).is_equal_to('key')
85 |     unittest.Assert.that(keys[1]).is_equal_to('my key')
86 |     unittest.Assert.that(keys[2]).is_equal_to('other_key')
87 | }


--------------------------------------------------------------------------------
/test_scripts/image.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_image() {
 4 |     var width = 200
 5 |     var height = 100
 6 | 
 7 |     var my_colour = Colour(0, 255, 125)
 8 | 
 9 |     var image = Image(width, height)
10 |     for (var y = 0; y < height; y+=1) {
11 |         for (var x = 0; x < width; x+=1) {
12 |             image.set_pixel(x, y, my_colour)
13 |         }
14 |     }
15 | 
16 |     var colour = image.get_pixel(50, 50)
17 |     unittest.Assert.that(colour).is_of_type(Colour)
18 |     unittest.Assert.that(colour.red()).is_equal_to(0)
19 |     unittest.Assert.that(colour.green()).is_equal_to(255)
20 |     unittest.Assert.that(colour.blue()).is_equal_to(125)
21 | 
22 |     image.write_to_file("test.png", IMAGE_FORMAT.PNG)
23 |     image.write_to_file("test.jpg", IMAGE_FORMAT.JPEG)
24 |     image.write_to_file("test.bmp", IMAGE_FORMAT.BMP)
25 | 
26 |     unittest.Assert.that(File.exists?('test.png')).is_true()
27 |     unittest.Assert.that(File.exists?('test.jpg')).is_true()
28 |     unittest.Assert.that(File.exists?('test.bmp')).is_true()
29 | 
30 |     File.delete('test.png')
31 |     File.delete('test.jpg')
32 |     File.delete('test.bmp')
33 | }
34 | 


--------------------------------------------------------------------------------
/test_scripts/import_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'import_test/secondary' as secondary
 2 | import { Assert } from 'unittest'
 3 | 
 4 | function test_import() {
 5 |     Assert.that(secondary).is_of_type(Module)
 6 | }
 7 | 
 8 | function test_module_index_operator() {
 9 |     var print_something = secondary['print_something']
10 |     Assert.that(print_something).is_callable()
11 | }


--------------------------------------------------------------------------------
/test_scripts/import_test/main.cmt:
--------------------------------------------------------------------------------
1 | import './secondary' as secondary
2 | 
3 | if (__MAIN__ == __FILE__) {
4 |     secondary.print_something()
5 | } else {
6 |     print("nothing")
7 | }
8 | 


--------------------------------------------------------------------------------
/test_scripts/import_test/secondary.cmt:
--------------------------------------------------------------------------------
1 | function print_something()
2 | {
3 |     print("Something")
4 | }


--------------------------------------------------------------------------------
/test_scripts/is.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class ParentClass
 4 | {
 5 | 
 6 | }
 7 | 
 8 | class ChildClass : ParentClass
 9 | {
10 | 
11 | }
12 | 
13 | function test_is_operator() {
14 |     var parent = ParentClass()
15 |     var child = ChildClass()
16 | 
17 |     unittest.Assert.that(parent is ParentClass).is_true("Expect parent to be is ParentClass")
18 |     unittest.Assert.that(child is ParentClass).is_true("Expect child to be is ParentClass")
19 |     unittest.Assert.that(child is ChildClass).is_true("Expect child to be is ChildClass")
20 |     unittest.Assert.that(child is Object).is_true("Expect child to be is Object")
21 |     unittest.Assert.that(!child is Exception).is_true("Expect child not to be is Exception")
22 | }
23 | 
24 | function test_builtin_types() {
25 |     unittest.Assert.that("this is a string" is Object).is_true("Expect a literal string to be is Object")
26 |     unittest.Assert.that("this is a string" is String).is_true("Expect a literal string to be is String")
27 |     unittest.Assert.that(1 is Number).is_true("Expect literal number to be an instance of a Number class")
28 | }
29 | 


--------------------------------------------------------------------------------
/test_scripts/json_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'json' as json
 2 | import 'unittest' as unittest
 3 | 
 4 | var test_hash = {
 5 |     'string': 'this is a string',
 6 |     'date': "2023-05-18T19:55:36.000+00:00",
 7 |     'number': 12345,
 8 |     'skip': [ 54321 ],
 9 | }
10 | 
11 | var test_string = '{"date": "2023-05-18T19:55:36.000+00:00", "string": "this is a string", "number": 12345, "other": [ 54321 ]}'
12 | 
13 | function test_to_json_string() {
14 |     var str = json.to_json_string(test_hash)
15 | 
16 |     var obj = json.parse_from_string(test_string)
17 | 
18 |     foreach (var key in test_hash) {
19 |         if (key != 'skip') {
20 |             unittest.Assert.that(obj.has_key?(key)).is_true()
21 |             unittest.Assert.that(obj[key]).is_equal_to(test_hash[key])
22 |         }
23 |     }
24 | }
25 | 
26 | function test_parse_from_string() {
27 |     var obj = json.parse_from_string(test_string)
28 | 
29 |     foreach (var key in test_hash) {
30 |         if (key != 'skip') {
31 |             unittest.Assert.that(obj.has_key?(key)).is_true()
32 |             unittest.Assert.that(obj[key]).is_equal_to(test_hash[key])
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/test_scripts/lambda.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function callee(lambda) {
 4 |     lambda(true)
 5 | }
 6 | 
 7 | function test_basic_args() {
 8 |     callee((|result|) {
 9 |         unittest.Assert.that(result).is_true()
10 |     })
11 | }
12 | 
13 | function calls_lambda(lambda) {
14 |     var result = lambda()
15 |     unittest.Assert.that(result).is_true()
16 | } 
17 | 
18 | function test_empty_args() {
19 |     calls_lambda((||) {
20 |         return true
21 |     })
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/test_scripts/list_test.cmt:
--------------------------------------------------------------------------------
  1 | import 'unittest' as unittest
  2 | 
  3 | function test_basic_list() {
  4 |     var test = []
  5 |     test.add("hi")
  6 |     unittest.Assert.that(test[0]).is_equal_to('hi')
  7 | }
  8 | 
  9 | function test_multiple_additions() {
 10 |     var list = List()
 11 | 
 12 |     list.add("This")
 13 |     list.add("is")
 14 |     list.add("a")
 15 |     list.add("list")
 16 | 
 17 |     list.add("strings
 18 | are
 19 | multi-line
 20 | by default")
 21 | 
 22 |     unittest.Assert.that(list[4]).is_equal_to('strings\nare\nmulti-line\nby default')
 23 | }
 24 | 
 25 | function test_filter() {
 26 |     var filtered_list = ['a', 1, 'a', '2', 3, 'a'].filter((|item|) {
 27 |         return item == 'a'
 28 |     })
 29 | 
 30 |     unittest.Assert.that(filtered_list.length()).is_equal_to(3)
 31 |     unittest.Assert.that(filtered_list[0]).is_equal_to('a')
 32 |     unittest.Assert.that(filtered_list[1]).is_equal_to('a')
 33 |     unittest.Assert.that(filtered_list[2]).is_equal_to('a')
 34 | }
 35 | 
 36 | function test_reduce() {
 37 |     var sum = [1, 2, 3, 4, 5].reduce(0, (|accumulator, item, index|) {
 38 |         return accumulator + item
 39 |     })
 40 |     unittest.Assert.that(sum).is_equal_to(15, 'Sum must be 15')
 41 | }
 42 | 
 43 | function test_subscript_operation() {
 44 |     var subscript = List(3)
 45 |     subscript[2] = 0
 46 |     subscript[2] += 1
 47 |     unittest.Assert.that(subscript[2]).is_equal_to(1, 'subscript should be 1')
 48 | }
 49 | 
 50 | function test_sort_numbers() {
 51 |     var to_sort = [
 52 |         35, 13, 10, 41, 64, 36, 12, 51,
 53 |         3, 42, 56, 34, 55, 19,  9, 31,
 54 |         24,  8,  6, 21, 40, 54, 17, 61,
 55 |         58, 47, 18, 11,  4, 26, 48, 14,
 56 |         53, 30, 57, 52, 45, 20, 29, 46,
 57 |         63, 27, 59, 49, 43, 16,  2,  1,
 58 |         23, 39, 38,  7,  5, 37, 28, 44,
 59 |         33, 62, 32, 22, 15, 60, 50, 25,
 60 |     ]
 61 | 
 62 |     to_sort.sort()
 63 | 
 64 |     for(var i = 0; i < 64; i += 1) {
 65 |         unittest.Assert.that(to_sort[i]).is_equal_to(i+1)
 66 |     }
 67 | }
 68 | 
 69 | function test_sort_strings() {
 70 |     var to_sort_str = [
 71 |         '35', '13', '10', '41', '64', '36', '12', '51',
 72 |         '03', '42', '56', '34', '55', '19', '09', '31',
 73 |         '24', '08', '06', '21', '40', '54', '17', '61',
 74 |         '58', '47', '18', '11', '04', '26', '48', '14',
 75 |         '53', '30', '57', '52', '45', '20', '29', '46',
 76 |         '63', '27', '59', '49', '43', '16', '02', '01',
 77 |         '23', '39', '38', '07', '05', '37', '28', '44',
 78 |         '33', '62', '32', '22', '15', '60', '50', '25',
 79 |     ]
 80 |     to_sort_str.sort()
 81 | 
 82 |     for(var i = 0; i < 64; i += 1) {
 83 |         unittest.Assert.that(Number.parse(to_sort_str[i])).is_equal_to(i+1)
 84 |     }
 85 | }
 86 | 
 87 | enum Index {
 88 |     First,
 89 |     Second,
 90 |     Third
 91 | }
 92 | 
 93 | function test_using_enum_to_index() {
 94 |     var list = List(Index.count())
 95 | 
 96 |     foreach (var i in Index) {
 97 |         list[i] = i.to_string()
 98 |     }
 99 | 
100 |     foreach (var i in Index) {
101 |         unittest.Assert.that(list[i]).is_equal_to(i.to_string())
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/test_scripts/main_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | if (__MAIN__ == __FILE__) {
 4 |     function test_main() {
 5 |         unittest.Assert.pass()
 6 |     }
 7 | }
 8 | else if (__MAIN__.ends_with?('unittest.cmt')) {
 9 |     function test_main_under_test() {
10 |         unittest.Assert.pass()
11 |     }
12 | }
13 | else {
14 |     function test_main() {
15 |         unittest.Assert.fail()
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/test_scripts/native_field_accessor.cmt:
--------------------------------------------------------------------------------
1 | import 'unittest' as unittest
2 | 
3 | function test_native_property_accessor() {
4 |     var ex = Exception("This is a native property")
5 |     unittest.Assert.that(ex.message()).is_equal_to("This is a native property")
6 |     unittest.Assert.that(ex._message).is_equal_to("This is a native property")
7 | }
8 | 


--------------------------------------------------------------------------------
/test_scripts/numbers_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_basic_math_operators() {
 4 |     unittest.Assert.that(1 + 1).is_equal_to(2)
 5 |     unittest.Assert.that(4 / 2).is_equal_to(2)
 6 |     unittest.Assert.that(1 * 2).is_equal_to(2)
 7 |     unittest.Assert.that(4 - 2).is_equal_to(2)
 8 |     unittest.Assert.that(6 % 4).is_equal_to(2)
 9 | }
10 | 
11 | function test_parsing_with_underscores() {
12 |     unittest.Assert.that(2_000_000).is_equal_to(2000000)
13 | }
14 | 
15 | function test_comparison_operators() {
16 |     unittest.Assert.that(3 < 4).is_true()
17 |     unittest.Assert.that(3 <= 3).is_true()
18 |     unittest.Assert.that(4 > 3).is_true()
19 |     unittest.Assert.that(4 >= 3).is_true()
20 |     unittest.Assert.that(0 == 0).is_true()
21 | }
22 | 
23 | function test_number_parse() {
24 |     unittest.Assert.that(Number.parse("3")).is_of_type(Number, 'parsed number should be a number')
25 |     unittest.Assert.that(Number.parse("three")).is_nil("String that can't parse into a number, should be nil")
26 | }
27 | 
28 | function test_parsed_number_acts_like_a_number() {
29 |     var num = Number.parse('6')
30 |     unittest.Assert.that(num < 8).is_true()
31 | }
32 | 
33 | function test_hexadecimal_numbers() {
34 |     unittest.Assert.that(0xff).is_equal_to(255)
35 | }
36 | 
37 | function test_binary_operators() {
38 |     unittest.Assert.that(3 & 2).is_equal_to(2)
39 |     unittest.Assert.that(3 ^ 1).is_equal_to(2)
40 |     unittest.Assert.that(2 | 1).is_equal_to(3)
41 |     unittest.Assert.that(2 << 1).is_equal_to(4)
42 |     unittest.Assert.that(2 >> 1).is_equal_to(1)
43 | }
44 | 
45 | function test_complicated_math_functions() {
46 |     unittest.Assert.that(2.power(2)).is_equal_to(4)
47 |     unittest.Assert.that(4.square_root()).is_equal_to(2)
48 | }
49 | 
50 | function test_even?() {
51 |     unittest.Assert.that(4.even?()).is_true()
52 |     unittest.Assert.that(3.even?()).is_false()
53 | }
54 | 
55 | function test_min() {
56 |     unittest.Assert.that(Number.min(Number.random(), 0)).is_equal_to(0)
57 | }
58 | 
59 | function test_max() {
60 |     unittest.Assert.that(Number.max(Number.random(), 1)).is_equal_to(1)
61 | }
62 | 
63 | @unittest.test_case(5, 0, 10, 5)
64 | @unittest.test_case(-5, 0, 10, 0)
65 | @unittest.test_case(15, 0, 10, 10)
66 | @unittest.test_case(0, 0, 10, 0)
67 | @unittest.test_case(10, 0, 10, 10)
68 | function test_clamp(value, min, max, expected) {
69 |     var result = Number.clamp(value, min, max)
70 |     unittest.Assert.that(result).is_equal_to(expected)
71 | }
72 | 
73 | function test_absolute_value() {
74 |     unittest.Assert.that((-42).absolute_value()).is_equal_to(42)
75 | }
76 | 


--------------------------------------------------------------------------------
/test_scripts/object_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_object_not_nil?() {
 4 |     var obj = Object()
 5 | 
 6 |     unittest.Assert.that(obj).is_not_nil()
 7 | }
 8 | 
 9 | function test_nil?() {
10 |     unittest.Assert.that(nil).is_nil()
11 | }
12 | 
13 | function test_type_equals() {
14 |     unittest.Assert.that(Object).is_equal_to(Object)
15 | }
16 | 
17 | function test_class_name() {
18 |     var obj = Object()
19 | 
20 |     unittest.Assert.that(obj.class_name()).is_equal_to('Object instance')
21 | }
22 | 
23 | function test_methods() {
24 |     var obj = Object()
25 | 
26 |     var result = obj.methods()
27 | 
28 |     unittest.Assert.that(result).is_of_type(List)
29 |     unittest.Assert.that(result).is_not_empty()
30 | }
31 | 
32 | function test_fields() {
33 |     var obj = Object()
34 | 
35 |     var result = obj.fields()
36 | 
37 |     unittest.Assert.that(result).is_of_type(List)
38 |     unittest.Assert.that(result).is_empty()
39 | }
40 | 


--------------------------------------------------------------------------------
/test_scripts/process_test.cmt:
--------------------------------------------------------------------------------
 1 | import { test, Assert } from 'unittest'
 2 | 
 3 | # @test()
 4 | function test_process_can_run_returning_status_code() {
 5 |     var result = Process.run('ls')
 6 | 
 7 |     Assert.that(result.status_code).is_equal_to(0)
 8 | }
 9 | 
10 | # @test()
11 | function test_process_output_is_a_string() {
12 |     var result = Process.run('ls')
13 | 
14 |     Assert.that(result.output).is_of_type(String)
15 | }
16 | 
17 | # @test()
18 | function test_process_sets_the_command_used() {
19 |     var result = Process.run('ls')
20 | 
21 |     Assert.that(result.command).is_equal_to('ls')
22 | }
23 | 
24 | # @test()
25 | function test_process_shows_failure_in_status_code() {
26 |     var result = Process.run('unknown')
27 | 
28 |     Assert.that(result.status_code).is_not_equal_to(0)
29 | }
30 | 


--------------------------------------------------------------------------------
/test_scripts/rest_params_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function some_function(one, two, many, *lots) {
 4 |     unittest.Assert.that(one).is_equal_to('one')
 5 |     unittest.Assert.that(two).is_equal_to('two')
 6 |     unittest.Assert.that(many).is_equal_to('three')
 7 |     unittest.Assert.that(lots).is_of_type(List)
 8 |     unittest.Assert.that(lots[0]).is_equal_to('four')
 9 | }
10 | 
11 | function test_rest_params_with_more_than_expected() {
12 |     some_function('one', 'two', 'three', 'four', 'five')
13 | }
14 | 
15 | function test_rest_params_with_exactly_expected_count() {
16 |     some_function('one', 'two', 'three', 'four')
17 | }


--------------------------------------------------------------------------------
/test_scripts/set_test.cmt:
--------------------------------------------------------------------------------
  1 | import 'unittest' as unittest
  2 | 
  3 | function test_set_creation_strings() {
  4 |     var set = Set()
  5 |     set.add('a')
  6 |     set.add('a')
  7 |     set.add('a')
  8 | 
  9 |     unittest.Assert.that(set).has_count(1)
 10 | }
 11 | 
 12 | function test_set_creation_numbers() {
 13 |     var set = Set()
 14 |     set.add(1)
 15 |     set.add(1)
 16 |     set.add(1)
 17 | 
 18 |     unittest.Assert.that(set).has_count(1)
 19 | }
 20 | 
 21 | function test_set_contains() {
 22 |     var set = Set()
 23 |     set.add('a')
 24 |     set.add('b')
 25 |     set.add('c')
 26 | 
 27 |     unittest.Assert.that(set).contains('a')
 28 | }
 29 | 
 30 | function test_set_empty_when_empty() {
 31 |     var set = Set()
 32 | 
 33 |     unittest.Assert.that(set).is_empty()
 34 | }
 35 | 
 36 | function test_set_empty_when_not_empty() {
 37 |     var set = Set()
 38 |     set.add('a')
 39 | 
 40 |     unittest.Assert.that(set).is_not_empty()
 41 | }
 42 | 
 43 | function test_set_union() {
 44 |     var lhs = Set()
 45 |     var rhs = Set()
 46 | 
 47 |     lhs.add('a')
 48 |     lhs.add('b')
 49 |     lhs.add('c')
 50 | 
 51 |     rhs.add('c')
 52 |     rhs.add('d')
 53 |     rhs.add('e')
 54 | 
 55 |     # act
 56 |     var result = lhs.union(rhs)
 57 | 
 58 |     # assert
 59 |     unittest.Assert.that(result).has_count(5)
 60 |     unittest.Assert.that(result).contains('a')
 61 |     unittest.Assert.that(result).contains('b')
 62 |     unittest.Assert.that(result).contains('c')
 63 |     unittest.Assert.that(result).contains('d')
 64 |     unittest.Assert.that(result).contains('e')
 65 | }
 66 | 
 67 | function test_set_intersect() {
 68 |     var lhs = Set()
 69 |     var rhs = Set()
 70 | 
 71 |     lhs.add('a')
 72 |     lhs.add('b')
 73 |     lhs.add('c')
 74 | 
 75 |     rhs.add('c')
 76 |     rhs.add('d')
 77 |     rhs.add('e')
 78 | 
 79 |     # act
 80 |     var result = lhs.intersect(rhs)
 81 | 
 82 |     # assert
 83 |     unittest.Assert.that(result).has_count(1)
 84 |     unittest.Assert.that(result).does_not_contain('a')
 85 |     unittest.Assert.that(result).contains('c')
 86 | }
 87 | 
 88 | function test_set_difference() {
 89 |     var lhs = Set()
 90 |     var rhs = Set()
 91 | 
 92 |     lhs.add('a')
 93 |     lhs.add('b')
 94 |     lhs.add('c')
 95 | 
 96 |     rhs.add('c')
 97 | 
 98 |     # act
 99 |     var result = lhs.difference(rhs)
100 | 
101 |     # assert
102 |     unittest.Assert.that(result).has_count(2)
103 |     unittest.Assert.that(result).contains('a')
104 |     unittest.Assert.that(result).contains('b')
105 | }


--------------------------------------------------------------------------------
/test_scripts/socket_threads.cmt:
--------------------------------------------------------------------------------
 1 | var condition = ConditionVariable()
 2 | 
 3 | function client(arg)
 4 | {
 5 |     var client = Socket(SOCKET_TYPE.TCP, ADDRESS_FAMILY.IPv6)
 6 |     condition.signal_one()
 7 |     client.connect("::1", 8008)
 8 |     var contents = client.read()
 9 |     print(contents)
10 |     client.write("This is from the client")
11 |     client.close()
12 |     sleep(0.5)
13 | }
14 | 
15 | # disabled because libc complains about "stack thrashing" or some such BS.
16 | # It's probably right, and there's probably an horrific bug somewhere :s
17 | function x_test_socket_server() {
18 |     var server = Socket(SOCKET_TYPE.TCP, ADDRESS_FAMILY.IPv6)
19 |     server.bind("::1", 8008)
20 |     server.listen(1)
21 | 
22 |     var client_thread = Thread()
23 |     client_thread.start(client, nil)
24 | 
25 |     condition.wait()
26 |     var client_conn = server.accept()
27 |     client_conn.write("This is a string sent from the server")
28 |     print(client_conn.read())
29 |     client_conn.close()
30 | 
31 |     server.close()
32 |     client_thread.join()
33 | }
34 | 


--------------------------------------------------------------------------------
/test_scripts/splat_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function splatted(arg1, arg2, arg3) {
 4 |     unittest.Assert.that(arg1).is_equal_to('arg1')
 5 |     unittest.Assert.that(arg2).is_equal_to('arg2')
 6 |     unittest.Assert.that(arg3).is_equal_to('arg3')
 7 | }
 8 | 
 9 | function test_splat_args() {
10 |     var list = ['arg1', 'arg2', 'arg3']
11 |     splatted(*list)
12 | }
13 | 


--------------------------------------------------------------------------------
/test_scripts/string_builder_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | 
 4 | function test_string_builder_append() {
 5 |     var builder = StringBuilder()
 6 | 
 7 |     builder.append("a")
 8 |     builder.append("b")
 9 |     builder.append("c")
10 |     builder.append("ä")
11 |     builder.append("ē")
12 |     builder.append("íñ")
13 | 
14 |     unittest.Assert.that(builder.to_string()).is_equal_to("abcäēíñ")
15 | }


--------------------------------------------------------------------------------
/test_scripts/string_test.cmt:
--------------------------------------------------------------------------------
  1 | import 'unittest' as unittest
  2 | 
  3 | function test_ascii_length() {
  4 |     var normal_string = 'This is a string'
  5 |     unittest.Assert.that(normal_string.length()).is_equal_to(16)
  6 | }
  7 | 
  8 | var utf8_string = "This is ä ütf-8 string Encyclöpædiä"
  9 | function test_unicode_length() {
 10 |     unittest.Assert.that(utf8_string.length()).is_equal_to(35)
 11 | }
 12 | 
 13 | function test_to_upper_with_unicode() {
 14 |     var utf8_upper = utf8_string.to_upper()
 15 |     unittest.Assert.that(utf8_upper).is_equal_to("THIS IS Ä ÜTF-8 STRING ENCYCLÖPÆDIÄ")
 16 | }
 17 | 
 18 | function test_to_lower_with_unicode() {
 19 |     var utf8_lower = "THIS IS Ä ÜTF-8 STRING ENCYCLÖPÆDIÄ".to_lower()
 20 |     unittest.Assert.that(utf8_lower).is_equal_to("this is ä ütf-8 string encyclöpædiä")
 21 | }
 22 | 
 23 | function test_inline_concatenation() {
 24 |     unittest.Assert.that("this is" + " a string").is_equal_to('this is a string')
 25 | }
 26 | 
 27 | function test_multiple_concatenation() {
 28 |     var concat = 'this'
 29 |     concat += ' is '
 30 |     concat += 'a string'
 31 |     unittest.Assert.that(concat).is_equal_to('this is a string')
 32 | }
 33 | 
 34 | function test_trim() {
 35 |     unittest.Assert.that("   'left trimmed'".left_trim()).is_equal_to("'left trimmed'")
 36 |     unittest.Assert.that("'right trimmed'   ".right_trim()).is_equal_to("'right trimmed'")
 37 |     unittest.Assert.that("   'trimmed'   ".trim()).is_equal_to("'trimmed'")
 38 |     unittest.Assert.that("   'trimmed'\n".trim()).is_equal_to("'trimmed'")
 39 | }
 40 | 
 41 | function test_ends_with?() {
 42 |     unittest.Assert.that("this is a string...".ends_with?('ing...')).is_true()
 43 |     unittest.Assert.that("this is a string...".ends_with?('not this')).is_false()
 44 | }
 45 | 
 46 | function test_starts_with?() {
 47 |     unittest.Assert.that("this is a string...".starts_with?('this')).is_true()
 48 |     unittest.Assert.that("this is a string...".starts_with?('not this')).is_false()
 49 | }
 50 | 
 51 | function test_split() {
 52 |     var split = "this;is;a;string;;that;should;be;split".split(';')
 53 |     unittest.Assert.that(split[2]).is_equal_to('a')
 54 |     unittest.Assert.that(split.length()).is_equal_to(8)
 55 | }
 56 | 
 57 | function test_iteration() {
 58 |     var i = 0
 59 |     foreach(var char in utf8_string) {
 60 |         unittest.Assert.that(char).is_equal_to(utf8_string[i])
 61 |         i += 1
 62 |     }
 63 |     unittest.Assert.that(i).is_equal_to(utf8_string.length())
 64 | }
 65 | 
 66 | function test_escape() {
 67 |     var multiline = "This has an
 68 | escaped newline in it"
 69 |     var escaped = "This has an\nescaped newline in it"
 70 |     unittest.Assert.that(escaped).is_equal_to(multiline)
 71 | }
 72 | 
 73 | function test_replace() {
 74 |     var replaced = "this;is;a;string;;that;should;be;replaced".replace(';', ' ')
 75 |     unittest.Assert.that(replaced).is_equal_to("this is a string  that should be replaced")
 76 | }
 77 | 
 78 | function test_index() {
 79 |     var ooooo = utf8_string[10]
 80 |     unittest.Assert.that(ooooo).is_equal_to("ü")
 81 | }
 82 | 
 83 | function test_out_of_bounds() {
 84 |     unittest.Assert.that((||) {
 85 |         utf8_string[42]
 86 |     }).throws()
 87 | }
 88 | 
 89 | function test_substring() {
 90 |     var super_string = 'abc0123456789cba'
 91 |     var sub = super_string.substring(3, 10)
 92 |     unittest.Assert.that(sub).is_equal_to('0123456789')
 93 | }
 94 | 
 95 | @unittest.test_case('a', 97)
 96 | @unittest.test_case('A', 65)
 97 | function test_ascii_value(char, value) {
 98 |     var val = char.value()
 99 |     unittest.Assert.that(val).is_equal_to(value)
100 | }
101 | 
102 | function test_format() {
103 |     var formatted = String.format("Hello: {0}{1}", 12345, 6789)
104 |     unittest.Assert.that(formatted).is_equal_to('Hello: 123456789', 'formatted string did not match')
105 | }
106 | 
107 | function test_format_with_escape_sequence() {
108 |     var formatted = String.format("Hello: {{0}}{0}", 12345)
109 |     unittest.Assert.that(formatted).is_equal_to('Hello: {0}12345', 'formatted string did not match')
110 | }
111 | 
112 | function test_format_with_unicode() {
113 |     var formatted = String.format('Strīng mit unic{0}de', 'ö')
114 |     unittest.Assert.that(formatted).is_equal_to('Strīng mit unicöde', 'Unicode formatted string did not match')
115 | }
116 | 
117 | function test_contains_non_string() {
118 |     var str = 'This is a string'
119 | 
120 |     unittest.Assert.that(str).does_not_contain(4)
121 | }


--------------------------------------------------------------------------------
/test_scripts/ternary_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_positive_ternary() {
 4 |     var a = true ? 'pass' : 'fail'
 5 |     unittest.Assert.that(a).is_equal_to('pass')
 6 | }
 7 | 
 8 | function test_negative_ternary() {
 9 |     var b = false ? 'fail' : 'pass'
10 |     unittest.Assert.that(b).is_equal_to('pass')
11 | }


--------------------------------------------------------------------------------
/test_scripts/throw_exception.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | class NestedException : Exception {}
 4 | 
 5 | function nested_exception_handler_order() {
 6 |     try {
 7 |         try {
 8 |             throw Exception()
 9 |         } catch (NestedException as nested) {
10 |             unittest.Assert.fail(nested.message)
11 |         }
12 |     } catch (Exception as ex) {
13 |         throw NestedException("Should not be caught")
14 |     }
15 | }
16 | 
17 | 
18 | function test_throwing_exceptions() {
19 |     unittest.Assert.that((||) {
20 |         throw Exception()
21 |     }).throws()
22 | }
23 | 
24 | function test_nested_exception_handlers() {
25 |     unittest.Assert.that(nested_exception_handler_order).throws()
26 | }


--------------------------------------------------------------------------------
/test_scripts/variables.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_variables() {
 4 |     var number = 3
 5 | 
 6 |     number += 2
 7 |     unittest.Assert.that(number).is_equal_to(5)
 8 | 
 9 |     number -= 1
10 |     unittest.Assert.that(number).is_equal_to(4)
11 | 
12 |     number /= 2
13 |     unittest.Assert.that(number).is_equal_to(2)
14 | 
15 |     number *= 3
16 |     unittest.Assert.that(number).is_equal_to(6)
17 | 
18 |     number %= 4
19 |     unittest.Assert.that(number).is_equal_to(2)
20 | }
21 | 


--------------------------------------------------------------------------------
/test_scripts/while_loop_test.cmt:
--------------------------------------------------------------------------------
 1 | import 'unittest' as unittest
 2 | 
 3 | function test_while_loop() {
 4 |     var i = 0
 5 |     while (i < 10)
 6 |     {
 7 |         i += 1
 8 |     }
 9 |     unittest.Assert.that(i).is_equal_to(10)
10 | }
11 | 


--------------------------------------------------------------------------------
/vmlib/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.10)
 2 | project (clox)
 3 | enable_language(C)
 4 | enable_language(CXX)
 5 | enable_testing()
 6 | 
 7 | if (WIN32)
 8 | add_compile_definitions(WIN32=1)
 9 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
10 | else()
11 | set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -ggdb3 -Wall -Wextra -Werror")
12 | endif (WIN32)
13 | set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS}")
14 | 
15 | set(MEMORYCHECK_COMMAND_OPTIONS "--track-origins=yes --leak-check=full --errors-for-leak-kinds=all --error-exitcode=1 --log-fd=2")
16 | 
17 | add_subdirectory(lexer)
18 | add_subdirectory(compiler)
19 | 
20 | set(VM_SOURCE
21 | chunk.c
22 | chunk.h
23 | common.h
24 | import.cpp
25 | import.h
26 | mem.c
27 | mem.h
28 | native.c
29 | native.h
30 | objects.c
31 | objects.h
32 | table.c
33 | table.h
34 | value.c
35 | value.h
36 | vm_globals.c
37 | vm.c
38 | vm.h
39 | )
40 | 
41 | add_library(vmlib STATIC ${VM_SOURCE})
42 | target_include_directories(vmlib PRIVATE
43 |     ${CMAKE_CURRENT_SOURCE_DIR}
44 |     ${CMAKE_CURRENT_SOURCE_DIR}/../comet
45 | )
46 | 
47 | set_property(TARGET vmlib PROPERTY CXX_STANDARD 20)
48 | 
49 | target_link_libraries(vmlib stdlib compiler lexer Threads::Threads)
50 | target_include_directories(vmlib PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
51 | 


--------------------------------------------------------------------------------
/vmlib/chunk.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | #include <stdio.h>
 3 | 
 4 | #include "chunk.h"
 5 | #include "mem.h"
 6 | #include "value.h"
 7 | #include "vm.h"
 8 | 
 9 | void initChunk(Chunk *chunk, const char *filename)
10 | {
11 |     chunk->count = 0;
12 |     chunk->capacity = 0;
13 |     chunk->code = NULL;
14 |     chunk->lines = NULL;
15 |     chunk->execution_counts = NULL;
16 |     if (filename == NULL)
17 |     {
18 |         chunk->filename = NULL;
19 |     }
20 |     else
21 |     {
22 |         size_t filenameLen = strlen(filename) + 1;
23 |         chunk->filename = ALLOCATE(char, filenameLen);
24 |         strncpy(chunk->filename, filename, filenameLen);
25 |     }
26 |     initValueArray(&chunk->constants);
27 | }
28 | 
29 | void recordInstructionExecuted(Chunk *chunk, size_t instruction)
30 | {
31 |     chunk->execution_counts[(uint16_t)instruction]++;
32 | }
33 | 
34 | void writeChunk(Chunk *chunk, uint8_t byte, int line)
35 | {
36 |     if (chunk->capacity < chunk->count + 1)
37 |     {
38 |         int oldCapacity = chunk->capacity;
39 |         chunk->capacity = GROW_CAPACITY(oldCapacity);
40 |         chunk->code = GROW_ARRAY(chunk->code, uint8_t, oldCapacity, chunk->capacity);
41 |         chunk->lines = GROW_ARRAY(chunk->lines, int, oldCapacity, chunk->capacity);
42 |         chunk->execution_counts = GROW_ARRAY(chunk->execution_counts, uint16_t, oldCapacity, chunk->capacity);
43 |     }
44 | 
45 |     chunk->code[chunk->count] = byte;
46 |     chunk->lines[chunk->count] = line;
47 |     chunk->execution_counts[chunk->count] = 0;
48 |     chunk->count++;
49 | }
50 | 
51 | void freeChunk(Chunk *chunk)
52 | {
53 |     FREE_ARRAY(uint8_t, chunk->code, chunk->capacity);
54 |     FREE_ARRAY(int, chunk->lines, chunk->capacity);
55 |     FREE_ARRAY(uint16_t, chunk->execution_counts, chunk->capacity);
56 |     if (chunk->filename != NULL)
57 |     {
58 |         FREE_ARRAY(char, chunk->filename, strlen(chunk->filename) + 1);
59 |     }
60 |     freeValueArray(&chunk->constants);
61 |     initChunk(chunk, NULL);
62 | }
63 | 
64 | void print_constants(Chunk *chunk)
65 | {
66 |     for (int i = 0; i < chunk->constants.count; i++)
67 |     {
68 |         printf("%d: ", i);
69 |         printObject(chunk->constants.values[i]);
70 |         printf("\n");
71 |     }
72 | }


--------------------------------------------------------------------------------
/vmlib/chunk.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_chunk_h
 2 | #define clox_chunk_h
 3 | 
 4 | #include "common.h"
 5 | #include "value.h"
 6 | 
 7 | typedef enum
 8 | {
 9 |     OP_CONSTANT,
10 |     OP_NIL,
11 |     OP_TRUE,
12 |     OP_FALSE,
13 |     OP_POP,
14 |     OP_GET_LOCAL,
15 |     OP_SET_LOCAL,
16 |     OP_GET_GLOBAL,
17 |     OP_DEFINE_GLOBAL,
18 |     OP_SET_GLOBAL,
19 |     OP_GET_UPVALUE,
20 |     OP_SET_UPVALUE,
21 |     OP_GET_PROPERTY,
22 |     OP_SET_PROPERTY,
23 |     OP_GET_SUPER,
24 |     OP_EQUAL,
25 |     OP_GREATER,
26 |     OP_GREATER_EQUAL,
27 |     OP_LESS,
28 |     OP_LESS_EQUAL,
29 |     OP_ADD,
30 |     OP_SUBTRACT,
31 |     OP_MULTIPLY,
32 |     OP_DIVIDE,
33 |     OP_MODULO,
34 |     OP_NOT,
35 |     OP_NEGATE,
36 |     OP_JUMP,
37 |     OP_JUMP_IF_FALSE,
38 |     OP_LOOP,
39 |     OP_CALL,
40 |     OP_INVOKE,
41 |     OP_SUPER,
42 |     OP_CLOSURE,
43 |     OP_CLOSE_UPVALUE,
44 |     OP_RETURN,
45 |     OP_CLASS,
46 |     OP_INHERIT,
47 |     OP_METHOD,
48 |     OP_STATIC_METHOD,
49 |     OP_INDEX,
50 |     OP_INDEX_ASSIGN,
51 |     OP_DEFINE_OPERATOR,
52 |     OP_THROW,
53 |     OP_RETHROW,
54 |     OP_DUP_TOP,
55 |     OP_DUP_TWO,
56 |     OP_IS,
57 |     OP_PUSH_EXCEPTION_HANDLER,
58 |     OP_POP_EXCEPTION_HANDLER,
59 |     OP_PROPAGATE_EXCEPTION,
60 |     OP_IMPORT,
61 |     OP_IMPORT_PARAMS,
62 |     OP_BITWISE_OR,
63 |     OP_BITWISE_AND,
64 |     OP_BITWISE_XOR,
65 |     OP_BITSHIFT_LEFT,
66 |     OP_BITSHIFT_RIGHT,
67 |     OP_SPLAT,
68 | } OpCode;
69 | 
70 | typedef struct
71 | {
72 |     int count;
73 |     int capacity;
74 |     ValueArray constants;
75 |     int *lines;
76 |     uint16_t *execution_counts;
77 |     uint8_t *code;
78 |     char *filename;
79 | } Chunk;
80 | 
81 | void initChunk(Chunk *chunk, const char *filename);
82 | 
83 | void writeChunk(Chunk *chunk, uint8_t byte, int line);
84 | 
85 | void freeChunk(Chunk *chunk);
86 | 
87 | void print_constants(Chunk *chunk);
88 | 
89 | void recordInstructionExecuted(Chunk *chunk, size_t instruction);
90 | 
91 | #endif
92 | 


--------------------------------------------------------------------------------
/vmlib/common.h:
--------------------------------------------------------------------------------
 1 | #ifndef comet_common_h
 2 | #define comet_common_h
 3 | 
 4 | #include <stdbool.h> 
 5 | #include <stddef.h>  
 6 | #include <stdint.h>  
 7 | 
 8 | #define DEBUG_PRINT_CODE (0)
 9 | #define DEBUG_TRACE_EXECUTION (0)
10 | #define DEBUG_STRESS_GC (0)
11 | #define DEBUG_LOG_GC (0)
12 | #define DEBUG_LOG_GC_MINIMAL (0)
13 | #define DEBUG_LOG_GC_OBJ_FREES (0)
14 | #define MAX_VAR_COUNT (UINT8_MAX + 1)
15 | #define MAX_HANDLER_FRAMES (UINT8_MAX)
16 | #define DEBUG_ASSERT_ENABLED (1)
17 | #define MAX_ARGS (UINT8_MAX)
18 | 
19 | #define REF_COUNT_MEM_MANAGEMENT (0)
20 | 
21 | #ifndef UNUSED
22 | # if defined(WIN32) || defined(_WIN32)
23 | #  include <Windows.h>
24 | #  define UNUSED(x) UNREFERENCED_PARAMETER(x)
25 | # else
26 | #  define UNUSED(x) x __attribute__ ((unused))
27 | # endif
28 | #endif
29 | 
30 | typedef struct {
31 |     char *path;
32 |     char *source;
33 | } SourceFile;
34 | 
35 | 
36 | #if DEBUG_ASSERT_ENABLED
37 | #include <assert.h>
38 | # define DEBUG_ASSERT(x) assert(x)
39 | #else
40 | # define DEBUG_ASSERT(x)
41 | #endif
42 | 
43 | #endif 
44 | 


--------------------------------------------------------------------------------
/vmlib/compiler/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(src/sources.cmake)
 2 | add_library(compiler STATIC "${COMPILER_SOURCES}")
 3 | 
 4 | target_include_directories(
 5 |     compiler PUBLIC
 6 |     ${CMAKE_CURRENT_SOURCE_DIR}/inc
 7 |     PRIVATE
 8 |     ${CMAKE_CURRENT_SOURCE_DIR}/src
 9 |     ${CMAKE_CURRENT_SOURCE_DIR}/../
10 |     ${CMAKE_CURRENT_SOURCE_DIR}/../../comet/
11 | )
12 | target_link_libraries(compiler lexer)
13 | 
14 | add_subdirectory(test)


--------------------------------------------------------------------------------
/vmlib/compiler/inc/compiler.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_compiler_h
 2 | #define clox_compiler_h
 3 | 
 4 | #include "objects.h"
 5 | #include "vm.h"
 6 | 
 7 | #define NEW_HASH_PARAM_VALUE ((uint16_t) 0x8000)
 8 | #define NEW_LIST_PARAM_VALUE ((uint16_t) 0x4000)
 9 | 
10 | Value compile(const SourceFile* source, VM *thread);
11 | SourceFile *readSourceFile(const char *path);
12 | void freeSourceFile(SourceFile *source);
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/vmlib/compiler/inc/debug.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_debug_h
 2 | #define clox_debug_h
 3 | 
 4 | #include "chunk.h"
 5 | 
 6 | void disassembleChunk(Chunk *chunk, const char *name);
 7 | int disassembleInstruction(Chunk *chunk, int offset);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/compiler_defs.h:
--------------------------------------------------------------------------------
  1 | #ifndef _COMPILER_DEFS_H_
  2 | #define _COMPILER_DEFS_H_
  3 | 
  4 | #include "scanner.h"
  5 | #include "object_defs.h"
  6 | #include "compiler.h"
  7 | 
  8 | typedef struct ClassCompiler
  9 | {
 10 |     struct ClassCompiler *enclosing;
 11 | 
 12 |     Token name;
 13 | } ClassCompiler;
 14 | 
 15 | typedef struct LoopCompiler
 16 | {
 17 |     struct LoopCompiler *enclosing;
 18 |     int startAddress;
 19 |     int exitAddress;
 20 |     int loopScopeDepth;
 21 |     int breakJump;
 22 | } LoopCompiler;
 23 | 
 24 | typedef enum
 25 | {
 26 |     PREC_NONE,
 27 |     PREC_ASSIGNMENT,  // =
 28 |     PREC_TERNARY,     // ? :
 29 |     PREC_OR,          // ||
 30 |     PREC_AND,         // &&
 31 |     PREC_EQUALITY,    // == !=
 32 |     PREC_BITSHIFT,    // << >>
 33 |     PREC_XOR,         // ^
 34 |     PREC_BITWISE_OR,  // |
 35 |     PREC_BITWISE_AND, // &
 36 |     PREC_COMPARISON,  // < > <= >=
 37 |     PREC_TERM,        // + -
 38 |     PREC_FACTOR,      // * / %
 39 |     PREC_UNARY,       // ! - ~
 40 |     PREC_IS,  // is
 41 |     PREC_CALL,        // . () []
 42 |     PREC_PRIMARY,
 43 | } Precedence;
 44 | 
 45 | typedef struct
 46 | {
 47 |     Token name;
 48 |     int depth;
 49 |     bool isCaptured;
 50 | } Local;
 51 | 
 52 | typedef struct
 53 | {
 54 |     uint8_t index;
 55 |     bool isLocal;
 56 | } Upvalue;
 57 | 
 58 | typedef enum
 59 | {
 60 |     TYPE_FUNCTION,
 61 |     TYPE_INITIALIZER,
 62 |     TYPE_METHOD,
 63 |     TYPE_SCRIPT,
 64 |     TYPE_LAMBDA,
 65 | } FunctionType;
 66 | 
 67 | typedef struct Compiler
 68 | {
 69 |     struct Compiler *enclosing;
 70 |     ObjFunction *function;
 71 |     FunctionType type;
 72 |     Local locals[MAX_VAR_COUNT];
 73 |     int localCount;
 74 |     Upvalue upvalues[MAX_VAR_COUNT];
 75 |     int scopeDepth;
 76 | } Compiler;
 77 | 
 78 | typedef struct
 79 | {
 80 |     Token current;
 81 |     Token previous;
 82 |     bool hadError;
 83 |     bool panicMode;
 84 |     const char *filename;
 85 |     Scanner *scanner;
 86 |     ClassCompiler *currentClass;
 87 |     LoopCompiler *currentLoop;
 88 |     VALUE currentModule;
 89 |     Compiler *currentFunction;
 90 |     VM *compilation_thread;
 91 | } Parser;
 92 | 
 93 | typedef void (*ParseFn)(Parser *parser, bool canAssign);
 94 | 
 95 | typedef struct
 96 | {
 97 |     ParseFn prefix;
 98 |     ParseFn infix;
 99 |     Precedence precedence;
100 | } ParseRule;
101 | 
102 | Token syntheticToken(const char *text);
103 | Chunk *currentChunk(Compiler *compiler);
104 | int getCurrentOffset(Compiler *compiler);
105 | void setCodeOffset(Compiler *compiler, int offset, uint8_t value);
106 | 
107 | void synchronize(Parser *parser);
108 | 
109 | void initCompiler(Compiler *compiler, FunctionType type, Parser *parser);
110 | ObjFunction *endCompiler(Parser *parser);
111 | 
112 | void patchJump(Parser *parser, int offset);
113 | 
114 | void beginScope(Parser *parser);
115 | void endScope(Parser *parser);
116 | 
117 | void advance(Parser *parser);
118 | void consume(Parser *parser, TokenType_t type, const char *message);
119 | bool check(Parser *parser, TokenType_t type);
120 | bool match(Parser *parser, TokenType_t type);
121 | void error(Parser *parser, const char *message);
122 | void errorAtCurrent(Parser *parser, const char *message);
123 | 
124 | #endif
125 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/constants.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | 
 3 | #include "mem.h"
 4 | #include "constants.h"
 5 | #include "comet.h"
 6 | 
 7 | 
 8 | Value parseNumber(Parser *parser)
 9 | {
10 |     char *number_chars = ALLOCATE(char, parser->previous.length + 1);
11 |     int offset = 0;
12 |     for (int i = 0; i < parser->previous.length; i++)
13 |     {
14 |         if (parser->previous.start[i] != '_')
15 |             number_chars[offset++] = parser->previous.start[i];
16 |     }
17 |     number_chars[offset] = '\0';
18 | 
19 |     double value = strtod(number_chars, NULL);
20 |     FREE_ARRAY(char, number_chars, parser->previous.length + 1);
21 |     return create_number(parser->compilation_thread, value);
22 | }
23 | 
24 | Value parseString(Parser *parser)
25 | {
26 |     int index = 0;
27 |     char *string_chars = ALLOCATE(char, parser->previous.length - 1);
28 |     for (int i = 1; i < parser->previous.length - 1; i++)
29 |     {
30 |         if (parser->previous.start[i] == '\\')
31 |         {
32 |             if (parser->previous.start[i+1] == 'n')
33 |             {
34 |                 string_chars[index++] = '\n';
35 |                 i++;
36 |             }
37 |             else if (parser->previous.start[i+1] == '\\')
38 |             {
39 |                 string_chars[index++] = '\\';
40 |                 i++;
41 |             }
42 |             else if (parser->previous.start[i+1] == 't')
43 |             {
44 |                 string_chars[index++] = '\t';
45 |                 i++;
46 |             }
47 |             else if (parser->previous.start[i+1] == 'r')
48 |             {
49 |                 string_chars[index++] = '\r';
50 |                 i++;
51 |             }
52 |             else if (parser->previous.start[i+1] == '\'')
53 |             {
54 |                 string_chars[index++] = '\'';
55 |                 i++;
56 |             }
57 |             else if (parser->previous.start[i+1] == '"')
58 |             {
59 |                 string_chars[index++] = '"';
60 |                 i++;
61 |             }
62 |             else
63 |             {
64 |                 string_chars[index++] = parser->previous.start[i];
65 |             }
66 |         }
67 |         else
68 |         {
69 |             string_chars[index++] = parser->previous.start[i];
70 |         }
71 |     }
72 |     string_chars[index] = '\0';
73 |     return takeString(parser->compilation_thread, string_chars, index);
74 | }


--------------------------------------------------------------------------------
/vmlib/compiler/src/constants.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMPILER_CONSTANTS_H_
 2 | #define _COMPILER_CONSTANTS_H_
 3 | #include "compiler_defs.h"
 4 | 
 5 | Value parseNumber(Parser *parser);
 6 | 
 7 | Value parseString(Parser *parser);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/declarations.h:
--------------------------------------------------------------------------------
 1 | #ifndef _DECLARATIONS_H_
 2 | #define _DECLARATIONS_H_
 3 | #include "compiler_defs.h"
 4 | 
 5 | void method(Parser *parser, uint8_t attributeCount);
 6 | void operator_(Parser *parser);
 7 | void classDeclaration(Parser *parser, uint8_t attributeCount);
 8 | void functionDeclaration(Parser *parser, uint8_t attributeCount);
 9 | void enumDeclaration(Parser *parser);
10 | void varDeclaration(Parser *parser);
11 | void function(Parser *parser, FunctionType type, uint8_t attributeCount);
12 | 
13 | void declaration(Parser *parser);
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/emitter.c:
--------------------------------------------------------------------------------
 1 | #include "emitter.h"
 2 | #include "variables.h"
 3 | 
 4 | void emitByte(Parser *parser, uint8_t byte)
 5 | {
 6 |     writeChunk(currentChunk(parser->currentFunction), byte, parser->previous.line);
 7 | }
 8 | 
 9 | void emitBytes(Parser *parser, uint8_t byte1, uint8_t byte2)
10 | {
11 |     emitByte(parser, byte1);
12 |     emitByte(parser, byte2);
13 | }
14 | 
15 | void emitLoop(Parser *parser)
16 | {
17 |     emitByte(parser, OP_LOOP);
18 | 
19 |     int offset = getCurrentOffset(parser->currentFunction) - parser->currentLoop->startAddress + 2;
20 |     if (offset > UINT16_MAX)
21 |         error(parser, "Loop body too large.");
22 | 
23 |     emitByte(parser, (offset >> 8) & 0xff);
24 |     emitByte(parser, offset & 0xff);
25 | }
26 | 
27 | int emitJump(Parser *parser, uint8_t instruction)
28 | {
29 |     emitByte(parser, instruction);
30 |     emitByte(parser, 0xff);
31 |     emitByte(parser, 0xff);
32 |     return getCurrentOffset(parser->currentFunction) - 2;
33 | }
34 | 
35 | void emitReturn(Parser *parser)
36 | {
37 |     // An initializer automatically returns "self".
38 |     if (parser->currentFunction->type == TYPE_INITIALIZER)
39 |     {
40 |         emitBytes(parser, OP_GET_LOCAL, 0);
41 |     }
42 |     else
43 |     {
44 |         emitByte(parser, OP_NIL);
45 |     }
46 |     emitByte(parser, OP_RETURN);
47 | }
48 | 
49 | void emitConstant(Parser *parser, Value value)
50 | {
51 |     emitBytes(parser, OP_CONSTANT, makeConstant(parser, value));
52 | }
53 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/emitter.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EMITTER_H_
 2 | #define _EMITTER_H_
 3 | 
 4 | #include "compiler_defs.h"
 5 | 
 6 | void emitByte(Parser *parser, uint8_t byte);
 7 | void emitBytes(Parser *parser, uint8_t byte1, uint8_t byte2);
 8 | void emitLoop(Parser *parser);
 9 | int emitJump(Parser *parser, uint8_t instruction);
10 | void emitReturn(Parser *parser);
11 | void emitConstant(Parser *parser, Value value);
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/expressions.h:
--------------------------------------------------------------------------------
1 | #ifndef _EXPRESSIONS_H_
2 | #define _EXPRESSIONS_H_
3 | #include "compiler_defs.h"
4 | 
5 | void parsePrecedence(Parser *parser, Precedence precedence);
6 | void expression(Parser *parser);
7 | ParseRule *getRule(TokenType_t type);
8 | 
9 | #endif


--------------------------------------------------------------------------------
/vmlib/compiler/src/source_files.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | 
 5 | #include "comet.h"
 6 | 
 7 | SourceFile *readSourceFile(const char *path)
 8 | {
 9 |     SourceFile *sourcefile = (SourceFile *) malloc(sizeof(SourceFile));
10 |     FILE *file = fopen(path, "rb");
11 |     if (file == NULL)
12 |     {
13 |         fprintf(stderr, "Could not open file \"%s\"\n", path);
14 |         exit(74);
15 |     }
16 | 
17 |     fseek(file, 0L, SEEK_END);
18 |     size_t fileSize = ftell(file);
19 |     rewind(file);
20 | 
21 |     sourcefile->source = (char *)malloc(fileSize + 1);
22 |     if (sourcefile->source == NULL)
23 |     {
24 |         fprintf(stderr, "Could not allocate memory to read \"%s\"\n", path);
25 |         exit(74);
26 |     }
27 | 
28 |     size_t bytesRead = fread(sourcefile->source, sizeof(char), fileSize, file);
29 |     sourcefile->source[bytesRead] = '\0';
30 | 
31 |     fclose(file);
32 |     size_t pathLen = strlen(path);
33 |     sourcefile->path = (char *) malloc(pathLen + 1);
34 |     memcpy(sourcefile->path, path, pathLen);
35 |     sourcefile->path[pathLen] = '\0';
36 |     return sourcefile;
37 | }
38 | 
39 | void freeSourceFile(SourceFile *source)
40 | {
41 |     free(source->path);
42 |     free(source->source);
43 |     free(source);
44 | }


--------------------------------------------------------------------------------
/vmlib/compiler/src/sources.cmake:
--------------------------------------------------------------------------------
 1 | set(COMPILER_SOURCES
 2 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/compiler.c
 3 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/constants.c
 4 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/debug.c
 5 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/declarations.c
 6 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/emitter.c
 7 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/expressions.c
 8 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/source_files.c
 9 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/statements.c
10 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/variables.c
11 | )


--------------------------------------------------------------------------------
/vmlib/compiler/src/statements.h:
--------------------------------------------------------------------------------
 1 | #ifndef _STATEMENTS_H_
 2 | #define _STATEMENTS_H_
 3 | 
 4 | #include "compiler_defs.h"
 5 | 
 6 | #define UNINITALISED_ADDRESS -1
 7 | 
 8 | void block(Parser *parser);
 9 | 
10 | void expressionStatement(Parser *parser);
11 | void forStatement(Parser *parser);
12 | void foreachStatement(Parser *parser);
13 | void ifStatement(Parser *parser);
14 | void returnStatement(Parser *parser);
15 | void whileStatement(Parser *parser);
16 | void tryStatement(Parser *parser);
17 | void throwStatement(Parser *parser);
18 | void importStatement(Parser *parser);
19 | void nextStatement(Parser *parser);
20 | 
21 | void statement(Parser *parser);
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/vmlib/compiler/src/variables.h:
--------------------------------------------------------------------------------
 1 | #ifndef _VARIABLES_H_
 2 | #define _VARIABLES_H_
 3 | 
 4 | #include "compiler_defs.h"
 5 | 
 6 | uint8_t makeConstant(Parser *parser, Value value);
 7 | uint8_t identifierConstant(Parser *parser, Token *name);
 8 | bool identifiersEqual(Token *a, Token *b);
 9 | void markInitialized(Parser *parser);
10 | void defineVariable(Parser *parser, uint8_t global);
11 | uint8_t parseVariable(Parser *parser, const char *errorMessage);
12 | void declareVariable(Parser *parser);
13 | void namedVariable(Parser *parser, Token name, bool canAssign);
14 | void variable(Parser *parser, bool canAssign);
15 | int resolveUpvalue(Compiler *compiler, Parser *parser, Token *name);
16 | int resolveLocal(Parser *parser, Compiler *compiler, Token *name);
17 | int addLocal(Parser *parser, Token name);
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/vmlib/compiler/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | enable_testing()
 2 | 
 3 | set(TEST_SOURCES
 4 |     main.c
 5 |     test_pratt_parser.c
 6 | )
 7 | 
 8 | add_executable(compiler_tests "${TEST_SOURCES}")
 9 | target_link_libraries(compiler_tests PRIVATE compiler vmlib)
10 | target_include_directories(compiler_tests PRIVATE
11 |     "${CMAKE_CURRENT_SOURCE_DIR}/../src"
12 |     "${CMAKE_CURRENT_SOURCE_DIR}/../"
13 | )
14 | 
15 | add_test(compiler_tests compiler_tests)
16 | 


--------------------------------------------------------------------------------
/vmlib/compiler/test/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | 
 3 | #include "tests.h"
 4 | 
 5 | int main(void)
 6 | {
 7 |     test_rulesAreComplete();
 8 | 
 9 |     return EXIT_SUCCESS;
10 | }
11 | 


--------------------------------------------------------------------------------
/vmlib/compiler/test/test_pratt_parser.c:
--------------------------------------------------------------------------------
 1 | #include "expressions.h"
 2 | 
 3 | extern ParseRule rules[NUM_TOKENS];
 4 | 
 5 | void test_rulesAreComplete(void)
 6 | {
 7 |     for (int i = 0; i < NUM_TOKENS; i++)
 8 |     {
 9 |         DEBUG_ASSERT(rules[i].precedence >= PREC_NONE &&
10 |                      rules[i].precedence < PREC_PRIMARY);
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/vmlib/compiler/test/tests.h:
--------------------------------------------------------------------------------
1 | #ifndef _COMPILER_TESTS_H_
2 | #define _COMPILER_TESTS_H_
3 | 
4 | void test_rulesAreComplete(void);
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/vmlib/import.cpp:
--------------------------------------------------------------------------------
  1 | #ifndef _GNU_SOURCE
  2 | # define _GNU_SOURCE
  3 | #endif
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <string.h>
  7 | #ifndef WIN32
  8 | #include <libgen.h>
  9 | #endif
 10 | 
 11 | #include <string>
 12 | #include <string_view>
 13 | #include <filesystem>
 14 | 
 15 | #include <iostream>
 16 | 
 17 | extern "C" {
 18 | 
 19 | #include "import.h"
 20 | #include "comet.h"
 21 | #include "common.h"
 22 | #include "compiler.h"
 23 | 
 24 | }
 25 | 
 26 | using namespace std;
 27 | 
 28 | static constexpr string_view file_extension(".cmt");
 29 | static const char *COMET_LIB_ENV_VARNAME = "COMET_LIB_DIR";
 30 | 
 31 | static filesystem::path resolve_exact_module(VM *vm, filesystem::path input)
 32 | {
 33 |     if (filesystem::is_directory(input))
 34 |     {
 35 |         filesystem::path candidate = input / "_init.cmt";
 36 |         if (filesystem::exists(candidate))
 37 |             return candidate;
 38 | 
 39 |         throw_exception_native(vm, "ImportException", "Cannot import a directory that is not a module");
 40 |         return filesystem::path();
 41 |     }
 42 |     return input;
 43 | }
 44 | 
 45 | static filesystem::path resolve_import_path(VM *vm, const char *relative_to_filename, const char *to_import)
 46 | {
 47 |     std::string to_import_filename = string(to_import);
 48 |     if (!to_import_filename.ends_with(file_extension))
 49 |     {
 50 |         to_import_filename += string(file_extension);
 51 |     }
 52 |     filesystem::path import_path = filesystem::path(to_import_filename);
 53 |     filesystem::path current_dir;
 54 |     if (relative_to_filename == NULL)
 55 |     {
 56 |         current_dir = filesystem::current_path();
 57 |     }
 58 |     else
 59 |     {
 60 |         current_dir = filesystem::path(relative_to_filename).parent_path();
 61 |     }
 62 |     filesystem::path candidate = current_dir / import_path;
 63 |     if (filesystem::exists(candidate))
 64 |     {
 65 |         return resolve_exact_module(vm, candidate);
 66 |     }
 67 | 
 68 |     char *dir = std::getenv(COMET_LIB_ENV_VARNAME);
 69 |     if (dir != NULL)
 70 |     {
 71 |         candidate = filesystem::path(std::string(dir)) / import_path;
 72 |     }
 73 |     else
 74 |     {
 75 | #ifdef WIN32
 76 |         const char *lib_dir = "C:\\comet";
 77 | #else
 78 |         const char *lib_dir = "/usr/local/lib/comet";
 79 | #endif
 80 |         candidate = filesystem::path(std::string(lib_dir)) / import_path;
 81 |     }
 82 | 
 83 |     if (filesystem::exists(candidate))
 84 |     {
 85 |         return resolve_exact_module(vm, candidate);
 86 |     }
 87 | 
 88 |     candidate = filesystem::current_path() / import_path;
 89 |     if (filesystem::exists(candidate))
 90 |     {
 91 |         return resolve_exact_module(vm, candidate);
 92 |     }
 93 | 
 94 |     return filesystem::path();
 95 | }
 96 | 
 97 | extern "C" {
 98 | 
 99 | Value import_from_file(VM *vm, const char *relative_to_filename, Value to_import)
100 | {
101 |     const char *to_import_path = string_get_cstr(to_import);
102 |     filesystem::path candidate = resolve_import_path(vm, relative_to_filename, to_import_path);
103 |     if (!filesystem::exists(candidate))
104 |     {
105 |         throw_exception_native(vm, "ImportException", "Could not import '%s'", to_import_path);
106 |         return NIL_VAL;
107 |     }
108 |     string absolute_path = filesystem::canonical(candidate).string();
109 | 
110 |     const char *full_path = absolute_path.c_str();
111 |     Value full_path_val = copyString(vm, full_path, strlen(full_path));
112 |     push(vm, full_path_val);
113 | 
114 |     Value module;
115 |     if (!findModule(peek(vm, 0), &module))
116 |     {
117 |         SourceFile *source = readSourceFile(full_path);
118 |         module = compile(source, vm);
119 |         if (module == NIL_VAL)
120 |         {
121 |             runtimeError(vm, "Compilation failed for %s\n", full_path);
122 |         }
123 |         else
124 |         {
125 |             push(vm, module);
126 |             addModule(module, full_path_val);
127 |             pop(vm);
128 |         }
129 |         freeSourceFile(source);
130 |     }
131 |     pop(vm);
132 | 
133 |     return module;
134 | }
135 | 
136 | 
137 | }


--------------------------------------------------------------------------------
/vmlib/import.h:
--------------------------------------------------------------------------------
 1 | #ifndef _COMET_IMPORT_H_
 2 | #define _COMET_IMPORT_H_
 3 | 
 4 | #include "vm.h"
 5 | 
 6 | #ifdef __cplusplus
 7 | extern "C" {
 8 | #endif
 9 | 
10 |     Value import_from_file(VM *vm, const char *relative_to_filename, Value to_import);
11 | 
12 | #ifdef __cplusplus
13 | }
14 | #endif
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/vmlib/lexer/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | include(src/sources.cmake)
 2 | 
 3 | add_library(lexer STATIC "${LEXER_SOURCES}")
 4 | target_include_directories(
 5 |     lexer PUBLIC
 6 |     ${CMAKE_CURRENT_SOURCE_DIR}/inc
 7 |     PRIVATE
 8 |     ${CMAKE_CURRENT_SOURCE_DIR}/src
 9 |     ${CMAKE_CURRENT_SOURCE_DIR}/../
10 | )
11 | 
12 | if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "Release")
13 |     add_subdirectory(test)
14 | endif()
15 | 


--------------------------------------------------------------------------------
/vmlib/lexer/inc/scanner.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_scanner_h
 2 | #define clox_scanner_h
 3 | 
 4 | #include "common.h"
 5 | 
 6 | typedef enum {
 7 |   // Single-character tokens.
 8 |   TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN,
 9 |   TOKEN_LEFT_BRACE, TOKEN_RIGHT_BRACE,
10 |   TOKEN_LEFT_SQ_BRACKET, TOKEN_RIGHT_SQ_BRACKET,
11 |   TOKEN_COMMA, TOKEN_DOT, TOKEN_MINUS, TOKEN_PLUS,
12 |   TOKEN_SEMI_COLON, TOKEN_SLASH, TOKEN_STAR,
13 |   TOKEN_COLON, TOKEN_EOL, TOKEN_VBAR, TOKEN_PERCENT,
14 |   TOKEN_QUESTION_MARK, TOKEN_AT_SYMBOL,
15 | 
16 |   // One or two character tokens.
17 |   TOKEN_BANG, TOKEN_BANG_EQUAL,
18 |   TOKEN_EQUAL, TOKEN_EQUAL_EQUAL,
19 |   TOKEN_GREATER, TOKEN_GREATER_EQUAL,
20 |   TOKEN_LESS, TOKEN_LESS_EQUAL,
21 |   TOKEN_PLUS_EQUAL, TOKEN_MINUS_EQUAL, TOKEN_STAR_EQUAL, TOKEN_SLASH_EQUAL, TOKEN_PERCENT_EQUAL,
22 |   TOKEN_LOGICAL_OR, TOKEN_LOGICAL_AND,
23 |   TOKEN_BITWISE_AND, TOKEN_BITWISE_XOR, TOKEN_BITWISE_NEGATE,
24 |   TOKEN_BITSHIFT_LEFT, TOKEN_BITSHIFT_RIGHT,
25 |   TOKEN_LAMBDA_ARGS_OPEN, TOKEN_LAMBDA_ARGS_CLOSE,
26 | 
27 |   // Literals.
28 |   TOKEN_IDENTIFIER, TOKEN_STRING, TOKEN_NUMBER, TOKEN_FILE_NAME,
29 | 
30 |   // Keywords.
31 |   TOKEN_AS, TOKEN_BREAK, TOKEN_CLASS, TOKEN_ELSE, TOKEN_ENUM, TOKEN_FALSE,
32 |   TOKEN_FOR, TOKEN_FOREACH, TOKEN_FROM, TOKEN_FUN, TOKEN_IF, TOKEN_IMPORT, TOKEN_IN,
33 |   TOKEN_IS, TOKEN_NEXT, TOKEN_NIL, TOKEN_OPERATOR, TOKEN_RETHROW,
34 |   TOKEN_RETURN, TOKEN_SELF, TOKEN_SUPER, TOKEN_TRUE, TOKEN_VAR, TOKEN_WHILE,
35 |   TOKEN_TRY, TOKEN_CATCH, TOKEN_THROW, TOKEN_FINAL, TOKEN_FINALLY,
36 | 
37 |   // Access Modifiers
38 |   TOKEN_PRIVATE, TOKEN_PROTECTED, TOKEN_PUBLIC, TOKEN_STATIC,
39 | 
40 |   TOKEN_ERROR,
41 |   TOKEN_EOF,
42 | 
43 |   NUM_TOKENS,
44 | } TokenType_t;
45 | 
46 | typedef struct {
47 |     TokenType_t type;
48 |     const char *start;
49 |     int length;
50 |     int line;
51 | } Token;
52 | 
53 | typedef struct
54 | {
55 |     const char *start;
56 |     const char *current;
57 |     int line;
58 | } Scanner;
59 | 
60 | void initScanner(Scanner *scanner, const SourceFile *source);
61 | Token scanToken(Scanner *scanner);
62 | 
63 | #endif
64 | 


--------------------------------------------------------------------------------
/vmlib/lexer/src/sources.cmake:
--------------------------------------------------------------------------------
1 | set(LEXER_SOURCES
2 |     ${CMAKE_CURRENT_SOURCE_DIR}/src/scanner.c
3 | )


--------------------------------------------------------------------------------
/vmlib/lexer/test/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | enable_testing()
 2 | 
 3 | set(TEST_SOURCES
 4 |     main.c
 5 |     test_scanner.c
 6 | )
 7 | 
 8 | add_executable(lexer_tests "${TEST_SOURCES}")
 9 | target_link_libraries(lexer_tests PRIVATE lexer vmlib)
10 | target_include_directories(lexer_tests PRIVATE
11 |     "${CMAKE_CURRENT_SOURCE_DIR}/../src"
12 |     "${CMAKE_CURRENT_SOURCE_DIR}/../"
13 | )
14 | 
15 | add_test(lexer_tests lexer_tests)
16 | 


--------------------------------------------------------------------------------
/vmlib/lexer/test/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | 
 3 | #include "common.h"
 4 | #include "tests.h"
 5 | 
 6 | int main(int UNUSED(argc), char UNUSED(**argv))
 7 | {
 8 |     test_scanner_tokens();
 9 | 
10 |     return EXIT_SUCCESS;
11 | }


--------------------------------------------------------------------------------
/vmlib/lexer/test/test_scanner.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "tests.h"
  3 | #include "scanner.h"
  4 | 
  5 | char *token_strings[NUM_TOKENS] = 
  6 | {
  7 |     [TOKEN_LEFT_PAREN] = "(",
  8 |     [TOKEN_RIGHT_PAREN] = ")",
  9 |     [TOKEN_LEFT_BRACE] = "{",
 10 |     [TOKEN_RIGHT_BRACE] = "}",
 11 |     [TOKEN_LEFT_SQ_BRACKET] = "[",
 12 |     [TOKEN_RIGHT_SQ_BRACKET] = "]",
 13 |     [TOKEN_COMMA] = ",",
 14 |     [TOKEN_DOT] = ".",
 15 |     [TOKEN_MINUS] = "-",
 16 |     [TOKEN_PLUS] = "+",
 17 |     [TOKEN_SEMI_COLON] = ";",
 18 |     [TOKEN_SLASH] = "/",
 19 |     [TOKEN_STAR] = "*",
 20 |     [TOKEN_COLON] = ":",
 21 |     [TOKEN_EOL] = "\n",
 22 |     [TOKEN_VBAR] = "|",
 23 |     [TOKEN_PERCENT] = "%",
 24 |     [TOKEN_QUESTION_MARK] = "?",
 25 |     [TOKEN_AT_SYMBOL] = "@",
 26 |     [TOKEN_BANG] = "!",
 27 |     [TOKEN_BANG_EQUAL] = "!=",
 28 |     [TOKEN_EQUAL] = "=",
 29 |     [TOKEN_EQUAL_EQUAL] = "==",
 30 |     [TOKEN_GREATER] = ">",
 31 |     [TOKEN_GREATER_EQUAL] = ">=",
 32 |     [TOKEN_LESS] = "<",
 33 |     [TOKEN_LESS_EQUAL] = "<=",
 34 |     [TOKEN_PLUS_EQUAL] = "+=",
 35 |     [TOKEN_MINUS_EQUAL] = "-=",
 36 |     [TOKEN_STAR_EQUAL] = "*=",
 37 |     [TOKEN_SLASH_EQUAL] = "/=",
 38 |     [TOKEN_PERCENT_EQUAL] = "%=",
 39 |     [TOKEN_LOGICAL_OR] = "||",
 40 |     [TOKEN_LOGICAL_AND] = "&&",
 41 |     [TOKEN_BITWISE_AND] = "&",
 42 |     [TOKEN_BITWISE_XOR] = "^",
 43 |     [TOKEN_BITSHIFT_LEFT] = "<<",
 44 |     [TOKEN_BITSHIFT_RIGHT] = ">>",
 45 |     [TOKEN_BITWISE_NEGATE] = "~",
 46 |     [TOKEN_LAMBDA_ARGS_OPEN] = "(|",
 47 |     [TOKEN_LAMBDA_ARGS_CLOSE] = "|)",
 48 |     [TOKEN_IDENTIFIER] = "something",
 49 |     [TOKEN_STRING] = "'a string'",
 50 |     [TOKEN_NUMBER] = "123456",
 51 |     [TOKEN_FILE_NAME] = "__FILE__",
 52 |     [TOKEN_AS] = "as",
 53 |     [TOKEN_BREAK] = "break",
 54 |     [TOKEN_CLASS] = "class",
 55 |     [TOKEN_ELSE] = "else",
 56 |     [TOKEN_ENUM] = "enum",
 57 |     [TOKEN_FALSE] = "false",
 58 |     [TOKEN_FOR] = "for",
 59 |     [TOKEN_FOREACH] = "foreach",
 60 |     [TOKEN_FROM] = "from",
 61 |     [TOKEN_FUN] = "function",
 62 |     [TOKEN_IF] = "if",
 63 |     [TOKEN_IMPORT] = "import",
 64 |     [TOKEN_IN] = "in",
 65 |     [TOKEN_IS] = "is",
 66 |     [TOKEN_NEXT] = "next",
 67 |     [TOKEN_NIL] = "nil",
 68 |     [TOKEN_OPERATOR] = "operator",
 69 |     [TOKEN_RETHROW] = "rethrow",
 70 |     [TOKEN_RETURN] = "return",
 71 |     [TOKEN_SELF] = "self",
 72 |     [TOKEN_SUPER] = "super",
 73 |     [TOKEN_TRUE] = "true",
 74 |     [TOKEN_VAR] = "var",
 75 |     [TOKEN_WHILE] = "while",
 76 |     [TOKEN_TRY] = "try",
 77 |     [TOKEN_CATCH] = "catch",
 78 |     [TOKEN_THROW] = "throw",
 79 |     [TOKEN_FINALLY] = "finally",
 80 |     [TOKEN_FINAL] = "final",
 81 |     [TOKEN_PRIVATE] = "private",
 82 |     [TOKEN_PROTECTED] = "protected",
 83 |     [TOKEN_PUBLIC] = "public",
 84 |     [TOKEN_STATIC] = "static",
 85 | };
 86 | 
 87 | void test_scanner_tokens(void)
 88 | {
 89 |     Scanner scanner;
 90 |     SourceFile source;
 91 |     // We aren't able to scan for TOKEN_ERROR or TOKEN_EOF
 92 |     for (int i = 0; i < NUM_TOKENS - 2; i++)
 93 |     {
 94 |         source.path = "test_scanner_tokens";
 95 |         source.source = token_strings[i];
 96 |         initScanner(&scanner, &source);
 97 | 
 98 |         printf("Testing: '%s', expecting %d\n", token_strings[i], i);
 99 | 
100 |         Token result = scanToken(&scanner);
101 |         DEBUG_ASSERT(result.type == (TokenType_t) i);
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/vmlib/lexer/test/tests.h:
--------------------------------------------------------------------------------
1 | #ifndef _LEXER_TESTS_H_
2 | #define _LEXER_TESTS_H_
3 | 
4 | void test_scanner_tokens(void);
5 | 
6 | #endif
7 | 


--------------------------------------------------------------------------------
/vmlib/mem.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_memory_h
 2 | #define clox_memory_h
 3 | 
 4 | #include "objects.h"
 5 | #include "vm.h"
 6 | 
 7 | #ifdef __cplusplus
 8 | #define ALLOCATE(type, count) \
 9 |     (type *)reallocate(nullptr, 0, sizeof(type) * (count))
10 | #else
11 | #define ALLOCATE(type, count) \
12 |     (type *)reallocate(NULL, 0, sizeof(type) * (count))
13 | #endif
14 | 
15 | #define FREE(type, pointer) \
16 |     reallocate(pointer, sizeof(type), 0)
17 | 
18 | #define FREE_NATIVE_INSTANCE(pointer) \
19 |     reallocate(pointer, ((ObjNativeClass *)((ObjInstance *) pointer)->klass)->allocSize, 0)
20 | 
21 | #define GROW_CAPACITY(capacity) \
22 |     ((capacity) < 8 ? 8 : (capacity)*2)
23 | 
24 | #define GROW_ARRAY(previous, type, oldCount, newCount)        \
25 |     (type *)reallocate((previous), sizeof(type) * (oldCount), \
26 |                        sizeof(type) * (newCount))
27 | 
28 | #define FREE_ARRAY(type, pointer, oldCount) \
29 |     reallocate(pointer, sizeof(type) * oldCount, 0)
30 | 
31 | uint32_t get_current_thread_id(void);
32 | void register_thread(VM *vm);
33 | void deregister_thread(VM *vm);
34 | void *reallocate(void *previous, size_t oldSize, size_t newSize);
35 | Obj *allocateObject(VM *vm, size_t size, ObjType type);
36 | void markObject(Obj* object);
37 | void markValue(Value value);
38 | void freeObjects();
39 | void finalizeGarbageCollection(void);
40 | #endif
41 | 


--------------------------------------------------------------------------------
/vmlib/native.c:
--------------------------------------------------------------------------------
  1 | #include "native.h"
  2 | #include "vm.h"
  3 | #include "comet.h"
  4 | 
  5 | #include <string.h>
  6 | #include <stdio.h>
  7 | 
  8 | void defineNativeFunction(VM *vm, const char *name, NativeFn function)
  9 | {
 10 |     newNativeFunction(vm, function);
 11 |     push(vm, copyString(vm, name, (int)strlen(name)));
 12 |     addGlobal(peek(vm, 0), peek(vm, 1));
 13 |     pop(vm);
 14 |     pop(vm);
 15 | }
 16 | 
 17 | VALUE bootstrapNativeClass(VM *vm, const char *name, NativeConstructor constructor, NativeDestructor destructor, ClassType classType, size_t dataSize, bool final)
 18 | {
 19 |     return OBJ_VAL(newNativeClass(vm, name, constructor, destructor, NULL, classType, dataSize, final));
 20 | }
 21 | 
 22 | VALUE completeNativeClassDefinition(VM *vm, VALUE klass_, const char *super_name)
 23 | {
 24 |     ObjClass *klass = AS_CLASS(klass_);
 25 |     Value name_string = copyString(vm, klass->name, (int)strlen(klass->name));
 26 |     push(vm, name_string);
 27 |     if (string_compare_to_cstr(name_string, "Object") != 0)
 28 |     {
 29 |         Value parent;
 30 |         if (super_name == NULL)
 31 |         {
 32 |             super_name = "Object";
 33 |         }
 34 |         Value superClassName = copyString(vm, super_name, (int)strlen(super_name));
 35 |         push(vm, superClassName);
 36 |         if (!findGlobal(superClassName, &parent))
 37 |         {
 38 |             pop(vm);
 39 |             runtimeError(vm, "Could not inherit from unknown class '%s'", super_name);
 40 |             return NIL_VAL;
 41 |         }
 42 |         pop(vm);
 43 | 
 44 |         ObjClass *parent_class = AS_CLASS(parent);
 45 | 
 46 |         if (parent_class->final)
 47 |         {
 48 |             runtimeError(vm, "Cannot inherit from a final class");
 49 |             return NIL_VAL;
 50 |         }
 51 | 
 52 | 
 53 |         tableAddAll(&parent_class->methods, &klass->methods);
 54 |         tableAddAll(&parent_class->staticMethods, &klass->staticMethods);
 55 |         for (int i = 0; i < NUM_OPERATORS; i++)
 56 |         {
 57 |             klass->operators[i] = parent_class->operators[i];
 58 |         }
 59 |         klass->super_ = AS_CLASS(parent);
 60 |     }
 61 |     if (addGlobal(name_string, OBJ_VAL(klass)))
 62 |     {
 63 |         pop(vm);
 64 |         pop(vm);
 65 |         return OBJ_VAL(klass);
 66 |     }
 67 |     else
 68 |     {
 69 |         runtimeError(vm, "Redefining class %s", klass->name);
 70 |         return NIL_VAL;
 71 |     }
 72 | }
 73 | 
 74 | VALUE defineNativeClass(
 75 |     VM *vm,
 76 |     const char *name,
 77 |     NativeConstructor constructor,
 78 |     NativeDestructor destructor,
 79 |     MarkNativeObject marker,
 80 |     const char *super_name,
 81 |     ClassType classType,
 82 |     size_t dataSize,
 83 |     bool final)
 84 | {
 85 |     VALUE klass = OBJ_VAL(newNativeClass(vm, name, constructor, destructor, marker, classType, dataSize, final));
 86 |     return completeNativeClassDefinition(vm, klass, super_name);
 87 | }
 88 | 
 89 | void defineNativeMethod(VM *vm, VALUE klass, NativeMethod function, const char *name, uint8_t arity, bool isStatic)
 90 | {
 91 |     Value name_string = copyString(vm, name, strlen(name));
 92 |     push(vm, name_string);
 93 |     push(vm, klass);
 94 |     newNativeMethod(vm, function, arity, isStatic, name_string);
 95 |     defineMethod(vm, name_string, isStatic);
 96 |     pop(vm);
 97 |     pop(vm);
 98 | }
 99 | 
100 | void defineNativeOperator(VM *vm, VALUE klass, NativeMethod function, uint8_t arity, OPERATOR operator)
101 | {
102 |     const char *op_method_chars = getOperatorString(operator);
103 |     Value op_method_name = copyString(vm, op_method_chars, strlen(op_method_chars));
104 |     push(vm, op_method_name);
105 |     push(vm, klass);
106 |     newNativeMethod(vm, function, arity, false, op_method_name);
107 |     defineOperator(vm, operator);
108 |     pop(vm);
109 |     pop(vm);
110 | }
111 | 
112 | void setNativeProperty(VM *vm, VALUE self, const char *property_name, VALUE value)
113 | {
114 |     push(vm, self);
115 |     push(vm, value);
116 |     Value name_string = copyString(vm, property_name, strlen(property_name));
117 |     push(vm, name_string);
118 |     tableSet(&AS_INSTANCE(self)->fields, name_string, value);
119 |     pop(vm);
120 |     pop(vm);
121 |     pop(vm);
122 | }
123 | 
124 | VALUE getNativeProperty(VM *vm, VALUE self, const char *property_name)
125 | {
126 |     Value value;
127 |     Value name_string = copyString(vm, property_name, strlen(property_name));
128 |     if (tableGet(&AS_INSTANCE(self)->fields, name_string, &value))
129 |     {
130 |         return value;
131 |     }
132 |     return NIL_VAL;
133 | }
134 | 


--------------------------------------------------------------------------------
/vmlib/native.h:
--------------------------------------------------------------------------------
 1 | #ifndef _NATIVE_API_H_
 2 | #define _NATIVE_API_H_
 3 | 
 4 | #include "objects.h"
 5 | #include "vm.h"
 6 | 
 7 | void defineNativeFunction(VM *vm, const char *name, NativeFn function);
 8 | VALUE defineNativeClass(
 9 |     VM *vm,
10 |     const char *name,
11 |     NativeConstructor constructor,
12 |     NativeDestructor destructor,
13 |     MarkNativeObject marker,
14 |     const char *super_name,
15 |     ClassType classType,
16 |     size_t dataSize,
17 |     bool final);
18 | void defineNativeMethod(VM *vm, VALUE klass, NativeMethod function, const char *name, uint8_t arity, bool isStatic);
19 | void defineNativeOperator(VM *vm, VALUE klass, NativeMethod function, uint8_t arity, OPERATOR operator_);
20 | void setNativeProperty(VM *vm, VALUE self, const char *property_name, VALUE value);
21 | VALUE getNativeProperty(VM *vm, VALUE self, const char *property_name);
22 | 
23 | 
24 | VALUE bootstrapNativeClass(VM *vm, const char *name, NativeConstructor constructor, NativeDestructor destructor, ClassType classType, size_t dataSize, bool final);
25 | VALUE completeNativeClassDefinition(VM *vm, VALUE klass_, const char *super_name);
26 | #endif
27 | 


--------------------------------------------------------------------------------
/vmlib/objects.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_object_h
 2 | #define clox_object_h
 3 | 
 4 | #include "common.h"
 5 | #include "scanner.h"
 6 | #include "value.h"
 7 | #include "object_defs.h"
 8 | #include "vm.h"
 9 | #include "native.h"
10 | 
11 | ObjBoundMethod *newBoundMethod(VM *vm, Value receiver, ObjClosure *method);
12 | ObjClass *newClass(VM *vm, const char *name, ClassType classType, bool final);
13 | ObjNativeClass *newNativeClass(
14 |     VM *vm,
15 |     const char *name,
16 |     NativeConstructor constructor,
17 |     NativeDestructor destructor,
18 |     MarkNativeObject marker,
19 |     ClassType classType,
20 |     size_t dataSize,
21 |     bool final);
22 | ObjNativeMethod *newNativeMethod(VM *vm, NativeMethod function, uint8_t arity, bool isStatic, Value name);
23 | ObjClosure *newClosure(VM *vm, ObjFunction *function);
24 | ObjFunction *newFunction(VM *vm, const char *filename, Value module);
25 | Obj *newInstance(VM *vm, ObjClass *klass);
26 | ObjNative *newNativeFunction(VM *vm, NativeFn function);
27 | Value takeString(VM *vm, char *chars, int length);
28 | Value copyString(VM *vm, const char *chars, size_t length);
29 | ObjUpvalue *newUpvalue(VM *vm, Value *slot);
30 | void printObject(Value value);
31 | const char *objTypeName(ObjType type);
32 | const char *getOperatorString(OPERATOR operator_);
33 | const char* getClassNameFromInstance(VALUE instance);
34 | OPERATOR getOperatorFromToken(TokenType_t token);
35 | 
36 | static inline bool isObjType(Value value, ObjType type)
37 | {
38 |     return IS_OBJ(value) && AS_OBJ(value)->type == type;
39 | }
40 | 
41 | static inline bool isObjOfStdlibClassType(Value value, ClassType type)
42 | {
43 |     return (IS_INSTANCE(value) || IS_NATIVE_INSTANCE(value)) &&
44 |         AS_INSTANCE(value)->klass->classType == type;
45 | }
46 | 
47 | bool compare_objects(VM *vm, VALUE lhs, VALUE rhs);
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/vmlib/table.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_table_h
 2 | #define clox_table_h
 3 | 
 4 | #include "common.h"
 5 | #include "value.h"
 6 | 
 7 | typedef struct
 8 | {
 9 |     Value key;
10 |     Value value;
11 | } Entry;
12 | 
13 | typedef struct
14 | {
15 |     int count;
16 |     int capacity;
17 |     Entry *entries;
18 | } Table;
19 | 
20 | void initTable(Table *table);
21 | void freeTable(Table *table);
22 | bool tableGet(Table *table, Value key, Value *result);
23 | bool tableSet(Table *table, Value key, Value value);
24 | bool tableDelete(Table *table, Value key);
25 | void tableAddAll(Table *from, Table *to);
26 | Value tableFindString(Table *table, const char *chars, uint32_t hash);
27 | void tableRemoveWhite(Table *table);
28 | void markTable(Table *table);
29 | void tableGetKeys(Table *table, VM *vm, VALUE list);
30 | void tableGetValues(Table *table, VM* vm, Value list);
31 | void tablePrintKeys(Table *table);
32 | 
33 | #endif


--------------------------------------------------------------------------------
/vmlib/test/test_table.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cometlang/comet/e3a93ea6ad83b14bc0566dc09d9889773433f845/vmlib/test/test_table.c


--------------------------------------------------------------------------------
/vmlib/value.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | 
 4 | #include "objects.h"
 5 | #include "mem.h"
 6 | #include "value.h"
 7 | 
 8 | void initValueArray(ValueArray *array)
 9 | {
10 |     array->values = NULL;
11 |     array->capacity = 0;
12 |     array->count = 0;
13 | }
14 | 
15 | void writeValueArray(ValueArray *array, Value value)
16 | {
17 |     if (array->capacity < array->count + 1)
18 |     {
19 |         int oldCapacity = array->capacity;
20 |         array->capacity = GROW_CAPACITY(oldCapacity);
21 |         array->values = GROW_ARRAY(array->values, Value, oldCapacity, array->capacity);
22 |     }
23 | 
24 |     array->values[array->count] = value;
25 |     array->count++;
26 | }
27 | 
28 | void freeValueArray(ValueArray *array)
29 | {
30 |     FREE_ARRAY(Value, array->values, array->capacity);
31 |     initValueArray(array);
32 | }
33 | 
34 | bool valuesEqual(Value a, Value b)
35 | {
36 |     return a == b;
37 | }
38 | 


--------------------------------------------------------------------------------
/vmlib/value.h:
--------------------------------------------------------------------------------
 1 | #ifndef clox_value_h
 2 | #define clox_value_h
 3 | #include <string.h>
 4 | #include "common.h"
 5 | 
 6 | typedef struct sObj Obj;
 7 | 
 8 | // A mask that selects the sign bit.
 9 | #define SIGN_BIT ((uint64_t)1 << 63)
10 | 
11 | // The bits that must be set to indicate a quiet NaN.
12 | #define QNAN ((uint64_t)0x7ffc000000000000)
13 | 
14 | typedef uint64_t Value;
15 | 
16 | // The triple casting is necessary here to satisfy some compilers:
17 | // 1. (uintptr_t) Convert the pointer to a number of the right size.
18 | // 2. (uint64_t)  Pad it up to 64 bits in 32-bit builds.
19 | // 3. Or in the bits to make a tagged Nan.
20 | // 4. Cast to a typedef'd value.
21 | #define OBJ_VAL(obj) \
22 |     (Value)(SIGN_BIT | QNAN | (uint64_t)(uintptr_t)(obj))
23 | 
24 | #define VALUE Value
25 | 
26 | #define NIL_VAL (OBJ_VAL(&nil_instance))
27 | #define TRUE_VAL (OBJ_VAL(boolean_true))
28 | #define FALSE_VAL (OBJ_VAL(boolean_false))
29 | 
30 | #define NUMBER_VAL(num)  numToValue(num)
31 | #define AS_NUMBER(value) valueToNum(value)
32 | 
33 | #define IS_NIL(v)        ((v) == NIL_VAL)
34 | #define IS_OBJ(v)        (((v) & (QNAN | SIGN_BIT)) == (QNAN | SIGN_BIT))
35 | #define AS_OBJ(v)        ((Obj*)(uintptr_t)((v) & ~(SIGN_BIT | QNAN)))
36 | #define IS_NUMBER(value) (((value) & QNAN) != QNAN)
37 | 
38 | typedef struct _vm VM;
39 | 
40 | typedef struct
41 | {
42 |     int capacity;
43 |     int count;
44 |     Value *values;
45 | } ValueArray;
46 | 
47 | bool valuesEqual(Value a, Value b);
48 | void initValueArray(ValueArray *array);
49 | void writeValueArray(ValueArray *array, Value value);
50 | void freeValueArray(ValueArray *array);
51 | void printObject(Value value);
52 | 
53 | static inline Value numToValue(double num) {
54 |     Value value;
55 |     memcpy(&value, &num, sizeof(double));
56 |     return value;
57 | }
58 | 
59 | static inline double valueToNum(Value value) {
60 |     double num;
61 |     memcpy(&num, &value, sizeof(Value));
62 |     return num;
63 | }
64 | 
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/vmlib/vm.h:
--------------------------------------------------------------------------------
  1 | #ifndef clox_vm_h
  2 | #define clox_vm_h
  3 | 
  4 | #include "chunk.h"
  5 | #include "object_defs.h"
  6 | #include "table.h"
  7 | #include "value.h"
  8 | #include "common.h"
  9 | 
 10 | #define FRAMES_MAX 64
 11 | #define STACK_MAX (FRAMES_MAX * MAX_VAR_COUNT)
 12 | 
 13 | typedef struct {
 14 |     uint16_t handlerAddress;
 15 |     uint16_t finallyAddress;
 16 |     Value klass;
 17 | } ExceptionHandler;
 18 | 
 19 | typedef struct
 20 | {
 21 |     ObjClosure *closure;
 22 |     uint8_t *ip;
 23 |     Value *slots;
 24 |     uint8_t handlerCount;
 25 |     ExceptionHandler handlerStack[MAX_HANDLER_FRAMES];
 26 |     int16_t bonusSplatArgCount;
 27 | } CallFrame;
 28 | 
 29 | struct _vm
 30 | {
 31 |     CallFrame frames[FRAMES_MAX];
 32 |     int frameCount;
 33 |     Value stack[STACK_MAX];
 34 |     Value *stackTop;
 35 |     ObjUpvalue *openUpvalues;
 36 | };
 37 | 
 38 | typedef enum
 39 | {
 40 |     INTERPRET_OK,
 41 |     INTERPRET_COMPILE_ERROR,
 42 |     INTERPRET_RUNTIME_ERROR,
 43 | } InterpretResult;
 44 | 
 45 | typedef enum {
 46 |     STRING_INIT,
 47 |     STRING_HASH,
 48 |     STRING_TO_STRING,
 49 |     STRING_LAMBDA,
 50 |     STRING_EMPTY_Q,
 51 |     STRING_NUMBER,
 52 |     STRING_SCRIPT,
 53 |     STRING_FUNCTION,
 54 |     STRING_ADD,
 55 |     NUM_COMMON_STRINGS,
 56 | } COMMON_STRINGS;
 57 | 
 58 | extern Value common_strings[NUM_COMMON_STRINGS];
 59 | void initGlobals(void);
 60 | void freeGlobals(void);
 61 | 
 62 | void initVM(VM *vm);
 63 | void freeVM(VM *vm);
 64 | 
 65 | Value findInternedString(const char *chars, uint32_t hash);
 66 | 
 67 | bool internString(Value string);
 68 | void addModule(Value module, Value filename);
 69 | bool findModule(Value filename,  Value *module);
 70 | void getAllModules(VM *vm, Value list);
 71 | void markGlobals(void);
 72 | void removeWhiteStrings(void);
 73 | 
 74 | bool addGlobal(Value name, Value value);
 75 | bool findGlobal(Value name, Value *value);
 76 | bool findModuleVariable(Value module, Value name, Value *value);
 77 | bool addModuleVariable(Value module, Value name, Value value);
 78 | 
 79 | void call_function(VM *vm, VALUE receiver, VALUE method_name, int arg_count, VALUE *arguments);
 80 | 
 81 | InterpretResult interpret(VM *vm, Value main);
 82 | void runtimeError(VM *vm, const char *format, ...);
 83 | void defineMethod(VM *vm, Value name, bool isStatic);
 84 | void defineOperator(VM *vm, OPERATOR operator_);
 85 | 
 86 | void push(VM *vm, Value value);
 87 | void push_to(VM *vm, Value value, int distance);
 88 | Value pop(VM *vm);
 89 | Value peek(VM *vm, int distance);
 90 | Value popMany(VM *vm, int count);
 91 | void swapTop(VM *vm);
 92 | 
 93 | void throw_exception_native(VM *vm, const char *exception_type_name, const char *message_format, ...);
 94 | 
 95 | #if DEBUG_TRACE_EXECUTION
 96 | void toggle_stack_printing(void);
 97 | void print_stack(VM *vm);
 98 | void print_stack_trace(VM *vm);
 99 | #endif
100 | 
101 | #endif
102 | 


--------------------------------------------------------------------------------
/vmlib/vm_globals.c:
--------------------------------------------------------------------------------
 1 | #include "vm.h"
 2 | #include "mem.h"
 3 | 
 4 | static Table globals;
 5 | static Table strings;
 6 | static Table modules;
 7 | Value common_strings[NUM_COMMON_STRINGS];
 8 | 
 9 | void initGlobals(void)
10 | {
11 |     initTable(&globals);
12 |     initTable(&strings);
13 |     initTable(&modules);
14 | }
15 | 
16 | void freeGlobals(void)
17 | {
18 |     freeTable(&globals);
19 |     freeTable(&strings);
20 |     freeTable(&modules);
21 |     for (int i = 0; i < NUM_COMMON_STRINGS; i++)
22 |     {
23 |         common_strings[i] = NIL_VAL;
24 |     }
25 | }
26 | 
27 | void markGlobals(void)
28 | {
29 |     markTable(&globals);
30 |     markTable(&strings);
31 |     markTable(&modules);
32 |     for (int i = 0; i < NUM_COMMON_STRINGS; i++)
33 |     {
34 |         markValue(common_strings[i]);
35 |     }
36 |     markValue(NIL_VAL);
37 |     markValue(TRUE_VAL);
38 |     markValue(FALSE_VAL);
39 | }
40 | 
41 | void removeWhiteStrings(void)
42 | {
43 |     tableRemoveWhite(&strings);
44 | }
45 | 
46 | Value findInternedString(const char *chars, uint32_t hash)
47 | {
48 |     return tableFindString(&strings, chars, hash);
49 | }
50 | 
51 | bool internString(Value string)
52 | {
53 |     return tableSet(&strings, string, NIL_VAL);
54 | }
55 | 
56 | bool findGlobal(Value name, Value *value)
57 | {
58 |     return tableGet(&globals, name, value);
59 | }
60 | 
61 | bool addGlobal(Value name, Value value)
62 | {
63 |     return tableSet(&globals, name, value);
64 | }
65 | 
66 | bool findModuleVariable(Value module, Value name, Value *value)
67 | {
68 |     ObjInstance *instance = AS_INSTANCE(module);
69 |     return tableGet(&instance->fields, name, value);
70 | }
71 | 
72 | bool addModuleVariable(Value module, Value name, Value value)
73 | {
74 |     ObjInstance *instance = AS_INSTANCE(module);
75 |     return tableSet(&instance->fields, name, value);
76 | }
77 | 
78 | void addModule(Value module, Value filename)
79 | {
80 |     tableSet(&modules, filename, module);
81 | }
82 | 
83 | bool findModule(Value filename, Value *module)
84 | {
85 |     return tableGet(&modules, filename, module);
86 | }
87 | 
88 | void getAllModules(VM *vm, Value list)
89 | {
90 |     tableGetValues(&modules, vm, list);
91 | }
92 | 


--------------------------------------------------------------------------------