From 5a2e3dcec45de3cca9b5aa35895bda15f1bd3ca7 Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Sat, 13 Apr 2024 15:29:53 +0200 Subject: [PATCH] Init new repository --- .github/workflows/run_tests.yaml | 25 + .gitignore | 7 + LICENSE | 20 + README.md | 674 + build.bat | 11 + build_file.cpp | 311 + examples/add_dynamic_array_macro/build.cpp | 173 + examples/add_dynamic_array_macro/main.lc | 64 + examples/add_instrumentation/build.cpp | 62 + examples/add_instrumentation/main.lc | 13 + examples/add_printf_format_check/build.cpp | 56 + examples/add_printf_format_check/main.lc | 6 + examples/add_source_location_macro/build.cpp | 48 + examples/add_source_location_macro/main.lc | 16 + examples/create_raylib_window/build.cpp | 30 + examples/create_raylib_window/main.lc | 16 + examples/generate_type_info/build.cpp | 64 + examples/generate_type_info/generated.lc | 13 + examples/generate_type_info/main.lc | 19 + examples/hello_world/build.cpp | 29 + examples/hello_world/main.lc | 6 + examples/pathfinding_visualizer/array.lc | 147 + examples/pathfinding_visualizer/build.cpp | 42 + examples/pathfinding_visualizer/main.lc | 266 + examples/pathfinding_visualizer/map.lc | 286 + examples/pathfinding_visualizer/random.lc | 22 + examples/sandbox/arena.lc | 68 + examples/sandbox/arena_win32.lc | 28 + examples/sandbox/build.cpp | 121 + examples/sandbox/common.lc | 96 + examples/sandbox/dynamic_array.lc | 49 + examples/sandbox/main.lc | 93 + examples/text_editor/buffer.lc | 249 + examples/text_editor/buffer_iter.lc | 54 + examples/text_editor/build.cpp | 34 + examples/text_editor/main.lc | 362 + examples/text_editor/rect2p.lc | 79 + examples/text_editor/unicode.lc | 94 + examples/text_editor/visual_pos.lc | 76 + .../build.cpp | 105 + .../data.lc | 57 + lib_compiler.h | 11089 ++++++++++++++++ pkgs/libc/assert.lc | 13 + pkgs/libc/ctype.lc | 17 + pkgs/libc/errno.lc | 2 + pkgs/libc/math.lc | 122 + pkgs/libc/size_t.lc | 3 + pkgs/libc/stdarg.lc | 12 + pkgs/libc/stdio.lc | 61 + pkgs/libc/stdlib.lc | 48 + pkgs/libc/string.lc | 28 + pkgs/raylib/raylib-5.0_win64_msvc16/LICENSE | 16 + .../raylib-5.0_win64_msvc16/include/raylib.h | 1662 +++ .../raylib-5.0_win64_msvc16/include/raymath.h | 2190 +++ .../raylib-5.0_win64_msvc16/include/rlgl.h | 4859 +++++++ .../raylib-5.0_win64_msvc16/lib/raylib.dll | Bin 0 -> 1821184 bytes .../raylib-5.0_win64_msvc16/lib/raylib.lib | Bin 0 -> 5365858 bytes .../raylib-5.0_win64_msvc16/lib/raylibdll.lib | Bin 0 -> 169448 bytes pkgs/raylib/raylib.lc | 1012 ++ pkgs/raylib/raymath.lc | 122 + pkgs/raylib/rlgl.lc | 173 + pkgs/std_types/c_types.lc | 12 + pkgs/std_types/non_c_types.lc | 11 + pkgs/std_types/types.lc | 44 + pkgs/std_types/windows_types.lc | 9 + pkgs/std_types/x64_linux_types.lc | 8 + pkgs/std_types/x64_types.lc | 15 + pkgs/std_types/x86_types.lc | 22 + src/build_file/ast_verify.cpp | 125 + src/build_file/package_compiler.cpp | 166 + src/build_file/test_readme.cpp | 37 + src/build_file/testsuite.cpp | 463 + src/build_tool/cache.cpp | 127 + src/build_tool/easy_strings.cpp | 116 + src/build_tool/library.cpp | 55 + src/build_tool/main.cpp | 90 + src/build_tool/process.cpp | 153 + src/compiler/arena.c | 138 + src/compiler/ast.c | 167 + src/compiler/ast_copy.c | 283 + src/compiler/ast_walk.c | 316 + src/compiler/bigint.c | 1471 ++ src/compiler/common.c | 198 + src/compiler/extended_passes.c | 72 + src/compiler/genc.c | 677 + src/compiler/init.c | 259 + src/compiler/intern.c | 44 + src/compiler/lex.c | 535 + src/compiler/lib_compiler.c | 95 + src/compiler/lib_compiler.h | 1696 +++ src/compiler/packages.c | 363 + src/compiler/parse.c | 1079 ++ src/compiler/printer.c | 477 + src/compiler/resolve.c | 1496 +++ src/compiler/resolver.c | 192 + src/compiler/string.c | 422 + src/compiler/to_string.c | 277 + src/compiler/unicode.c | 158 + src/compiler/unix_arena.c | 30 + src/compiler/unix_filesystem.c | 89 + src/compiler/value.c | 328 + src/compiler/win32_arena.c | 44 + src/compiler/win32_filesystem.c | 118 + src/core/allocator.c | 115 + src/core/allocator.h | 44 + src/core/array.hpp | 270 + src/core/cmd.c | 186 + src/core/cmd.h | 37 + src/core/core.c | 23 + src/core/core.cpp | 1 + src/core/core.h | 25 + src/core/filesystem.c | 720 + src/core/filesystem.h | 73 + src/core/table.hpp | 204 + src/profiler/profiler.c | 62 + src/profiler/spall.h | 448 + src/standalone_libraries/arena.c | 366 + src/standalone_libraries/arena.h | 179 + src/standalone_libraries/clexer.c | 1549 +++ src/standalone_libraries/clexer.h | 302 + src/standalone_libraries/defer.hpp | 25 + src/standalone_libraries/hash.c | 53 + src/standalone_libraries/hash.h | 28 + src/standalone_libraries/io.c | 236 + src/standalone_libraries/io.h | 108 + src/standalone_libraries/linked_list.h | 119 + src/standalone_libraries/load_library.c | 26 + src/standalone_libraries/load_library.h | 12 + src/standalone_libraries/multimedia.c | 1740 +++ src/standalone_libraries/multimedia.h | 370 + src/standalone_libraries/preproc_env.h | 119 + src/standalone_libraries/regex.c | 558 + src/standalone_libraries/regex.h | 95 + src/standalone_libraries/stb_sprintf.c | 1669 +++ src/standalone_libraries/stb_sprintf.h | 262 + src/standalone_libraries/string.c | 566 + src/standalone_libraries/string.h | 197 + src/standalone_libraries/unicode.c | 210 + src/standalone_libraries/unicode.h | 55 + src/wasm_playground/01_hello_world.lc | 9 + .../02_conways_game_of_life.lc | 72 + src/wasm_playground/index.html | 110 + src/wasm_playground/run_server.bat | 1 + src/wasm_playground/wasm_main.c | 132 + src/x64/misc.cpp | 18 + src/x64/registers.cpp | 28 + src/x64/tests/array.lc | 4 + src/x64/tests/assignop.lc | 10 + src/x64/tests/expr.lc | 10 + src/x64/tests/first.lc | 31 + src/x64/tests/for_loop.lc | 18 + src/x64/tests/ifreturnvar.lc | 11 + src/x64/tests/pointers.lc | 25 + src/x64/tests/proc_call.lc | 17 + src/x64/value.cpp | 15 + src/x64/x64.h | 41 + src/x64/x64main.cpp | 309 + tests/any.txt | 106 + tests/any2.txt | 4 + tests/arrays.txt | 25 + tests/assign.txt | 173 + tests/assign_void_proc.txt | 18 + tests/break_inside_defer.txt | 12 + tests/break_outside_loop.txt | 6 + tests/build_if_note.txt | 21 + tests/builtins.txt | 89 + tests/builtins2.txt | 12 + tests/builtins3.txt | 21 + tests/cannot_use_type_as_value.txt | 13 + tests/compilation/test_compile_header.cpp | 4 + tests/compilation/test_compile_packed.c | 40 + tests/compilation/test_compile_packed_cpp.c | 40 + tests/compilation/test_compile_with_core.c | 5 + .../test_compile_with_core_cpp.cpp | 5 + tests/compo_cyclic_error.txt | 11 + tests/compos.txt | 55 + tests/compos2.txt | 4 + tests/compos_resolve.txt | 48 + tests/const.txt | 4 + tests/custom_untyped_string.txt | 37 + tests/defer_inside_defer.txt | 11 + tests/defer_order.txt | 21 + tests/defer_with_return_inside.txt | 7 + tests/division_by_0.txt | 3 + tests/doc_comment.txt | 36 + tests/doc_comments2.txt | 17 + tests/doc_comments3.txt | 8 + tests/duplicate_package_name/32asd/a.lc | 2 + tests/duplicate_package_name/main/main.lc | 6 + tests/duplicate_package_name/std_types/a.lc | 2 + tests/duplicate_package_name/test.txt | 3 + tests/error_call_proc_in_global_space.txt | 10 + tests/error_in_global_and_local.txt | 9 + tests/error_non_const_in_global_scope.txt | 37 + tests/error_on_shadowing.txt | 12 + tests/error_pointer_arithmetic.txt | 20 + tests/error_proc_invalid_args.txt | 41 + .../error_when_assigning_compo_to_global.txt | 8 + tests/errors.txt | 43 + tests/errors_proc_vargs.txt | 13 + tests/example_ui_and_hot_reloading/build.bat | 7 + .../dll/app_main.lc | 78 + .../example_ui_and_hot_reloading/dll/math.lc | 122 + .../dll/opengl.lc | 3012 +++++ .../dll/render_opengl.lc | 545 + .../dll/stb_truetype.lc | 183 + tests/example_ui_and_hot_reloading/dll/ui.lc | 342 + .../exe/exe_main.lc | 89 + .../shared/core.lc | 557 + .../shared/events.lc | 13 + .../shared/windows_types.lc | 34 + tests/field_access.txt | 37 + tests/field_pointer_offset.txt | 21 + tests/for.txt | 17 + tests/for2.txt | 12 + tests/fpointers.txt | 66 + tests/implicit_compo_array_size.txt | 16 + tests/import_libc.txt | 9 + tests/import_libc/main/main.lc | 12 + tests/import_libc2.txt | 7 + tests/invalid_note_name.txt | 18 + tests/labeled_breaks.txt | 40 + tests/lack_return.txt | 92 + tests/large_values.txt | 12 + tests/literals.txt | 94 + tests/loops.txt | 46 + tests/lvalues.txt | 19 + tests/lvalues2.txt | 5 + .../a/a.lc | 6 + .../b/b.lc | 3 + .../d_not_working/d.lc | 2 + .../main/main.lc | 13 + .../test.txt | 7 + .../working/c.lc | 7 + tests/multiple_errors_in_same_struct.txt | 19 + tests/negate.txt | 16 + tests/nested_comments.txt | 32 + tests/new_get_pointer.txt | 9 + tests/nil.txt | 7 + tests/opengl_loader.txt | 3028 +++++ tests/ops_on_basic_types_and_casts.txt | 129 + tests/packed_struct.txt | 52 + tests/parse_decl_errors.txt | 22 + tests/parse_decl_note.txt | 8 + tests/pointers.txt | 33 + tests/raw_strings.txt | 46 + tests/regression_const_assign_decls.txt | 10 + .../regression_crash_on_decl_like_builtin.txt | 17 + tests/regression_error_address_of_address.txt | 7 + ...ession_error_field_followed_by_invalid.txt | 25 + ...regression_error_handling_field_access.txt | 20 + ...egression_error_handling_field_access2.txt | 26 + tests/regression_incomplete_type.txt | 18 + tests/regression_note_after_if.txt | 12 + tests/regression_return_null_pointer.txt | 10 + tests/regression_same_named_agg_fields.txt | 6 + .../regression_same_named_proc_arguments.txt | 4 + tests/regression_sizeof_mismatch_with_c.txt | 19 + tests/regression_subtract_from_pointer.txt | 10 + tests/regression_typedefs_not_compiling.txt | 8 + ...ntified_in_function_please_dont_assert.txt | 14 + tests/resolve_for_error.txt | 13 + tests/simulated_enum.txt | 14 + tests/simulated_enum2.txt | 4 + tests/simulated_enum3.txt | 14 + tests/sizes1.txt | 113 + tests/sizes2.txt | 313 + tests/stmt_parse_error1.txt | 10 + tests/stmt_parse_error2.txt | 27 + tests/stmt_parse_error3.txt | 15 + tests/stmt_parse_error4.txt | 35 + tests/stmt_parse_error5.txt | 11 + tests/string_errors.txt | 19 + tests/strings.txt | 46 + tests/switch.txt | 18 + tests/switch2.txt | 15 + tests/switch3.txt | 15 + tests/switch4.txt | 15 + tests/switch5.txt | 11 + tests/switch_non_int.txt | 12 + tests/test_bound_check.txt | 23 + tests/test_build_if_import/a/a.lc | 5 + tests/test_build_if_import/a/b.lc | 5 + tests/test_build_if_import/b/a.lc | 5 + tests/test_build_if_import/b/b.lc | 5 + tests/test_build_if_import/main/main.lc | 8 + tests/test_cast_string_lvalue.txt | 8 + .../circular_b/circular_b.lc | 4 + .../test_circular_imports/main/circular_a.lc | 4 + tests/test_circular_imports/test.txt | 2 + .../circular_b/circular_b.lc | 4 + .../main/circular_a.lc | 4 + .../test_circular_imports_namespaced/test.txt | 2 + tests/test_cross_package_types/main/main.lc | 17 + .../main_error/main.lc | 7 + tests/test_cross_package_types/type/type.lc | 18 + .../test_error_in_other_package/main/main.lc | 14 + .../other/other.lc | 3 + tests/test_error_in_other_package/test.txt | 4 + tests/test_global_const.txt | 10 + tests/test_global_const2.txt | 11 + tests/test_import_duplicate_symbol/b/b.lc | 4 + tests/test_import_duplicate_symbol/main/a.lc | 4 + tests/test_import_duplicate_symbol/test.txt | 5 + tests/test_import_std/main/main.lc | 14 + tests/test_import_std/main/test_sizes.lc | 61 + tests/test_import_symbol_leak/a/a.lc | 3 + tests/test_import_symbol_leak/b/b.lc | 6 + tests/test_import_symbol_leak/main/c.lc | 6 + tests/test_import_symbol_leak/test.txt | 2 + .../b/duplicate_b.lc | 2 + .../main/duplicate_a.lc | 4 + .../test.txt | 5 + tests/test_namespaced_duplicate_decl/a2/a2.lc | 3 + .../main/main.lc | 6 + tests/test_namespaced_import/a/a.lc | 4 + tests/test_namespaced_import/b/b.lc | 12 + tests/test_namespaced_import/main/c.lc | 10 + tests/test_namespaced_import/test.txt | 3 + tests/test_same_foreign_names.txt | 11 + tests/test_two_mains/b/main.lc | 3 + tests/test_two_mains/main/main.lc | 5 + .../test_typechecking_all_errors_reported.txt | 37 + tests/typedef_struct.txt | 24 + tests/uninitialized.txt | 13 + tests/unreferenced_local_variable.txt | 7 + tests/untyped_overflow_div.txt | 11 + tests/untyped_strings.txt | 24 + tests/untyped_strings_errors.txt | 22 + tests/void_ptr_index.txt | 8 + tests/weird_import_parse.txt | 12 + tools/bindgen.py | 285 + tools/lcompile.c | 50 + tools/nasm.exe | Bin 0 -> 1388544 bytes tools/ndisasm.exe | Bin 0 -> 952832 bytes 335 files changed, 61571 insertions(+) create mode 100644 .github/workflows/run_tests.yaml create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 build.bat create mode 100644 build_file.cpp create mode 100644 examples/add_dynamic_array_macro/build.cpp create mode 100644 examples/add_dynamic_array_macro/main.lc create mode 100644 examples/add_instrumentation/build.cpp create mode 100644 examples/add_instrumentation/main.lc create mode 100644 examples/add_printf_format_check/build.cpp create mode 100644 examples/add_printf_format_check/main.lc create mode 100644 examples/add_source_location_macro/build.cpp create mode 100644 examples/add_source_location_macro/main.lc create mode 100644 examples/create_raylib_window/build.cpp create mode 100644 examples/create_raylib_window/main.lc create mode 100644 examples/generate_type_info/build.cpp create mode 100644 examples/generate_type_info/generated.lc create mode 100644 examples/generate_type_info/main.lc create mode 100644 examples/hello_world/build.cpp create mode 100644 examples/hello_world/main.lc create mode 100644 examples/pathfinding_visualizer/array.lc create mode 100644 examples/pathfinding_visualizer/build.cpp create mode 100644 examples/pathfinding_visualizer/main.lc create mode 100644 examples/pathfinding_visualizer/map.lc create mode 100644 examples/pathfinding_visualizer/random.lc create mode 100644 examples/sandbox/arena.lc create mode 100644 examples/sandbox/arena_win32.lc create mode 100644 examples/sandbox/build.cpp create mode 100644 examples/sandbox/common.lc create mode 100644 examples/sandbox/dynamic_array.lc create mode 100644 examples/sandbox/main.lc create mode 100644 examples/text_editor/buffer.lc create mode 100644 examples/text_editor/buffer_iter.lc create mode 100644 examples/text_editor/build.cpp create mode 100644 examples/text_editor/main.lc create mode 100644 examples/text_editor/rect2p.lc create mode 100644 examples/text_editor/unicode.lc create mode 100644 examples/text_editor/visual_pos.lc create mode 100644 examples/use_as_data_format_with_typechecking/build.cpp create mode 100644 examples/use_as_data_format_with_typechecking/data.lc create mode 100644 lib_compiler.h create mode 100644 pkgs/libc/assert.lc create mode 100644 pkgs/libc/ctype.lc create mode 100644 pkgs/libc/errno.lc create mode 100644 pkgs/libc/math.lc create mode 100644 pkgs/libc/size_t.lc create mode 100644 pkgs/libc/stdarg.lc create mode 100644 pkgs/libc/stdio.lc create mode 100644 pkgs/libc/stdlib.lc create mode 100644 pkgs/libc/string.lc create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/LICENSE create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/include/raylib.h create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/include/raymath.h create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/include/rlgl.h create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.dll create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.lib create mode 100644 pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylibdll.lib create mode 100644 pkgs/raylib/raylib.lc create mode 100644 pkgs/raylib/raymath.lc create mode 100644 pkgs/raylib/rlgl.lc create mode 100644 pkgs/std_types/c_types.lc create mode 100644 pkgs/std_types/non_c_types.lc create mode 100644 pkgs/std_types/types.lc create mode 100644 pkgs/std_types/windows_types.lc create mode 100644 pkgs/std_types/x64_linux_types.lc create mode 100644 pkgs/std_types/x64_types.lc create mode 100644 pkgs/std_types/x86_types.lc create mode 100644 src/build_file/ast_verify.cpp create mode 100644 src/build_file/package_compiler.cpp create mode 100644 src/build_file/test_readme.cpp create mode 100644 src/build_file/testsuite.cpp create mode 100644 src/build_tool/cache.cpp create mode 100644 src/build_tool/easy_strings.cpp create mode 100644 src/build_tool/library.cpp create mode 100644 src/build_tool/main.cpp create mode 100644 src/build_tool/process.cpp create mode 100644 src/compiler/arena.c create mode 100644 src/compiler/ast.c create mode 100644 src/compiler/ast_copy.c create mode 100644 src/compiler/ast_walk.c create mode 100644 src/compiler/bigint.c create mode 100644 src/compiler/common.c create mode 100644 src/compiler/extended_passes.c create mode 100644 src/compiler/genc.c create mode 100644 src/compiler/init.c create mode 100644 src/compiler/intern.c create mode 100644 src/compiler/lex.c create mode 100644 src/compiler/lib_compiler.c create mode 100644 src/compiler/lib_compiler.h create mode 100644 src/compiler/packages.c create mode 100644 src/compiler/parse.c create mode 100644 src/compiler/printer.c create mode 100644 src/compiler/resolve.c create mode 100644 src/compiler/resolver.c create mode 100644 src/compiler/string.c create mode 100644 src/compiler/to_string.c create mode 100644 src/compiler/unicode.c create mode 100644 src/compiler/unix_arena.c create mode 100644 src/compiler/unix_filesystem.c create mode 100644 src/compiler/value.c create mode 100644 src/compiler/win32_arena.c create mode 100644 src/compiler/win32_filesystem.c create mode 100644 src/core/allocator.c create mode 100644 src/core/allocator.h create mode 100644 src/core/array.hpp create mode 100644 src/core/cmd.c create mode 100644 src/core/cmd.h create mode 100644 src/core/core.c create mode 100644 src/core/core.cpp create mode 100644 src/core/core.h create mode 100644 src/core/filesystem.c create mode 100644 src/core/filesystem.h create mode 100644 src/core/table.hpp create mode 100644 src/profiler/profiler.c create mode 100644 src/profiler/spall.h create mode 100644 src/standalone_libraries/arena.c create mode 100644 src/standalone_libraries/arena.h create mode 100644 src/standalone_libraries/clexer.c create mode 100644 src/standalone_libraries/clexer.h create mode 100644 src/standalone_libraries/defer.hpp create mode 100644 src/standalone_libraries/hash.c create mode 100644 src/standalone_libraries/hash.h create mode 100644 src/standalone_libraries/io.c create mode 100644 src/standalone_libraries/io.h create mode 100644 src/standalone_libraries/linked_list.h create mode 100644 src/standalone_libraries/load_library.c create mode 100644 src/standalone_libraries/load_library.h create mode 100644 src/standalone_libraries/multimedia.c create mode 100644 src/standalone_libraries/multimedia.h create mode 100644 src/standalone_libraries/preproc_env.h create mode 100644 src/standalone_libraries/regex.c create mode 100644 src/standalone_libraries/regex.h create mode 100644 src/standalone_libraries/stb_sprintf.c create mode 100644 src/standalone_libraries/stb_sprintf.h create mode 100644 src/standalone_libraries/string.c create mode 100644 src/standalone_libraries/string.h create mode 100644 src/standalone_libraries/unicode.c create mode 100644 src/standalone_libraries/unicode.h create mode 100644 src/wasm_playground/01_hello_world.lc create mode 100644 src/wasm_playground/02_conways_game_of_life.lc create mode 100644 src/wasm_playground/index.html create mode 100644 src/wasm_playground/run_server.bat create mode 100644 src/wasm_playground/wasm_main.c create mode 100644 src/x64/misc.cpp create mode 100644 src/x64/registers.cpp create mode 100644 src/x64/tests/array.lc create mode 100644 src/x64/tests/assignop.lc create mode 100644 src/x64/tests/expr.lc create mode 100644 src/x64/tests/first.lc create mode 100644 src/x64/tests/for_loop.lc create mode 100644 src/x64/tests/ifreturnvar.lc create mode 100644 src/x64/tests/pointers.lc create mode 100644 src/x64/tests/proc_call.lc create mode 100644 src/x64/value.cpp create mode 100644 src/x64/x64.h create mode 100644 src/x64/x64main.cpp create mode 100644 tests/any.txt create mode 100644 tests/any2.txt create mode 100644 tests/arrays.txt create mode 100644 tests/assign.txt create mode 100644 tests/assign_void_proc.txt create mode 100644 tests/break_inside_defer.txt create mode 100644 tests/break_outside_loop.txt create mode 100644 tests/build_if_note.txt create mode 100644 tests/builtins.txt create mode 100644 tests/builtins2.txt create mode 100644 tests/builtins3.txt create mode 100644 tests/cannot_use_type_as_value.txt create mode 100644 tests/compilation/test_compile_header.cpp create mode 100644 tests/compilation/test_compile_packed.c create mode 100644 tests/compilation/test_compile_packed_cpp.c create mode 100644 tests/compilation/test_compile_with_core.c create mode 100644 tests/compilation/test_compile_with_core_cpp.cpp create mode 100644 tests/compo_cyclic_error.txt create mode 100644 tests/compos.txt create mode 100644 tests/compos2.txt create mode 100644 tests/compos_resolve.txt create mode 100644 tests/const.txt create mode 100644 tests/custom_untyped_string.txt create mode 100644 tests/defer_inside_defer.txt create mode 100644 tests/defer_order.txt create mode 100644 tests/defer_with_return_inside.txt create mode 100644 tests/division_by_0.txt create mode 100644 tests/doc_comment.txt create mode 100644 tests/doc_comments2.txt create mode 100644 tests/doc_comments3.txt create mode 100644 tests/duplicate_package_name/32asd/a.lc create mode 100644 tests/duplicate_package_name/main/main.lc create mode 100644 tests/duplicate_package_name/std_types/a.lc create mode 100644 tests/duplicate_package_name/test.txt create mode 100644 tests/error_call_proc_in_global_space.txt create mode 100644 tests/error_in_global_and_local.txt create mode 100644 tests/error_non_const_in_global_scope.txt create mode 100644 tests/error_on_shadowing.txt create mode 100644 tests/error_pointer_arithmetic.txt create mode 100644 tests/error_proc_invalid_args.txt create mode 100644 tests/error_when_assigning_compo_to_global.txt create mode 100644 tests/errors.txt create mode 100644 tests/errors_proc_vargs.txt create mode 100644 tests/example_ui_and_hot_reloading/build.bat create mode 100644 tests/example_ui_and_hot_reloading/dll/app_main.lc create mode 100644 tests/example_ui_and_hot_reloading/dll/math.lc create mode 100644 tests/example_ui_and_hot_reloading/dll/opengl.lc create mode 100644 tests/example_ui_and_hot_reloading/dll/render_opengl.lc create mode 100644 tests/example_ui_and_hot_reloading/dll/stb_truetype.lc create mode 100644 tests/example_ui_and_hot_reloading/dll/ui.lc create mode 100644 tests/example_ui_and_hot_reloading/exe/exe_main.lc create mode 100644 tests/example_ui_and_hot_reloading/shared/core.lc create mode 100644 tests/example_ui_and_hot_reloading/shared/events.lc create mode 100644 tests/example_ui_and_hot_reloading/shared/windows_types.lc create mode 100644 tests/field_access.txt create mode 100644 tests/field_pointer_offset.txt create mode 100644 tests/for.txt create mode 100644 tests/for2.txt create mode 100644 tests/fpointers.txt create mode 100644 tests/implicit_compo_array_size.txt create mode 100644 tests/import_libc.txt create mode 100644 tests/import_libc/main/main.lc create mode 100644 tests/import_libc2.txt create mode 100644 tests/invalid_note_name.txt create mode 100644 tests/labeled_breaks.txt create mode 100644 tests/lack_return.txt create mode 100644 tests/large_values.txt create mode 100644 tests/literals.txt create mode 100644 tests/loops.txt create mode 100644 tests/lvalues.txt create mode 100644 tests/lvalues2.txt create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/a/a.lc create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/b/b.lc create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/d_not_working/d.lc create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/main/main.lc create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/test.txt create mode 100644 tests/make_sure_to_try_resolving_all_imports_despite_errors/working/c.lc create mode 100644 tests/multiple_errors_in_same_struct.txt create mode 100644 tests/negate.txt create mode 100644 tests/nested_comments.txt create mode 100644 tests/new_get_pointer.txt create mode 100644 tests/nil.txt create mode 100644 tests/opengl_loader.txt create mode 100644 tests/ops_on_basic_types_and_casts.txt create mode 100644 tests/packed_struct.txt create mode 100644 tests/parse_decl_errors.txt create mode 100644 tests/parse_decl_note.txt create mode 100644 tests/pointers.txt create mode 100644 tests/raw_strings.txt create mode 100644 tests/regression_const_assign_decls.txt create mode 100644 tests/regression_crash_on_decl_like_builtin.txt create mode 100644 tests/regression_error_address_of_address.txt create mode 100644 tests/regression_error_field_followed_by_invalid.txt create mode 100644 tests/regression_error_handling_field_access.txt create mode 100644 tests/regression_error_handling_field_access2.txt create mode 100644 tests/regression_incomplete_type.txt create mode 100644 tests/regression_note_after_if.txt create mode 100644 tests/regression_return_null_pointer.txt create mode 100644 tests/regression_same_named_agg_fields.txt create mode 100644 tests/regression_same_named_proc_arguments.txt create mode 100644 tests/regression_sizeof_mismatch_with_c.txt create mode 100644 tests/regression_subtract_from_pointer.txt create mode 100644 tests/regression_typedefs_not_compiling.txt create mode 100644 tests/regression_unidentified_in_function_please_dont_assert.txt create mode 100644 tests/resolve_for_error.txt create mode 100644 tests/simulated_enum.txt create mode 100644 tests/simulated_enum2.txt create mode 100644 tests/simulated_enum3.txt create mode 100644 tests/sizes1.txt create mode 100644 tests/sizes2.txt create mode 100644 tests/stmt_parse_error1.txt create mode 100644 tests/stmt_parse_error2.txt create mode 100644 tests/stmt_parse_error3.txt create mode 100644 tests/stmt_parse_error4.txt create mode 100644 tests/stmt_parse_error5.txt create mode 100644 tests/string_errors.txt create mode 100644 tests/strings.txt create mode 100644 tests/switch.txt create mode 100644 tests/switch2.txt create mode 100644 tests/switch3.txt create mode 100644 tests/switch4.txt create mode 100644 tests/switch5.txt create mode 100644 tests/switch_non_int.txt create mode 100644 tests/test_bound_check.txt create mode 100644 tests/test_build_if_import/a/a.lc create mode 100644 tests/test_build_if_import/a/b.lc create mode 100644 tests/test_build_if_import/b/a.lc create mode 100644 tests/test_build_if_import/b/b.lc create mode 100644 tests/test_build_if_import/main/main.lc create mode 100644 tests/test_cast_string_lvalue.txt create mode 100644 tests/test_circular_imports/circular_b/circular_b.lc create mode 100644 tests/test_circular_imports/main/circular_a.lc create mode 100644 tests/test_circular_imports/test.txt create mode 100644 tests/test_circular_imports_namespaced/circular_b/circular_b.lc create mode 100644 tests/test_circular_imports_namespaced/main/circular_a.lc create mode 100644 tests/test_circular_imports_namespaced/test.txt create mode 100644 tests/test_cross_package_types/main/main.lc create mode 100644 tests/test_cross_package_types/main_error/main.lc create mode 100644 tests/test_cross_package_types/type/type.lc create mode 100644 tests/test_error_in_other_package/main/main.lc create mode 100644 tests/test_error_in_other_package/other/other.lc create mode 100644 tests/test_error_in_other_package/test.txt create mode 100644 tests/test_global_const.txt create mode 100644 tests/test_global_const2.txt create mode 100644 tests/test_import_duplicate_symbol/b/b.lc create mode 100644 tests/test_import_duplicate_symbol/main/a.lc create mode 100644 tests/test_import_duplicate_symbol/test.txt create mode 100644 tests/test_import_std/main/main.lc create mode 100644 tests/test_import_std/main/test_sizes.lc create mode 100644 tests/test_import_symbol_leak/a/a.lc create mode 100644 tests/test_import_symbol_leak/b/b.lc create mode 100644 tests/test_import_symbol_leak/main/c.lc create mode 100644 tests/test_import_symbol_leak/test.txt create mode 100644 tests/test_multiple_imports_of_same_package/b/duplicate_b.lc create mode 100644 tests/test_multiple_imports_of_same_package/main/duplicate_a.lc create mode 100644 tests/test_multiple_imports_of_same_package/test.txt create mode 100644 tests/test_namespaced_duplicate_decl/a2/a2.lc create mode 100644 tests/test_namespaced_duplicate_decl/main/main.lc create mode 100644 tests/test_namespaced_import/a/a.lc create mode 100644 tests/test_namespaced_import/b/b.lc create mode 100644 tests/test_namespaced_import/main/c.lc create mode 100644 tests/test_namespaced_import/test.txt create mode 100644 tests/test_same_foreign_names.txt create mode 100644 tests/test_two_mains/b/main.lc create mode 100644 tests/test_two_mains/main/main.lc create mode 100644 tests/test_typechecking_all_errors_reported.txt create mode 100644 tests/typedef_struct.txt create mode 100644 tests/uninitialized.txt create mode 100644 tests/unreferenced_local_variable.txt create mode 100644 tests/untyped_overflow_div.txt create mode 100644 tests/untyped_strings.txt create mode 100644 tests/untyped_strings_errors.txt create mode 100644 tests/void_ptr_index.txt create mode 100644 tests/weird_import_parse.txt create mode 100644 tools/bindgen.py create mode 100644 tools/lcompile.c create mode 100644 tools/nasm.exe create mode 100644 tools/ndisasm.exe diff --git a/.github/workflows/run_tests.yaml b/.github/workflows/run_tests.yaml new file mode 100644 index 0000000..f226b84 --- /dev/null +++ b/.github/workflows/run_tests.yaml @@ -0,0 +1,25 @@ +on: [push] +jobs: + run-and-compile-ubuntu: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: sudo apt install g++ + - run: sudo apt install clang + - run: g++ -o bld src/build_tool/main.cpp -g -lm && ./bld + run-and-compile-mac: + runs-on: macos-latest + steps: + - uses: actions/checkout@v4 + - run: brew install llvm + - run: clang++ src/build_tool/main.cpp -std=c++11 -o bld && ./bld + run-and-compile-windows: + runs-on: windows-latest + steps: + - name: Setup MSVC Developer Command Prompt + uses: TheMrMilchmann/setup-msvc-dev@v3.0.0 + with: + arch: x64 + - uses: actions/checkout@v4 + - run: cl.exe src/build_tool/main.cpp /Fe:bld.exe && bld.exe + shell: cmd \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b320a46 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +build/ +private.bat +todo.txt +*.sublime-project +*.sublime-workspace +*.rdbg +*.wasm diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..2f69c3d --- /dev/null +++ b/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2024 Krzosa Karol + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..acfd04d --- /dev/null +++ b/README.md @@ -0,0 +1,674 @@ +# Compiler front-end in a single-header-file C library + +I have no illusions here, this is not the next big language. What I propose is very simple, "a return to C", a language that is smaller but with modern features, distributed as a dependency free, easy to use single-header-file library. Add compiler checks, generate code, do whatever floats your boat. Enjoy. + +- **User has full control over compilation!** +- **No dependencies, permissive license, single file that compile both in C and C++!** +- **Simpler then C:** core of the language is 4000 loc and entire package 11k loc. +- **Statically typed, procedural and MODERN:** it's a mix of Go/Odin/Jai with "return to C" as ideal. +- **Complete:** it supports conditional compilation, modularity via packages etc. +- **State of art error handling techniques** like AST poisoning, proper parsing recovery, catches tons of errors without misreporting! +- **Great C integration:** using C libraries feels native, the language compiles easily to C with great debug info. + +**Library is in beta so I reserve the right to change things!** + +## Example or [you can try the language online](https://krzosa.xyz/playground.html) + +``` odin +import "raylib"; + +main :: proc(): int { + InitWindow(800, 600, "Thing"); + SetTargetFPS(60); + + for !WindowShouldClose() { + BeginDrawing(); + ClearBackground(RAYWHITE); + DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); + EndDrawing(); + } + CloseWindow(); + return 0; +} +``` + +**Program examples:** + +- [Hello world](examples/hello_world) +- [Text editor](examples/text_editor) +- [Path-finding visualizer](examples/pathfinding_visualizer) + +**Examples of hooking into the compilation:** + +- [Generating type information](examples/generate_type_info) +- [Adding printf checks](examples/add_printf_format_check) +- [Adding instrumentation to every procedure](examples/add_instrumentation) +- [Adding a generic dynamic array using AST modification](examples/add_dynamic_array_macro) + +**Other:** + +- [Using the language as a data format (with type safety)](examples/use_as_data_format_with_typechecking) + +## How to integrate + +To create the implementation do this in **one** of your C or C++ files: + +``` c +#define LIB_COMPILER_IMPLEMENTATION +#include "lib_compiler.h" +``` + +## How to build the compiler executable + +Simply compile one file with whatever compiler you want: + +``` bash +clang tools/lcompile.c -o lc.exe +``` + +Once you have the executable you can compile examples and stuff: + +``` bash +lc.exe examples/create_raylib_window +``` + +When in doubt: `./lc.exe --help`. + +## How to run the test suite + +``` bash +clang++ src/build_tool/main.cpp -o bld.exe +./bld.exe +``` + +You only need to compile the build tool once. Afterwards just call `./bld.exe`. There are multiple testing options so checkout: `./bld.exe --help`. + +## Further plans + +My priority is to improve the C user API, harden the compiler, accommodate things that I didn't foresee and stuff like that. + +Sometime in the future I want to implement a bytecode backend so that the language can be used like Lua as a nice scripting language. + +I'm also considering the addition of overloaded procedures because it would greatly aid in writing macros. + +# Language overview + +The language is strictly procedural, I have taken most of the inspiration from C, Golang, Ion, Jai and Odin. There are no classes, methods etc. only procedures and data types. + +## Packages + +Package is a real directory on your disk that contains source files. It's also an aggregation of declarations - functions, constants, variables, types which you can `import` into your program. + +``` odin +import "libc"; +import RL "raylib"; + +main :: proc(): int { + RL.SetClipboardText("**magic**"); + printf("**magic**"); + return 0; +} +``` + + + + + +## Constants + +By which I mean the literal values but also the named declarations. There are 3 constant types in the language: untyped ints, untyped floats and untyped strings. The "untyped" here means that the type is inferred from context. There are no suffixes like 'ull', no random overflows and the values are also bounds checked for safety. If you have ever used Go, I have a good news for you, you are already familiar with this concept. + +``` odin +binary :: 0b10000110; +hex1 :: 0xabcd3245; +hex2 :: 0xABCD3245; +decimal :: 1235204950; +floating_point :: 2342.44230; + +boolean :: false; +nil_val :: nil; + +string_val :: "Something"; +raw_string :: ` +{ + "cool_json": "yes", + "cool_array": ["a", "b", 32], +} +`; +``` + +## Types + +The type system is strict, most conversions require explicit casts. + +``` odin +a: int = 10; +b: long = :long(a); // all of these assignments require a cast +c: float = :float(a); +d: short = :short(a); +e: llong = 1234; // untyped constants automatically fit into the context + // no matter the type +``` + +There is one exception which is the `*void` type. It has very permissive semantics. + +``` odin +i1: int; +v : *void = &i1; +i2: *int = v; +``` + +When using regular pointers, again, casts are necessary. + +``` odin +i1: *int = nil; +i2: *float = :*float(i1); +``` + +Compound types are read from left to right. This creates a nice mirroring between spoken and the symbolic language: + +``` odin +a: *int; // a: pointer '*' to an int +b: [32]*int; // an: array of 32 pointers to int +c: *proc(): int; // a: pointer to a proc type that returns int +``` + +## Structs and unions + +``` odin +Node :: struct { + v1: Value; + v2: Value; +} + +Value :: union { + i64: llong; + u64: ullong; +} +``` + +## Basic types + +The language uses exactly the same types as C for greater compatibility. I don't want to go against the current. I want the language to be as simple as possible. + +``` odin +c: char; uc: uchar; s: short; us: ushort; +i: int; ui: uint; l: long; ul: ulong; +ll: llong; ull: ullong; f: float; d: double; +b: bool; +``` + +## Typedefs + +Typedef allows you to create an alias to an existsing type but with additional layer of type safety. `my_int` is not an `int`, it's a different type and so it requires a cast. + +``` +my_int :: typedef int; + +i: int = 10; +mi: my_int = :my_int(i); // requires a cast +``` + +A simple alias can be defined by adding a '@weak' note: + +``` +my_int: typedef int; @weak + +i: int = 10; +mi: my_int = i; +``` + +## Compound expressions + +These are expressions meant for initializing structs and unions. + +- Particular members can be targeted by name. +- Members that were not mentioned are initialized to zero. + +``` odin +Vector2 :: struct { x: float; y: float; } +Camera2D :: struct { + offset: Vector2; + target: Vector2; + rotation: float; + zoom: float; +} + +Camera: Camera2D = { + offset = {100, 100}, + zoom = 1.0, +}; + +SecondCamera := :Camera2D{{1, 1}, zoom = 1.0}; +``` + +## Arrays and compound expressions + +``` odin +array: [100]int; // array of 100 integers + +inited_array: [100]int = { + 0, + [4] = 4, + [50] = 50, + [99] = 99, + // remaining values are '0'ed +}; +``` + +## Named and default procedure arguments + +``` odin +RED :: 0xff0000ff; +DrawRectangle :: proc(x: int, y: int, w: int, h: int, color: uint = RED); + +main :: proc(): int { + DrawRectangle(x = 100, y = 100, w = 50, h = 50); + return 0; +} +``` + +## Simulating enums + +The language doesn't have enums but similar feature can be easily simulated. Operator '^' allows you to generate a list of enumerated constants: 1, 2, 3 ... using typedef you can create a simple integer type with additional type safety. + +``` +TextKind :: typedef int; +TEXT_INVALID :: 0; +TEXT_BOLD :: ^; // 1 +TEXT_CURSIVE :: ^; // 2 +TEXT_NORMAL :: ^; // 3 +``` + +## Enumerating bit flags + +Operator '<<' allows you to generate a list of enumerated flags: 0b1, 0b10, 0b100 ... + +``` +EntityProps :: typedef uint; +ENTITY_CAN_BURN :: 0b1; +ENTITY_CAN_MOVE :: <<; // 0b10 +ENTITY_CAN_BE_SHOCKED :: <<; // 0b100 +ENTITY_WALKING :: <<; // 0b1000 +``` + +## `*char` and String types + +The language by default is very `*char` friendly. Strings default to the cstring type which functions in exactly the same way as in C. It functions as an array of bytes which is null terminated by a null `0`. + +But the language also has it's own String type: + +``` +String :: struct { + str: *char; + len: int; +} +``` + +Untyped strings work well with both: + +``` odin +a: String = "sized string"; +b: *char = "c string"; +c: = "this defaults to *char"; +``` + +`String` is a structure so you need to index it using `.str` or `.len`. + +``` odin +test :: proc() { + a: *char = "C string"; + c := a[1]; + + b: String = "Len string"; + c = b.str[1]; + len := b.len; @unused +} +``` + +A `lengthof` operator can be used to learn how big a constant string is, this also works for arrays: + +``` odin +str :: "String"; +len :: lengthof(str); +``` + +## Pointer arithmetic + +``` odin +import "libc"; + +test :: proc() { + a: *int = malloc(sizeof(:int) * 10); + c: *int = addptr(a, 4); + d: *int = &a[4]; + // there is no: (a + 4) +} +``` + +## Casting between types + +``` +a: float = :float(10); + +b := &a; +c := :*int(b); +``` + +## If statement + +``` odin +if_statement_showcase :: proc(cond: int) { + if cond == 1 { + // + } else if cond == 2 { + // + } else { + // + } +} +``` + +## Switch statement + +``` odin +import "libc"; +switch_statement_showcase :: proc(value: int) +{ + switch value + { + case 0,4,8: + { + printf("0, 4, 8\n"); + } + case 1, 2, 3: + { + printf("1, 2, 3\n"); + } @fallthrough + case 5: + { + printf("this activates when 1, 2, 3 and 5\n"); + } + default: printf("default case"); + } +} +``` + +## For loop + +``` odin +for_loop_showcase :: proc() { + + // infinite loop + for { + /* .. */ + } + + cond := true; + for cond { + break; + } + + for i := 0; i < 4; i += 1 { + // + } + + i := 0; + for i < 4 { + i += 1; + } + + i = 0; + for i < 4; i += 1 { + // + } +} +``` + +## Labeled loops, breaks and continues + +You can label a loop and use that label to control the outer loop. + +``` odin +test :: proc() { + cond := true; + outer_loop: for cond { + for cond { + break outer_loop; // continue works too + } + } +} +``` + +## Defer statement + +A defer statement allows to postpone a certain action to the end of scope. For example - you might allocate memory and use defer just bellow your allocation to free the memory. This free will be deferred, it will happen a bit later. + +``` odin +import "libc"; +test :: proc() { + // it's useful to keep certain pairs of actions together: + file := fopen("data.txt", "rb"); + if (file) { + defer fclose(file); + // .. do things + } +} +``` + +## Notes + +You can annotate declarations, statements etc. This puts metadata on the AST which you can access from a metaprogram. + +``` odin +// a note that starts with '#', doesn't bind to anything, it basically acts as a directive. +#do_something(a, b, c); + + +Data :: struct { + a: int; + b: *int; +} @serialize // binds to AST of Data +``` + +The language uses notes to implement a bunch of features, for example: + +``` odin +#static_assert(sizeof(:int) == 4); + + +test :: proc() { + // ... +} @build_if(LC_OS == OS_WINDOWS) +``` + +## Conditional compilation + +It's important for a low level language to have some form of platform awareness. We don't have includes and preprocessor here so I decided to implement a construct that works during parsing stage. It discards declarations and doesn't let them into typechecking based on the evaluation of the inner expression. + +'#build_if' can appear at the top of the file, it decides whether to compile that particular file or not: + +``` odin +#build_if(LC_OS == OS_WINDOWS); +``` + +'@build_if' can be bound to any top level declaration. + +``` odin +LONG_MAX :: 0xFFFFFFFF; @build_if(LC_OS == OS_WINDOWS) +LONG_MAX :: 0xFFFFFFFFFFFFFFFF; @build_if(LC_OS == OS_MAC || LC_OS == OS_LINUX) +``` + +## Builtins (like sizeof) + +``` odin +a := sizeof(:int); +b := alignof(:int); + +A :: struct { a: int; b: int; } +c := offsetof(:A, b); + +d := lengthof("asd"); +e := typeof(d); + +#static_assert(offsetof(:A, b) == 4); +``` + +## Raw C code when targeting the C generator + +``` odin +#`#include `; + +global_variable := 0; + +main :: proc(): int { + a: *int = #`malloc(32)`; + #`a[0] = lc_package_global_variable`; + return a[0]; +} +``` + +## Any and typeof + +``` odin +Any :: struct { + type: int; + data: *void; +} +``` + +``` odin +test :: proc() { + a: Any = 32; + b: Any = "thing"; + c: Any = b; + + i: int = 10; + d: Any = &i; +} +``` + +``` odin +print :: proc(v: Any) { + switch(v.type) { + case typeof(:int): { + val := :*int(v.data); + // .. + } + case typeof(:float): { + val := :*float(v.data); + // .. + } + } +} + +main :: proc() { + print(32); + print("asd"); +} +``` + +## Variadic arguments with Any promotion + +``` odin +import "libc"; + +any_vargs :: proc(fmt: *char, ...Any) { + va: va_list; + va_start(va, fmt); + + for i := 0; fmt[i]; i += 1 { + if fmt[i] == '%' { + arg := va_arg_any(va); + + if arg.type == typeof(:int) { + val := :*int(arg.data); + // .. + } else { + // .. + } + } + } + + va_end(va); +} + +main :: proc() { + any_vargs("testing % %", 32, "thing"); +} +``` + +## Comments + +``` odin +// I'm a line comment + +/* I'm a block comment + /* + I can even nest! + */ +*/ +``` + +## Doc comments + +``` odin +/** package + +This is a package doc comment, + there can only be 1 per package, + it appears at top of the file. +It binds to the package AST. + +*/ + +/** file + +This is a file doc comment, + there can only be 1 per file, + it appears at top of the file under package doc comment. +It binds to the file AST. + +*/ + +/** + +This is a top level declaration doc comment, + 1 per declaration, + it appears above the declaration. +It binds to the declaration AST. + +*/ +A :: proc(): int { + return 0; +} +``` + +## Packed structs + +``` odin +A :: struct { + a: short; + b: char; + c: int; + d: char; + e: llong; + f: uchar; +} @packed +``` + +## Useful resources for compiler development + +* https://c3.handmade.network/blog/p/8632-handling_parsing_and_semantic_errors_in_a_compiler - great article by Christoffer Lerno (C3 author) about handling errors in compilers. +* https://www.youtube.com/watch?v=bNJhtKPugSQ - Walter Bright (D author) talks about AST poisoning here. +* https://bitwise.handmade.network/ - series by Per Vognsen where he actually creates a C like language, very helpful, very hands on! +* https://hero.handmade.network/episode/code/day206/ - this episode of handmade hero started me on the entire compiler journey, a long, long time ago. +* https://www.youtube.com/watch?v=TH9VCN6UkyQ&list=PLmV5I2fxaiCKfxMBrNsU1kgKJXD3PkyxO - I have re-watched this playlist many this, searching for keywords and ideas. Jonathan Blow's compiler was a big inspiration of mine when learning programming languages. +* A Retargetable C Compiler: Design and Implementation by Christopher W. Fraser and David R. Hanson - sometimes looked at this as a reference to figure stuff out. Very helpful resource on compiler construction, the way it's written reads more like documentation but you use what you have. +* Compiler Construction by Niklaus Wirth - https://people.inf.ethz.ch/wirth/CompilerConstruction/index.html - have to learn to read Pascal / Oberon but he goes over implementing all the stages of the compiler. Wirth's project of implementing an entire hardware / software stack is really inspiring. +* https://github.com/rui314/chibicc - great resource for learning how to write a very dumb x64 backend. I like the format, you go over git commits, doesn't work well on github though, with Sublime Merge it's a pleasure to follow. +* https://go.dev/blog/constants - article on golang type system, untyped types, constants that kind of stuff. +* https://github.com/JoshuaManton/sif - looked at this as a reference from time to time, author seems like a Jonathan Blow fan so it was a good resource informed by similar resources as I used. +* https://github.com/gingerbill/odin - I sometimes peeked at the compiler to figure stuff out when I was confused. +https://c3.handmade.network/blog - Christoffer Lerno (C3 author) blog. +* https://github.com/c3lang/c3c - I sometimes looked at C3 compiler as a reference, the author also let me use his bigint library, thanks a lot! :) diff --git a/build.bat b/build.bat new file mode 100644 index 0000000..fc8ae12 --- /dev/null +++ b/build.bat @@ -0,0 +1,11 @@ +@echo off + +if not exist build\bld.exe ( + mkdir build + cd build + cl -Fe:bld.exe ../src/build_tool/main.cpp -FC -WX -W3 -wd4200 -wd4244 -diagnostics:column -nologo -Zi -D_CRT_SECURE_NO_WARNINGS + cd .. +) + +rem ubuntu run ./build.sh +build\bld.exe diff --git a/build_file.cpp b/build_file.cpp new file mode 100644 index 0000000..9de7d1f --- /dev/null +++ b/build_file.cpp @@ -0,0 +1,311 @@ +/* This build file runs all the tests, compiles them using all +available compilers, cleans the house and walks the dog. Wowie. +*/ +#include "src/build_tool/library.cpp" + +#define LC_USE_CUSTOM_ARENA +#define LC_Arena MA_Arena +#define LC__PushSizeNonZeroed MA__PushSizeNonZeroed +#define LC__PushSize MA__PushSize +#define LC_InitArena MA_Init +#define LC_DeallocateArena MA_DeallocateArena +#define LC_BootstrapArena MA_Bootstrap +#define LC_TempArena MA_Temp +#define LC_BeginTemp MA_BeginTemp +#define LC_EndTemp MA_EndTemp + +#define LC_String S8_String +#include "src/compiler/lib_compiler.c" + +#include + +bool UseClang; +bool UseCL; +bool UseTCC; +bool UseGCC; +bool QuickRun; +bool BuildX64Sandbox; +bool BreakpointOnError; +S8_List TestsToRun; +bool UseColoredIO; +int ThreadCount = 24; +bool PrintAllFunctions; + +S8_String RaylibLIB; +S8_String RaylibDLL; + +#include "src/build_file/ast_verify.cpp" +#include "src/build_file/test_readme.cpp" +#include "src/build_file/testsuite.cpp" +#include "src/build_file/package_compiler.cpp" + +#include "examples/add_printf_format_check/build.cpp" +#include "examples/pathfinding_visualizer/build.cpp" +#include "examples/generate_type_info/build.cpp" +#include "examples/add_dynamic_array_macro/build.cpp" +#include "examples/text_editor/build.cpp" +#include "examples/hello_world/build.cpp" +#include "examples/sandbox/build.cpp" +#include "examples/create_raylib_window/build.cpp" +#include "examples/add_instrumentation/build.cpp" +#include "examples/use_as_data_format_with_typechecking/build.cpp" +#include "examples/add_source_location_macro/build.cpp" + +int main(int argc, char **argv) { + MA_InitScratch(); + + MA_Scratch scratch; + UseColoredIO = OS_EnableTerminalColors(); + + { + CmdParser p = MakeCmdParser(scratch, argc, argv, "I'm a build tool for this codebase, by default I build the entire test suite"); + AddBool(&p, &BuildX64Sandbox, "build-x64-sandbox", "build the x64 sandbox program using msvc"); + AddBool(&p, &QuickRun, "quick", "build tests using tcc compiler only"); + AddBool(&p, &BreakpointOnError, "breakpoint", "breakpoint if a compiler error is thrown"); + AddBool(&p, &PrintAllFunctions, "print-functions", "prints all functions marked with LC_FUNCTION"); + AddInt(&p, &ThreadCount, "threads", "number of threads to use when running the test suite"); + AddList(&p, &TestsToRun, "tests", "run only these particular tests"); + if (!ParseCmd(Perm, &p)) return 0; + } + + // + // Find compilers in the path + // + { + char *path_string = getenv("PATH"); + Array path = Split(path_string, IF_WINDOWS_ELSE(";", ":")); + + char *end = IF_WINDOWS_ELSE(".exe", ""); + For(path) { + S8_String clpath = Fmt("%.*s/cl%s", S8_Expand(it), end); + S8_String clangpath = Fmt("%.*s/clang%s", S8_Expand(it), end); + S8_String tccpath = Fmt("%.*s/tcc%s", S8_Expand(it), end); + S8_String gccpath = Fmt("%.*s/gcc%s", S8_Expand(it), end); + + if (OS_FileExists(clpath)) UseCL = true; + if (OS_FileExists(clangpath)) UseClang = true; + if (OS_FileExists(tccpath)) UseTCC = true; +#if OS_WINDOWS == 0 + if (OS_FileExists(gccpath)) UseGCC = true; +#endif + } + } + + if (UseClang == false && UseCL == false && UseTCC == false && UseGCC == false) { + IO_FatalErrorf("Found no supported compiler on the PATH! Make sure to have GCC, Clang, CL/MSVC or TCC on the PATH"); + } + + if (QuickRun) { + if (!UseTCC) IO_FatalErrorf("TCC is not on the path"); + UseClang = false; + UseCL = false; + UseGCC = false; + UseTCC = true; + } + + RaylibLIB = OS_GetAbsolutePath(Perm, "../pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylibdll.lib"); + RaylibDLL = OS_GetAbsolutePath(Perm, "../pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.dll"); + + if (BuildX64Sandbox) { + PushDir("x64_sandbox"); + S8_String cc = "cl"; + + Array flags = {MA_GetAllocator(scratch)}; + flags += "/MP /Zi -D_CRT_SECURE_NO_WARNINGS"; + flags += "/FC /WX /W3 /wd4200 /diagnostics:column /nologo"; + flags += "/GF /Gm- /Oi"; + flags += "/GR- /EHa-"; + flags += "/D_DEBUG -RTC1 -Od"; + flags += Fmt("/Fe:x64main.exe"); + OS_DeleteFile("x64main.pdb"); + Run(cc + "../../src/x64/x64main.cpp" + flags); + return 0; + } + + PackageCompiler(); + IO_Printf("Compiler packed successfully: lib_compiler.h\n"); + + if (ShouldRun("test_readme")) { + TestReadme(); + } + + OS_MakeDir("examples"); + if (ShouldRun("add_printf_format_check")) { + bool result = add_printf_format_check(); + if (result) IO_Printf("%-50s - OK\n", "add_printf_format_check"); + else IO_Printf("%-50s - ERROR\n", "add_printf_format_check"); + } + + if (ShouldRun("generate_type_info")) { + bool result = generate_type_info(); + if (result) IO_Printf("%-50s - OK\n", "generate_type_info"); + else IO_Printf("%-50s - ERROR\n", "generate_type_info"); + } + + if (ShouldRun("add_dynamic_array_macro")) { + bool result = add_dynamic_array_macro(); + if (result) IO_Printf("%-50s - OK\n", "add_dynamic_array_macro"); + else IO_Printf("%-50s - ERROR\n", "add_dynamic_array_macro"); + } + + if (ShouldRun("text_editor")) { + bool result = text_editor(); + if (result) IO_Printf("%-50s - OK\n", "text_editor"); + else IO_Printf("%-50s - ERROR\n", "text_editor"); + } + + if (ShouldRun("pathfinding_visualizer")) { + bool result = pathfinding_visualizer(); + if (result) IO_Printf("%-50s - OK\n", "pathfinding_visualizer"); + else IO_Printf("%-50s - ERROR\n", "pathfinding_visualizer"); + } + + if (ShouldRun("hello_world")) { + bool result = hello_world(); + if (result) IO_Printf("%-50s - OK\n", "hello_world"); + else IO_Printf("%-50s - ERROR\n", "hello_world"); + } + + if (!ShouldRun("sandbox")) { + bool result = sandbox(); + if (result) IO_Printf("%-50s - OK\n", "sandbox"); + else IO_Printf("%-50s - ERROR\n", "sandbox"); + } + + if (ShouldRun("create_raylib_window")) { + bool result = create_raylib_window(); + if (result) IO_Printf("%-50s - OK\n", "create_raylib_window"); + else IO_Printf("%-50s - ERROR\n", "create_raylib_window"); + } + + if (ShouldRun("add_instrumentation")) { + bool result = add_instrumentation(); + if (result) IO_Printf("%-50s - OK\n", "add_instrumentation"); + else IO_Printf("%-50s - ERROR\n", "add_instrumentation"); + } + + if (!ShouldRun("wasm_playground") && UseClang) { + OS_MakeDir("wasm_playground"); + int result = Run("clang --target=wasm32 -mbulk-memory -Oz -Wno-writable-strings --no-standard-libraries -Wl,--strip-all -Wl,--import-memory -Wl,--no-entry -o wasm_playground/playground.wasm ../src/wasm_playground/wasm_main.c -DOS_WASM=1"); + + S8_String index = OS_ReadFile(scratch, "../src/wasm_playground/index.html"); + S8_List programs = S8_MakeEmptyList(); + + OS_SetWorkingDir("wasm_playground"); // so that RegisterDir("../../pkgs") works + for (OS_FileIter it = OS_IterateFiles(scratch, "../../src/wasm_playground/"); OS_IsValid(it); OS_Advance(&it)) { + if (S8_EndsWith(it.filename, ".lc", false)) { + RunTestFile({TestKind_File, it.absolute_path, it.filename, "not_needed", true}); + + S8_String file = OS_ReadFile(scratch, it.absolute_path); + file = S8_ReplaceAll(scratch, file, S8_Lit("\\"), S8_Lit("\\\\"), true); + S8_AddF(scratch, &programs, "`%.*s`,\n", S8_Expand(file)); + } + } + OS_SetWorkingDir(".."); + + S8_String programs_string = S8_Merge(scratch, programs); + S8_String new_index = S8_ReplaceAll(scratch, index, "", programs_string, false); + + OS_WriteFile("wasm_playground/playground.html", new_index); + OS_CopyFile("../src/wasm_playground/run_server.bat", "wasm_playground/run_server.bat", true); + + if (result == 0) IO_Printf("%-50s - OK\n", "wasm_playground"); + else IO_Printf("%-50s - ERROR\n", "wasm_playground"); + } + + if (ShouldRun("use_as_data_format_with_typechecking")) { + bool result = use_as_data_format_with_typechecking(); + if (result) IO_Printf("%-50s - OK\n", "use_as_data_format_with_typechecking"); + else IO_Printf("%-50s - ERROR\n", "use_as_data_format_with_typechecking"); + } + + if (ShouldRun("add_source_location_macro")) { + bool result = add_source_location_macro(); + if (result) IO_Printf("%-50s - OK\n", "add_source_location_macro"); + else IO_Printf("%-50s - ERROR\n", "add_source_location_macro"); + } + + Array processes = {MA_GetAllocator(scratch)}; + if (ShouldRun("compilation")) { + // + // Test if things compile in C and C++ mode on all available compilers + // + S8_String working_dir = PushDir("targets"); + Array files = {MA_GetAllocator(scratch)}; + + files.add("../../../tests/compilation/test_compile_packed.c"); + files.add("../../../tests/compilation/test_compile_packed_cpp.c"); + files.add("../../../tests/compilation/test_compile_with_core.c"); + files.add("../../../tests/compilation/test_compile_with_core_cpp.cpp"); + files.add("../../../tests/compilation/test_compile_header.cpp"); + files.add("../../../tools/lcompile.c"); + + For(files) { + S8_String name_no_ext = S8_GetNameNoExt(it); + S8_String exe = Fmt("%.*s.exe", S8_Expand(name_no_ext)); + S8_String file_to_compile = it; + bool is_cpp = S8_EndsWith(it, ".cpp"); + + if (UseCL) { + S8_String cc = "cl"; + + Array flags = {MA_GetAllocator(scratch)}; + flags += "/Zi -D_CRT_SECURE_NO_WARNINGS"; + flags += "/FC /WX /W3 /wd4200 /diagnostics:column /nologo"; + flags += Fmt("/Fe:%.*s /Fd:%.*s.pdb", S8_Expand(exe), S8_Expand(name_no_ext)); + + Array link = {MA_GetAllocator(scratch)}; + link += "/link /incremental:no"; + + S8_String dir = Fmt("%.*s_cl_debug_" OS_NAME, S8_Expand(name_no_ext)); + Process p = RunEx(cc + file_to_compile + flags, dir); + processes.add(p); + } + + if (UseClang) { + S8_String cc = "clang"; + + Array flags = {MA_GetAllocator(scratch)}; + flags += "-g -Wno-write-strings"; + flags += "-fdiagnostics-absolute-paths"; + flags += "-fsanitize=address"; + if (is_cpp) flags += "-std=c++11"; + IF_LINUX(flags += "-lm";) + flags += Fmt("-o %.*s", S8_Expand(exe)); + + S8_String dir = Fmt("%.*s_clang_debug_" OS_NAME, S8_Expand(name_no_ext)); + Process p = RunEx(cc + file_to_compile + flags, dir); + processes.add(p); + } + + if (UseGCC) { + S8_String cc = "gcc"; + + Array flags = {MA_GetAllocator(scratch)}; + flags += "-g -Wno-write-strings"; + flags += "-fsanitize=address"; + if (is_cpp) flags += "-std=c++11"; + IF_LINUX(flags += "-lm";) + flags += Fmt("-o %.*s", S8_Expand(exe)); + + S8_String dir = Fmt("%.*s_gcc_debug_" OS_NAME, S8_Expand(name_no_ext)); + Process p = RunEx(cc + file_to_compile + flags, dir); + processes.add(p); + } + } + OS_SetWorkingDir(working_dir); + } + + RunTests(); + + // + // Wait for compilation from before tests to finish + // + int result = 0; + For(processes) { + int exit_code = Wait(&it); + if (exit_code != 0) result = exit_code; + } + + return result; +} diff --git a/examples/add_dynamic_array_macro/build.cpp b/examples/add_dynamic_array_macro/build.cpp new file mode 100644 index 0000000..e5cc626 --- /dev/null +++ b/examples/add_dynamic_array_macro/build.cpp @@ -0,0 +1,173 @@ +bool add_dynamic_array_macro() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("add_dynamic_array_macro"); + LC_ParsePackagesUsingRegistry(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + Array array_of_to_gen = {MA_GetAllocator(L->arena)}; + + LC_Intern init_array = LC_ILit("init_array"); + LC_AST *init_array_ast = LC_ParseStmtf("{ init_array_base(REF, SIZE, sizeof(REF.data[0])); }"); + LC_AST *init_array_add_ast = LC_ParseStmtf("{ REF.data[REF.len] = ITEM; REF.len += 1; }"); + + LC_Intern add = LC_ILit("add"); + LC_AST *add_ast = LC_ParseStmtf( + "{" + " try_growing_array(REF, sizeof(REF.data[0]));" + " REF.data[REF.len] = ITEM;" + " REF.len += 1;" + "}"); + LC_Intern ITEM = LC_ILit("ITEM"); + LC_Intern REF = LC_ILit("REF"); + + LC_AST *package = LC_GetPackageByName(name); + LC_AST *first_ast = (LC_AST *)L->ast_arena->memory.data; + for (int i = 0; i < L->ast_count; i += 1) { + LC_AST *it = first_ast + i; + + // Detect and save to array every unique use of 'ArrayOfT' + if (it->kind == LC_ASTKind_TypespecIdent) { + S8_String name = S8_MakeFromChar((char *)it->eident.name); + if (S8_StartsWith(name, "ArrayOf")) { + S8_String s8 = S8_Skip(name, S8_Lit("ArrayOf").len); + LC_Intern type = LC_InternStrLen(s8.str, (int)s8.len); + + bool is_unique = true; + For2(in_array, array_of_to_gen) { + if (in_array == type) { + is_unique = false; + break; + } + } + + if (is_unique) array_of_to_gen.add(type); + } + } + + if (it->kind == LC_ASTKind_StmtExpr && it->sexpr.expr->kind == LC_ASTKind_ExprCall) { + LC_AST *name = it->sexpr.expr->ecompo.name; + LC_AST *call = it->sexpr.expr; + + if (name->kind != LC_ASTKind_ExprIdent) { + continue; + } + + if (name->eident.name == add) { + if (call->ecompo.size != 2) { + LC_ReportASTError(call, "wrong argument count in macro call"); + continue; + } + LC_AST *first_item = call->ecompo.first; + LC_AST *arr_ref = first_item->ecompo_item.expr; + LC_AST *item = first_item->next->ecompo_item.expr; + + LC_AST *macro = LC_CopyAST(L->arena, add_ast); + LC_ASTArray array = LC_FlattenAST(L->arena, macro); + + for (int m_i = 0; m_i < array.len; m_i += 1) { + LC_AST *m_it = array.data[m_i]; + if (m_it->kind == LC_ASTKind_ExprIdent) { + if (m_it->eident.name == ITEM) { + *m_it = *LC_CopyAST(L->arena, item); + } else if (m_it->eident.name == REF) { + *m_it = *LC_CopyAST(L->arena, arr_ref); + } + } + m_it->pos = it->pos; + } + + macro->next = it->next; + macro->prev = it->prev; + *it = *macro; + } + + if (name->eident.name == init_array) { + if (call->ecompo.size != 2) { + LC_ReportASTError(call, "wrong argument count in macro call"); + continue; + } + + LC_AST *first_item = call->ecompo.first; + LC_AST *arr_ref = first_item->ecompo_item.expr; + LC_AST *item = first_item->next->ecompo_item.expr; + + if (item->kind != LC_ASTKind_ExprCompound) { + LC_ReportASTError(item, "expected compound"); + continue; + } + + LC_AST *macro = LC_CopyAST(L->arena, init_array_ast); + LC_ASTArray array = LC_FlattenAST(L->arena, macro); + for (int m_i = 0; m_i < array.len; m_i += 1) { + LC_AST *m_it = array.data[m_i]; + if (m_it->kind != LC_ASTKind_ExprIdent) continue; + + if (m_it->eident.name == LC_ILit("SIZE")) { + // This is a bit dangerous here because through + // this call we are bumping L->ast_count += 1 + *m_it = *LC_CreateAST(item->pos, LC_ASTKind_ExprInt); + m_it->eatom.i = LC_Bigint_u64(item->ecompo.size); + } else if (m_it->eident.name == REF) { + *m_it = *LC_CopyAST(L->arena, arr_ref); + } + m_it->pos = it->pos; + } + + LC_ASTFor(item_it, item->ecompo.first) { + LC_AST *init_item = LC_CopyAST(L->arena, init_array_add_ast); + LC_ASTArray array = LC_FlattenAST(L->arena, init_item); + for (int m_i = 0; m_i < array.len; m_i += 1) { + LC_AST *m_it = array.data[m_i]; + + if (m_it->kind == LC_ASTKind_ExprIdent) { + if (m_it->eident.name == ITEM) { + *m_it = *LC_CopyAST(L->arena, item_it->ecompo_item.expr); + } else if (m_it->eident.name == REF) { + *m_it = *LC_CopyAST(L->arena, arr_ref); + } + } + m_it->pos = name->pos; + } + + LC_DLLAdd(macro->sblock.first, macro->sblock.last, init_item); + } + + macro->next = it->next; + macro->prev = it->prev; + *it = *macro; + } + } + } + + // @todo: take package into consideration, my current idea is to have a shared package + // that is going to be imported into every other package, for now we use only the current package + For(array_of_to_gen) { + LC_AST *ast = LC_ParseDeclf("ArrayOf%s :: struct { data: *%s; len: int; cap: int; }", (char *)it, (char *)it); + LC_AST *file = package->apackage.ffile; + + LC_DLLAdd(file->afile.fdecl, file->afile.ldecl, ast); + } + + LC_OrderAndResolveTopLevelDecls(name); + LC_ResolveAllProcBodies(); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + LC_String code = LC_GenerateUnityBuild(L->ordered_packages); + OS_MakeDir("examples/add_dynamic_array_macro"); + OS_WriteFile("examples/add_dynamic_array_macro/add_dynamic_array_macro.c", code); + + return true; +} \ No newline at end of file diff --git a/examples/add_dynamic_array_macro/main.lc b/examples/add_dynamic_array_macro/main.lc new file mode 100644 index 0000000..c9a9244 --- /dev/null +++ b/examples/add_dynamic_array_macro/main.lc @@ -0,0 +1,64 @@ +import "libc"; + +try_growing_array :: proc(arrp: *void, element_size: size_t) { + arr: *ArrayOfvoid = arrp; + if (arr.len + 1 > arr.cap) { + cap := arr.cap * 2; + if (cap == 0) cap = 16; + + arr.data = realloc(arr.data, element_size * :size_t(cap)); + arr.cap = cap; + } +} + +init_array_base :: proc(arrp: *void, size: int, element_size: size_t) { + arr: *ArrayOfvoid = arrp; + arr.data = malloc(element_size * :size_t(size * 2)); + arr.len = size * 2; +} + +main :: proc(): int { + { + arr: ArrayOfint; + init_array(&arr, {0, 1, 2, 3, 4, 6, 7, 9, 10}); + for i := 0; i < 10; i += 1 { + assert(arr.data[i] == i); + } + + + + for it := &arr.data[0]; it < &arr.data[arr.len]; it = &it[1] { + + } + } + + { + arr: ArrayOfint; + + for i := 0; i < 128; i += 1 { + add(&arr, i); + } + + for i := 0; i < 128; i += 1 { + assert(arr.data[i] == i); + } + } + + + { + arr: ArrayOffloat; + + for i: float = 0; i < 128; i += 1 { + add(&arr, i); + } + + for i := 0; i < 128; i += 1 { + i0 := :int(arr.data[i]); + assert(i0 == i); + } + + } + + + return 0; +} \ No newline at end of file diff --git a/examples/add_instrumentation/build.cpp b/examples/add_instrumentation/build.cpp new file mode 100644 index 0000000..ed5f20b --- /dev/null +++ b/examples/add_instrumentation/build.cpp @@ -0,0 +1,62 @@ +bool OnDeclParsed_AddInstrumentation(bool discard, LC_AST *n) { + if (discard) return discard; + + if (n->kind == LC_ASTKind_DeclProc && n->dproc.body) { + if (n->dbase.name == LC_ILit("BeginProc")) return false; + if (n->dbase.name == LC_ILit("EndProc")) return false; + + LC_AST *body = n->dproc.body; + + LC_AST *begin = LC_ParseStmtf("BeginProc(\"%s\", \"%s\", %d)", n->dbase.name, n->pos->lex->file, n->pos->line); + LC_AST *end = LC_ParseStmtf("defer EndProc();"); + + LC_DLLAddFront(body->sblock.first, body->sblock.last, end); + LC_DLLAddFront(body->sblock.first, body->sblock.last, begin); + } + return discard; +} + +bool add_instrumentation() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + lang->on_decl_parsed = OnDeclParsed_AddInstrumentation; + LC_LangBegin(lang); + + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("add_instrumentation"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + DebugVerifyAST(packages); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + S8_String code = LC_GenerateUnityBuild(packages); + S8_String path = "examples/add_instrumentation/add_instrumentation.c"; + OS_MakeDir("examples"); + OS_MakeDir("examples/add_instrumentation"); + OS_WriteFile(path, code); + if (!UseCL) { + LC_LangEnd(lang); + return true; + } + + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/add_instrumentation/a.pdb -Fe:examples/add_instrumentation/add_instrumentation.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + int errcode = Run(cmd); + if (errcode != 0) { + LC_LangEnd(lang); + return false; + } + // Run("examples/add_instrumentation/add_instrumentation.exe"); + + LC_LangEnd(lang); + return true; +} \ No newline at end of file diff --git a/examples/add_instrumentation/main.lc b/examples/add_instrumentation/main.lc new file mode 100644 index 0000000..bee6dcb --- /dev/null +++ b/examples/add_instrumentation/main.lc @@ -0,0 +1,13 @@ +import c "libc"; + +BeginProc :: proc(func: *char, file: *char, line: int) { + c.printf("begin timming proc: %s at %s:%d\n", func, file, line); +} + +EndProc :: proc() { + c.printf("end timming proc\n"); +} + +main :: proc(): int { + return 0; +} \ No newline at end of file diff --git a/examples/add_printf_format_check/build.cpp b/examples/add_printf_format_check/build.cpp new file mode 100644 index 0000000..e88b9f4 --- /dev/null +++ b/examples/add_printf_format_check/build.cpp @@ -0,0 +1,56 @@ +void OnExprResolved_CheckPrintf(LC_AST *n, LC_Operand *op); + +bool add_printf_format_check() { + bool result = false; + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + lang->user_data = (void *)&result; + lang->on_expr_resolved = OnExprResolved_CheckPrintf; + lang->on_message = LC_IgnoreMessage; + LC_LangBegin(lang); + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("add_printf_format_check"); + LC_ResolvePackageByName(name); + + LC_LangEnd(lang); + return result; +} + +void OnExprResolved_CheckPrintf(LC_AST *n, LC_Operand *op) { + if (n->kind == LC_ASTKind_ExprCall) { + LC_AST *name = n->ecompo.name; + if (name->kind == LC_ASTKind_ExprIdent) { + LC_Decl *decl = name->eident.resolved_decl; + if (decl->name == LC_ILit("printf")) { + LC_ResolvedCompo *items = n->ecompo.resolved_items; + LC_AST *string = items->first->expr; + IO_Assert(string->kind == LC_ASTKind_ExprString); + + char *c = (char *)string->eatom.name; + LC_ResolvedCompoItem *item = items->first->next; + for (int i = 0; c[i]; i += 1) { + if (c[i] == '%') { + if (item == NULL) { + LC_ReportASTError(n, "too few arguments passed"); + + // Test reports success if error thrown correctly + *(bool *)L->user_data = true; + return; + } + if (c[i + 1] == 'd') { + if (item->expr->type != L->tint) LC_ReportASTError(item->expr, "expected int type"); + item = item->next; + } else if (c[i + 1] == 's') { + if (item->expr->type != L->tpchar) LC_ReportASTError(item->expr, "expected *char type"); + item = item->next; + } + } + } + if (item != NULL) LC_ReportASTError(item->expr, "too many arguments passed"); + } + } + } +} diff --git a/examples/add_printf_format_check/main.lc b/examples/add_printf_format_check/main.lc new file mode 100644 index 0000000..90fe92c --- /dev/null +++ b/examples/add_printf_format_check/main.lc @@ -0,0 +1,6 @@ +import "libc"; + +main :: proc(): int { + printf("testing %d %s %d\n", 32, "str"); + return 0; +} \ No newline at end of file diff --git a/examples/add_source_location_macro/build.cpp b/examples/add_source_location_macro/build.cpp new file mode 100644 index 0000000..29c41b3 --- /dev/null +++ b/examples/add_source_location_macro/build.cpp @@ -0,0 +1,48 @@ +/* This function is called after compiler determined procedure type but +** before the arguments got verified. This opens up a window for call manipulation. +** +** I basically swoop in and add the {file, line} information to the call LC_AST before +** the arguments get resolved. +*/ +void ModifyCallsDuringResolution(LC_AST *n, LC_Type *type) { + LC_TypeMember *tm = type->tproc.args.last; + if (tm && tm->type->kind == LC_TypeKind_Struct && tm->type->decl->name == LC_ILit("SourceLoc")) { + LC_AST *call_item = LC_CreateAST(n->pos, LC_ASTKind_ExprCallItem); + call_item->ecompo_item.name = LC_ILit("source_loc"); + call_item->ecompo_item.expr = LC_ParseExprf("{\"%s\", %d}", n->pos->lex->file, n->pos->line); + LC_SetASTPosOnAll(call_item->ecompo_item.expr, n->pos); + + LC_DLLAdd(n->ecompo.first, n->ecompo.last, call_item); + n->ecompo.size += 1; + } +} + +bool add_source_location_macro() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + lang->before_call_args_resolved = ModifyCallsDuringResolution; + LC_LangBegin(lang); + LC_RegisterPackageDir("../examples/"); + LC_RegisterPackageDir("../pkgs"); + + LC_Intern name = LC_ILit("add_source_location_macro"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + S8_String dir = "examples/add_source_location_macro"; + OS_MakeDir(dir); + S8_String cfile = "examples/add_source_location_macro/add_source_location_macro.c"; + S8_String code = LC_GenerateUnityBuild(packages); + OS_WriteFile(cfile, code); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + LC_LangEnd(lang); + return true; +} \ No newline at end of file diff --git a/examples/add_source_location_macro/main.lc b/examples/add_source_location_macro/main.lc new file mode 100644 index 0000000..e4634cf --- /dev/null +++ b/examples/add_source_location_macro/main.lc @@ -0,0 +1,16 @@ +import "libc"; + +SourceLoc :: struct { + file: String; + line: int; +} + +Allocate :: proc(size: int, source_loc: SourceLoc = {}): *void { + printf("%.*s:%d\n", source_loc.file.len, source_loc.file.str, source_loc.line); + return malloc(:size_t(size)); +} + +main :: proc(): int { + value: *int = Allocate(32); + return 0; +} \ No newline at end of file diff --git a/examples/create_raylib_window/build.cpp b/examples/create_raylib_window/build.cpp new file mode 100644 index 0000000..8fd4daf --- /dev/null +++ b/examples/create_raylib_window/build.cpp @@ -0,0 +1,30 @@ +bool create_raylib_window() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + LC_RegisterPackageDir("../examples/"); + LC_RegisterPackageDir("../pkgs"); + + LC_Intern name = LC_ILit("create_raylib_window"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + OS_MakeDir("examples/create_raylib_window"); + S8_String path = "examples/create_raylib_window/create_raylib_window.c"; + S8_String code = LC_GenerateUnityBuild(packages); + OS_WriteFile(path, code); + + bool success = true; + if (UseCL) { + OS_CopyFile(RaylibDLL, "examples/create_raylib_window/raylib.dll", true); + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/create_raylib_window/a.pdb -Fe:examples/create_raylib_window/create_raylib_window.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + int errcode = Run(cmd); + if (errcode != 0) success = false; + } + + return success; +} \ No newline at end of file diff --git a/examples/create_raylib_window/main.lc b/examples/create_raylib_window/main.lc new file mode 100644 index 0000000..fa5c3b1 --- /dev/null +++ b/examples/create_raylib_window/main.lc @@ -0,0 +1,16 @@ +import RL "raylib"; + +main :: proc(): int { + RL.InitWindow(800, 600, "Thing"); + RL.SetTargetFPS(60); + + for !RL.WindowShouldClose() { + RL.BeginDrawing(); + RL.ClearBackground(RL.RAYWHITE); + RL.DrawText("Congrats! You created your first window!", 190, 200, 20, RL.LIGHTGRAY); + RL.EndDrawing(); + } + + RL.CloseWindow(); + return 0; +} \ No newline at end of file diff --git a/examples/generate_type_info/build.cpp b/examples/generate_type_info/build.cpp new file mode 100644 index 0000000..d5a3be3 --- /dev/null +++ b/examples/generate_type_info/build.cpp @@ -0,0 +1,64 @@ +bool generate_type_info() { + OS_DeleteFile("../examples/generate_type_info/generated.lc"); + + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("generate_type_info"); + + LC_ParsePackagesUsingRegistry(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + LC_OrderAndResolveTopLevelDecls(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + LC_BeginStringGen(L->arena); + LC_AST *package = LC_GetPackageByName(name); + + // Iterate through all the types and generate struct member information + LC_Type *first = (LC_Type *)L->type_arena->memory.data; + for (int i = 0; i < L->type_count; i += 1) { + LC_Type *type = first + i; + if (type->kind != LC_TypeKind_Struct) continue; + + LC_GenLinef("%s_Members := :[]StructMem{", (char *)type->decl->name); + L->printer.indent += 1; + + LC_TypeFor(it, type->tagg.mems.first) { + LC_GenLinef("{name = \"%s\", offset = %d},", (char *)it->name, it->offset); + } + + L->printer.indent -= 1; + LC_GenLinef("};"); + } + + S8_String code = LC_EndStringGen(L->arena); + S8_String path = OS_GetAbsolutePath(L->arena, "../examples/generate_type_info/generated.lc"); + OS_WriteFile(path, code); + + LC_ParseFile(package, path.str, code.str, 0); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + // Resolve decls again with new content added in + LC_OrderAndResolveTopLevelDecls(name); + LC_ResolveAllProcBodies(); + LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls(); + + bool result = L->errors ? false : true; + LC_LangEnd(lang); + return result; +} \ No newline at end of file diff --git a/examples/generate_type_info/generated.lc b/examples/generate_type_info/generated.lc new file mode 100644 index 0000000..1aad15a --- /dev/null +++ b/examples/generate_type_info/generated.lc @@ -0,0 +1,13 @@ + +StructMem_Members := :[]StructMem{ + {name = "name", offset = 0}, + {name = "offset", offset = 8}, +}; +Typeinfo_Members := :[]StructMem{ + {name = "kind", offset = 0}, + {name = "name", offset = 8}, + {name = "size", offset = 16}, + {name = "align", offset = 20}, + {name = "child_count", offset = 24}, + {name = "struct_mems", offset = 32}, +}; \ No newline at end of file diff --git a/examples/generate_type_info/main.lc b/examples/generate_type_info/main.lc new file mode 100644 index 0000000..d8b8c31 --- /dev/null +++ b/examples/generate_type_info/main.lc @@ -0,0 +1,19 @@ +TypeKind :: typedef int; +TYPE_KIND_STRUCT :: 0; + +StructMem :: struct { + name: *char; + offset: int; +} + +Typeinfo :: struct { + kind: TypeKind; + name: *char; + + size: int; + align: int; + + child_count: int; + struct_mems: *StructMem; +} + diff --git a/examples/hello_world/build.cpp b/examples/hello_world/build.cpp new file mode 100644 index 0000000..836e46d --- /dev/null +++ b/examples/hello_world/build.cpp @@ -0,0 +1,29 @@ +bool hello_world() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + LC_RegisterPackageDir("../examples/"); + LC_RegisterPackageDir("../pkgs"); + + LC_Intern name = LC_ILit("hello_world"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + OS_MakeDir("examples/hello_world"); + S8_String code = LC_GenerateUnityBuild(packages); + S8_String path = "examples/hello_world/hello_world.c"; + OS_WriteFile(path, code); + + bool success = true; + if (UseCL) { + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/hello_world/hello_world.pdb -Fe:examples/hello_world/hello_world.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + if (Run(cmd) != 0) success = false; + } + + LC_LangEnd(lang); + return success; +} \ No newline at end of file diff --git a/examples/hello_world/main.lc b/examples/hello_world/main.lc new file mode 100644 index 0000000..31d6396 --- /dev/null +++ b/examples/hello_world/main.lc @@ -0,0 +1,6 @@ +import "libc"; + +main :: proc(): int { + printf("hello world!\n"); + return 0; +} \ No newline at end of file diff --git a/examples/pathfinding_visualizer/array.lc b/examples/pathfinding_visualizer/array.lc new file mode 100644 index 0000000..75c5afa --- /dev/null +++ b/examples/pathfinding_visualizer/array.lc @@ -0,0 +1,147 @@ +AddActorToArray :: proc(arr: *ArrayOfActors, actor: Actor) { + if arr.len + 1 > arr.cap { + new_cap := arr.cap * 2; + if (new_cap == 0) new_cap = 16; + + arr.data = libc.realloc(arr.data, sizeof(:Actor) * :libc.size_t(new_cap)); + arr.cap = new_cap; + } + + arr.data[arr.len] = actor; + arr.len += 1; +} + +TryGrowingActorArray :: proc(a: *ArrayOfActors) { + if a.len + 1 > a.cap { + new_cap := a.cap * 2; + if (new_cap == 0) new_cap = 16; + a.data = libc.realloc(a.data, sizeof(:Actor) * :libc.size_t(new_cap)); + a.cap = new_cap; + } +} + +InsertActor :: proc(a: *ArrayOfActors, item: Actor, index: int) { + if index == a.len { + AddActorToArray(a, item); + return; + } + + Assert(index < a.len); + Assert(index >= 0); + + TryGrowingActorArray(a); + right_len := :libc.size_t(a.len - index); + libc.memmove(&a.data[index + 1], &a.data[index], sizeof(:Actor) * right_len); + a.data[index] = item; + a.len += 1; +} + +GetLastActor :: proc(a: ArrayOfActors): *Actor { + Assert(a.len > 0); + result := &a.data[a.len - 1]; + return result; +} + +// + +AddPath :: proc(arr: *ArrayOfPaths, actor: Path) { + if arr.len + 1 > arr.cap { + new_cap := arr.cap * 2; + if (new_cap == 0) new_cap = 16; + + arr.data = libc.realloc(arr.data, sizeof(:Path) * :libc.size_t(new_cap)); + arr.cap = new_cap; + } + + arr.data[arr.len] = actor; + arr.len += 1; +} + +TryGrowingPathArray :: proc(a: *ArrayOfPaths) { + if a.len + 1 > a.cap { + new_cap := a.cap * 2; + if (new_cap == 0) new_cap = 16; + a.data = libc.realloc(a.data, sizeof(:Path) * :libc.size_t(new_cap)); + a.cap = new_cap; + } +} + +InsertPath :: proc(a: *ArrayOfPaths, item: Path, index: int) { + if index == a.len { + AddPath(a, item); + return; + } + + Assert(index < a.len); + Assert(index >= 0); + + TryGrowingPathArray(a); + right_len := :libc.size_t(a.len - index); + libc.memmove(&a.data[index + 1], &a.data[index], sizeof(:Path) * right_len); + a.data[index] = item; + a.len += 1; +} + +InsertSortedPath :: proc(a: *ArrayOfPaths, item: Path) { + insert_index := -1; + for i := 0; i < a.len; i += 1 { + it := &a.data[i]; + if it.value_to_sort_by <= item.value_to_sort_by { + insert_index = i; + InsertPath(a, item, i); + break; + } + } + if insert_index == -1 { + AddPath(a, item); + } +} + +GetLastPath :: proc(a: ArrayOfPaths): *Path { + Assert(a.len > 0); + result := &a.data[a.len - 1]; + return result; +} + +PopPath :: proc(a: *ArrayOfPaths): Path { + a.len -= 1; + result := a.data[a.len]; + return result; +} + +// + +AddV2I :: proc(arr: *ArrayOfV2Is, item: V2I) { + if arr.len + 1 > arr.cap { + new_cap := arr.cap * 2; + if (new_cap == 0) new_cap = 16; + + arr.data = libc.realloc(arr.data, sizeof(:V2I) * :libc.size_t(new_cap)); + arr.cap = new_cap; + } + + arr.data[arr.len] = item; + arr.len += 1; +} + +// + +AddAnimationSetTile :: proc(arr: *ArrayOfAnimationSetTiles, item: AnimationSetTile) { + if arr.len + 1 > arr.cap { + new_cap := arr.cap * 2; + if (new_cap == 0) new_cap = 16; + + arr.data = libc.realloc(arr.data, sizeof(:AnimationSetTile) * :libc.size_t(new_cap)); + arr.cap = new_cap; + } + + arr.data[arr.len] = item; + arr.len += 1; +} + +UnorderedRemoveAnimationSetTile :: proc(a: *ArrayOfAnimationSetTiles, item: *AnimationSetTile) { + Assert(a.len > 0); + Assert(item >= a.data && item < &a.data[a.len]); + a.len -= 1; + *item = a.data[a.len]; +} diff --git a/examples/pathfinding_visualizer/build.cpp b/examples/pathfinding_visualizer/build.cpp new file mode 100644 index 0000000..ef0942b --- /dev/null +++ b/examples/pathfinding_visualizer/build.cpp @@ -0,0 +1,42 @@ +bool pathfinding_visualizer() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + + LC_RegisterPackageDir("../examples/"); + LC_RegisterPackageDir("../pkgs"); + + LC_Intern name = LC_ILit("pathfinding_visualizer"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls(); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + DebugVerifyAST(packages); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + OS_MakeDir("examples"); + OS_MakeDir("examples/pathfinding_visualizer"); + S8_String code = LC_GenerateUnityBuild(packages); + S8_String path = "examples/pathfinding_visualizer/pathfinding_visualizer.c"; + OS_WriteFile(path, code); + + if (!UseCL) { + LC_LangEnd(lang); + return true; + } + + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/pathfinding_visualizer/a.pdb -Fe:examples/pathfinding_visualizer/pathfinding_visualizer.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + int errcode = Run(cmd); + OS_CopyFile(RaylibDLL, "examples/pathfinding_visualizer/raylib.dll", true); + + LC_LangEnd(lang); + bool result = errcode == 0; + return result; +} \ No newline at end of file diff --git a/examples/pathfinding_visualizer/main.lc b/examples/pathfinding_visualizer/main.lc new file mode 100644 index 0000000..c135aec --- /dev/null +++ b/examples/pathfinding_visualizer/main.lc @@ -0,0 +1,266 @@ +import "raylib"; +import libc "libc"; +import "std_types"; + +WinX := 1280; +WinY := 720; +Mode := 0; +RectX :: 16; +RectY :: 16; +Dt: float; + +MouseX:= 0; +MouseY:= 0; +MouseP: Vector2 = {0, 0}; + +MouseSelecting := false; +MouseSelectionPivot: Vector2; +MouseSelectionBox: Rectangle; +MouseSelectedActors: ArrayOfActors; + +AnimationSetTiles: ArrayOfAnimationSetTiles; + +AnimationSetTile :: struct { + set: bool; + p: V2I; + t: float; +} + +ArrayOfAnimationSetTiles :: struct { + data: *AnimationSetTile; + len: int; + cap: int; +} + +main :: proc(): int { + InitMap(); + InitWindow(WinX, WinY, "pathfinding visualizer"); + SetTargetFPS(60); + + orange := ORANGE; + orange.a = 255/2; + brown := BROWN; + brown.a = 255/2; + dark_green := DARKGREEN; + dark_green.a = 255/2; + blue := BLUE; + blue.a = 255/2; + green := GREEN; + green.a = 255/2; + red := RED; + red.a = 255/2; + + actor_color := dark_green; + past_actor_color := blue; + target_color := red; + selection_box_color := green; + selected_color := selection_box_color; + + for !WindowShouldClose() { + WinX = GetScreenHeight(); + WinY = GetScreenWidth(); + MouseX = GetMouseX(); + MouseY = GetMouseY(); + MouseP = GetMousePosition(); + Dt = GetFrameTime(); + @unused map := &CurrentMap; + + MouseSelecting = false; + if IsMouseButtonDown(MOUSE_BUTTON_LEFT) { + MouseSelecting = true; + if IsMouseButtonPressed(MOUSE_BUTTON_LEFT) { + MouseSelectionPivot = MouseP; + } + + MouseSelectionBox = { + MouseSelectionPivot.x, + MouseSelectionPivot.y, + MouseP.x - MouseSelectionPivot.x, + MouseP.y - MouseSelectionPivot.y, + }; + + if MouseSelectionBox.width < 0 { + MouseSelectionBox.x += MouseSelectionBox.width; + MouseSelectionBox.width = -MouseSelectionBox.width; + } + if MouseSelectionBox.height < 0 { + MouseSelectionBox.y += MouseSelectionBox.height; + MouseSelectionBox.height = -MouseSelectionBox.height; + } + } + + if IsKeyPressed(KEY_F1) { + Mode = 0; + } + + if IsKeyPressed(KEY_F2) { + Mode = 1; + } + + if IsKeyPressed(KEY_F3) { + for i := 0; i < map.actors.len; i += 1 { + it := &map.actors.data[i]; + MoveTowardsTarget(it); + } + } + PathFindUpdate(map); + + if IsKeyPressed(KEY_F4) { + RandomizeActors(); + } + + BeginDrawing(); + ClearBackground(RAYWHITE); + + map_rectangle: Rectangle = {0, 0, :float(map.x) * RectX, :float(map.y) * RectY}; + DrawRectangleRec(map_rectangle, LIGHTGRAY); + + for x := 0; x < map.x; x += 1 { + for y := 0; y < map.y; y += 1 { + it := map.data[x + y*map.x]; + r : Rectangle = {:float(x) * RectX, :float(y) * RectY, RectX, RectY}; + r2: Rectangle = {r.x + 1, r.y + 1, r.width - 2, r.height - 2}; + + colliding := CheckCollisionPointRec(MouseP, r); + color := RAYWHITE; + if it == 1 { color = GRAY; } + + if Mode == 0 { + if colliding && IsMouseButtonDown(MOUSE_BUTTON_LEFT) { + AddAnimationSetTile(&AnimationSetTiles, {true, {x,y}}); + } + if colliding && IsMouseButtonDown(MOUSE_BUTTON_RIGHT) { + AddAnimationSetTile(&AnimationSetTiles, {false, {x,y}}); + } + if colliding { + color.a = 100; + } + } + + DrawRectangleRec(r2, color); + } + } + + for tile_i := 0; tile_i < AnimationSetTiles.len; tile_i += 1 { + tile_it := &AnimationSetTiles.data[tile_i]; + remove := false; + + t := tile_it.t; + if tile_it.set == false { + t = 1 - t; + } + + x := :float(tile_it.p.x) * RectX + 1; + y := :float(tile_it.p.y) * RectY + 1; + + w: float = RectX - 2; + h: float = RectY - 2; + wt := w * t; + ht := h * t; + wd := w - wt; + hd := h - ht; + + r: Rectangle = {x + wd/2, y + hd/2, wt, ht}; + DrawRectangleRec(r, GRAY); + + if tile_it.t > 1 { + map_tile := &map.data[tile_it.p.x + tile_it.p.y*map.x]; + if tile_it.set {*map_tile |= TILE_BLOCKER;} + else {*map_tile &= ~TILE_BLOCKER;} + + remove = true; + } + + tile_it.t += Dt*8; + if remove { + UnorderedRemoveAnimationSetTile(&AnimationSetTiles, tile_it); + tile_i -= 1; + } + } + + for actor_i := 0; actor_i < map.actors.len; actor_i += 1 { + actor_it := &map.actors.data[actor_i]; + target_r := Rect(actor_it.target_p); + + main_p := Circle(actor_it.p); + DrawCircleV(main_p, RectX/2, actor_color); + DrawRectangleRec(target_r, target_color); + + smaller_the_further: float; + for tile_i := actor_it.tiles_visited.len - 1; tile_i >= 0; tile_i -= 1 { + tile_it := &actor_it.tiles_visited.data[tile_i]; + p := Circle({tile_it.x, tile_it.y}); + DrawCircleV(p, RectX/2 - smaller_the_further, past_actor_color); + smaller_the_further += 0.5; + } + + for path_i := 0; path_i < actor_it.open_paths.len; path_i += 1 { + path_it := &actor_it.open_paths.data[path_i]; + path_r := Rect(path_it.p); + DrawRectangleRec(path_r, orange); + s := TextFormat("%d", :int(libc.sqrtf(:float(path_it.value_to_sort_by)))); + DrawText(s, :int(path_r.x), :int(path_r.y), 1, RAYWHITE); + } + + for path_i := 0; path_i < actor_it.close_paths.len; path_i += 1 { + path_it := &actor_it.close_paths.data[path_i]; + path_r := Rect(path_it.p); + DrawRectangleRec(path_r, brown); + } + + for path_i := 0; path_i < actor_it.history.len; path_i += 1 { + path_it := &actor_it.history.data[path_i]; + + p0 := Circle(path_it.came_from); + p1 := Circle(path_it.p); + + DrawLineEx(p0, p1, 5, LIGHTGRAY); + DrawCircleV(p0, 4, LIGHTGRAY); + DrawCircleV(p1, 4, LIGHTGRAY); + } + } + + if Mode == 1 { + for actor_i := 0; actor_i < MouseSelectedActors.len; actor_i += 1 { + actor_it := &MouseSelectedActors.data[actor_i]; + actor_box := Rect(actor_it.p); + DrawRectangleRec(actor_box, selected_color); + + if IsMouseButtonPressed(MOUSE_BUTTON_RIGHT) { + p := ScreenToMap(MouseP); + SetTargetP(actor_it, p); + } + } + + if MouseSelecting { + MouseSelectedActors.len = 0; + for actor_i := 0; actor_i < MouseSelectedActors.len; actor_i += 1 { + actor_it := &MouseSelectedActors.data[actor_i]; + actor_box := Rect(actor_it.p); + + if CheckCollisionRecs(actor_box, MouseSelectionBox) { + AddActorToArray(&MouseSelectedActors, *actor_it); + } + } + DrawRectangleRec(MouseSelectionBox, selection_box_color); + } + } + + text_size := 24; + text_p := 4; + text_y := text_size * 2; + + DrawText("F4 :: Randomize actors", text_p, text_y, text_size, GRAY); + text_y -= text_size; + DrawText("F3 :: Simulate actors", text_p, text_y, text_size, GRAY); + text_y -= text_size; + text: *char = "Mode(F1) :: Block placing"; + if Mode == 1 { text = "Mode(F2) :: Actor placing"; } + DrawText(text, text_p, text_y, text_size, GRAY); + text_y -= text_size; + + EndDrawing(); + } + + return 0; +} \ No newline at end of file diff --git a/examples/pathfinding_visualizer/map.lc b/examples/pathfinding_visualizer/map.lc new file mode 100644 index 0000000..86545c8 --- /dev/null +++ b/examples/pathfinding_visualizer/map.lc @@ -0,0 +1,286 @@ +CurrentMap: Map; + +Tile :: typedef int; +TILE_BLOCKER :: 1; +TILE_ACTOR_IS_STANDING :: <<; + +Map :: struct { + data: *Tile; + x: int; + y: int; + actors: ArrayOfActors; +} + +V2I :: struct { + x: int; + y: int; +} + +Actor :: struct { + p: V2I; + target_p: V2I; + map: *Map; + + open_paths: ArrayOfPaths; + close_paths: ArrayOfPaths; + tiles_visited: ArrayOfV2Is; + history: ArrayOfPaths; +} + +Path :: struct { + value_to_sort_by: int; + p: V2I; + came_from: V2I; +} + +ArrayOfActors :: struct { + data: *Actor; + len: int; + cap: int; +} + +ArrayOfPaths :: struct { + data: *Path; + len: int; + cap: int; +} + +ArrayOfV2Is :: struct { + data: *V2I; + len: int; + cap: int; +} + +Rect :: proc(p: V2I): Rectangle { + result: Rectangle = {:float(p.x) * RectX, :float(p.y) * RectY, RectX, RectY}; + return result; +} + +Circle :: proc(p: V2I): Vector2 { + result: Vector2 = {:float(p.x) * RectX + RectX/2, :float(p.y) * RectY + RectY/2}; + return result; +} + +ScreenToMap :: proc(p: Vector2): V2I { + x := p.x / RectX; + y := p.y / RectY; + + result: V2I = {:int(x), :int(y)}; + return result; +} + +MaxInt :: proc(x: int, y: int): int { + if x > y return x; + return y; +} + +Assert :: proc(x: bool) { + if (!x) { + libc.printf("assertion failed\n"); + libc.fflush(libc.stdout); + libc.debug_break(); + } +} + +InvalidCodepath :: proc() { + libc.printf("invalid codepath\n"); + libc.fflush(libc.stdout); + libc.debug_break(); +} + +AddActor :: proc(map: *Map, p: V2I): *Actor { + AddActorToArray(&map.actors, {p, p, map}); + map.data[p.x + p.y * map.x] |= TILE_ACTOR_IS_STANDING; + result := GetLastActor(map.actors); + return result; +} + +SetActorP :: proc(actor: *Actor, p: V2I) { + map := actor.map; + new_tile := &map.data[p.x + p.y * map.x]; + if *new_tile != 0 return; + + tile := &map.data[actor.p.x + actor.p.y * map.x]; + Assert((*tile & TILE_ACTOR_IS_STANDING) != 0); + *tile &= ~TILE_ACTOR_IS_STANDING; + + *new_tile |= TILE_ACTOR_IS_STANDING; + actor.p = p; + + actor.tiles_visited.len = 0; + actor.history.len = 0; + actor.open_paths.len = 0; + actor.close_paths.len = 0; +} + +SetTargetP :: proc(actor: *Actor, p: V2I) { + actor.target_p = p; + + actor.tiles_visited.len = 0; + actor.history.len = 0; + actor.open_paths.len = 0; + actor.close_paths.len = 0; +} + +GetRandomP :: proc(m: *Map): V2I { + result: V2I = {GetRandomInt(0, m.x - 1), GetRandomInt(0, m.y - 1)}; + return result; +} + +GetRandomUnblockedP :: proc(m: *Map): V2I { + for i := 0; i < 128; i += 1 { + p := GetRandomP(m); + if m.data[p.x + p.y * m.x] == 0 { + return p; + } + } + Assert(!:ullong(:*char("invalid codepath"))); + return {}; +} + +InitMap :: proc() { + CurrentMap.x = WinX / RectX; + CurrentMap.y = WinY / RectY; + + bytes := sizeof(:Tile) * CurrentMap.x * CurrentMap.y; + CurrentMap.data = libc.malloc(:libc.size_t(bytes)); + libc.memset(CurrentMap.data, 0, :libc.size_t(bytes)); + + actor := AddActor(&CurrentMap, GetRandomUnblockedP(&CurrentMap)); + actor.target_p = GetRandomUnblockedP(&CurrentMap); + + actor2 := AddActor(&CurrentMap, GetRandomUnblockedP(&CurrentMap)); + actor2.target_p = GetRandomUnblockedP(&CurrentMap); +} + +RandomizeActors :: proc() { + map := &CurrentMap; + for i := 0; i < map.actors.len; i += 1 { + it := &map.actors.data[i]; + p := GetRandomUnblockedP(&CurrentMap); + SetActorP(it, p); + it.target_p = GetRandomUnblockedP(&CurrentMap); + } +} + +InsertOpenPath :: proc(actor: *Actor, p: V2I, came_from: V2I, ignore_blocks: bool = false) { + if p.x < 0 || p.x >= actor.map.x return; + if p.y < 0 || p.y >= actor.map.y return; + if ignore_blocks == false && actor.map.data[p.x + p.y * actor.map.x] != 0 return; + + for i := 0; i < actor.close_paths.len; i += 1 { + it := &actor.close_paths.data[i]; + if it.p.x == p.x && it.p.y == p.y return; + } + + for i := 0; i < actor.open_paths.len; i += 1 { + it := &actor.open_paths.data[i]; + if it.p.x == p.x && it.p.y == p.y return; + } + + dx := actor.target_p.x - p.x; + dy := actor.target_p.y - p.y; + d := dx*dx + dy*dy; + InsertSortedPath(&actor.open_paths, {d, p, came_from}); +} + +GetCloseP :: proc(actor: *Actor, p: V2I): *Path { + for i := 0; i < actor.close_paths.len; i += 1 { + it := &actor.close_paths.data[i]; + if it.p.x == p.x && it.p.y == p.y return it; + } + InvalidCodepath(); + return nil; +} + +RecomputeHistory :: proc(actor: *Actor) { + if actor.close_paths.len > 1 { + actor.history.len = 0; + it := GetLastPath(actor.close_paths); + AddPath(&actor.history, *it); + for i := 0;;i += 1 { + if it.p.x == actor.p.x && it.p.y == actor.p.y { break; } + if i > 512 { actor.history.len = 0; break; } // @todo: Pop after this and error? + it = GetCloseP(actor, it.came_from); + AddPath(&actor.history, *it); + } + PopPath(&actor.history); + } +} + +MoveTowardsTarget :: proc(actor: *Actor) { + tile := &actor.map.data[actor.p.x + actor.p.y * actor.map.x]; + if actor.history.len > 0 { + step := PopPath(&actor.history); + new_tile := &actor.map.data[step.p.x + step.p.y * actor.map.x]; + if *new_tile == 0 { + AddV2I(&actor.tiles_visited, actor.p); + actor.p = step.p; + *tile &= ~TILE_ACTOR_IS_STANDING; + *new_tile |= TILE_ACTOR_IS_STANDING; + } + } +} + +PathFindUpdate :: proc(map: *Map) { + for actor_i := 0; actor_i < map.actors.len; actor_i += 1 { + actor_it := &map.actors.data[actor_i]; + for i := 0; i < actor_it.history.len; i += 1 { + history_it := &actor_it.history.data[i]; + + tile := actor_it.map.data[history_it.p.x + history_it.p.y * actor_it.map.x]; + if tile != 0 { + actor_it.close_paths.len = 0; + actor_it.open_paths.len = 0; + actor_it.history.len = 0; + break; + } + } + PathFind(actor_it); + } +} + +PathFindStep :: proc(s: *Actor, compute_history: bool = true): bool { + if s.open_paths.len == 0 { + // Reset if we didn't find solution + if s.close_paths.len != 0 { + last := GetLastPath(s.close_paths); + reached_target := last.p.x == s.target_p.x && last.p.y == s.target_p.y; + if reached_target == false { + s.close_paths.len = 0; + s.open_paths.len = 0; + s.history.len = 0; + } + } + + InsertOpenPath(s, s.p, s.p, ignore_blocks = true); + } + + if s.close_paths.len != 0 { + last := GetLastPath(s.close_paths); + reached_target := last.p.x == s.target_p.x && last.p.y == s.target_p.y; + if reached_target return true; + } + + it := PopPath(&s.open_paths); + AddPath(&s.close_paths, it); + + for y := -1; y <= 1; y += 1 { + for x := -1; x <= 1; x += 1 { + if x == 0 && y == 0 continue; + p: V2I = {it.p.x + x, it.p.y + y}; + InsertOpenPath(s, p, it.p); + } + } + + if compute_history RecomputeHistory(s); + return false; +} + +PathFind :: proc(actor: *Actor) { + for i := 0; i < 32; i += 1 { + done := PathFindStep(actor, false); + if done break; + } + RecomputeHistory(actor); +} \ No newline at end of file diff --git a/examples/pathfinding_visualizer/random.lc b/examples/pathfinding_visualizer/random.lc new file mode 100644 index 0000000..de9cafe --- /dev/null +++ b/examples/pathfinding_visualizer/random.lc @@ -0,0 +1,22 @@ +RandomSeedValue: RandomSeed = {121521923492}; +RandomSeed :: struct { + a: u64; +} + +GetRandomU64 :: proc(s: *RandomSeed): u64 { + x := s.a; + x ^= x << 13; + x ^= x >> 7; + x ^= x << 17; + s.a = x; + return x; +} + +GetRandomInt :: proc(min: int, max: int): int { + random := GetRandomU64(&RandomSeedValue); + range_size: u64 = :u64(max - min) + 1; + + result := :int(random % range_size); + result = result + min; + return result; +} diff --git a/examples/sandbox/arena.lc b/examples/sandbox/arena.lc new file mode 100644 index 0000000..3e61ddd --- /dev/null +++ b/examples/sandbox/arena.lc @@ -0,0 +1,68 @@ +import "std_types"; +import libc "libc"; + +PAGE_SIZE :: 4096; + +Arena :: struct { + data: *u8; + len: usize; + commit: usize; + reserve: usize; + alignment: usize; +} + +GetAlignOffset :: proc(size: usize, align: usize): usize { + mask: usize = align - 1; + val: usize = size & mask; + if val { + val = align - val; + } + return val; +} + +AlignUp :: proc(size: usize, align: usize): usize { + result := size + GetAlignOffset(size, align); + return result; +} + +InitArena :: proc(arena: *Arena, reserve: usize) { + aligned_reserve := AlignUp(reserve, PAGE_SIZE); + data := VReserve(aligned_reserve); + libc.assert(data != nil); + + if data { + arena.data = data; + arena.reserve = aligned_reserve; + arena.alignment = 8; + } +} + +PushSize :: proc(arena: *Arena, size: usize): *void { + libc.assert(arena.data != nil); + + pointer := :usize(arena.data) + arena.len + size; + align := GetAlignOffset(pointer, arena.alignment); + aligned_size := size + align; + + a := arena.len + aligned_size; + if a > arena.commit { + diff := a - arena.commit; + commit_size := AlignUp(diff, PAGE_SIZE*4); + libc.assert(commit_size + arena.commit <= arena.reserve); + + if VCommit(&arena.data[arena.commit], commit_size) { + arena.commit += commit_size; + } else { + libc.assert(false && "commit failed"[0]); + } + } + + arena.len += align; + result: *void = &arena.data[arena.len]; + arena.len += size; + return result; +} + +TestArena :: proc() { + arena: Arena; +} \ No newline at end of file diff --git a/examples/sandbox/arena_win32.lc b/examples/sandbox/arena_win32.lc new file mode 100644 index 0000000..2dd476d --- /dev/null +++ b/examples/sandbox/arena_win32.lc @@ -0,0 +1,28 @@ +#build_if(LC_OS == OS_WINDOWS); + +DWORD :: typedef u32; +SIZE_T :: typedef uintptr; +BOOL :: typedef int; + +MEM_RESERVE :: 0x00002000; +MEM_COMMIT :: 0x00001000; +PAGE_READWRITE :: 0x04; +VirtualAlloc :: proc(lpAddress: *void, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD): *void; @api + +MEM_RELEASE :: 0x00008000; +MEM_DECOMMIT :: 0x00004000; +VirtualFree :: proc(lpAddress: *void, dwSize: SIZE_T, dwFreeType: DWORD): BOOL; @api + +VReserve :: proc(size: usize): *void { + result := VirtualAlloc(nil, :SIZE_T(size), MEM_RESERVE, PAGE_READWRITE); + return result; +} + +VCommit :: proc(p: *void, size: usize): bool { + result := VirtualAlloc(p, :SIZE_T(size), MEM_COMMIT, PAGE_READWRITE) != 0; + return result; +} + +VRelease :: proc(p: *void) { + VirtualFree(p, 0, MEM_RELEASE); +} \ No newline at end of file diff --git a/examples/sandbox/build.cpp b/examples/sandbox/build.cpp new file mode 100644 index 0000000..35ad1c2 --- /dev/null +++ b/examples/sandbox/build.cpp @@ -0,0 +1,121 @@ +namespace Sandbox { +Array TypesToGen; + +void RegisterMarkedTypes(LC_AST *n) { + if (n->kind == LC_ASTKind_TypespecIdent) { + S8_String name = S8_MakeFromChar((char *)n->eident.name); + S8_String array_of = "ArrayOf"; + if (S8_StartsWith(name, array_of)) { + if (name == "ArrayOfName") return; + + name = S8_Skip(name, array_of.len); + LC_Intern intern = LC_InternStrLen(name.str, (int)name.len); + + bool exists = false; + For(TypesToGen) { + if (intern == it) { + exists = true; + break; + } + } + if (!exists) { + TypesToGen.add(intern); + } + } + } +} + +void WalkAndRename(LC_ASTWalker *ctx, LC_AST *n) { + LC_Intern *p = NULL; + if (n->kind == LC_ASTKind_TypespecIdent || n->kind == LC_ASTKind_ExprIdent) { + p = &n->eident.name; + } + if (LC_IsDecl(n)) { + p = &n->dbase.name; + } + + if (p) { + LC_Intern user = *(LC_Intern *)ctx->user_data; + S8_String p8 = S8_MakeFromChar((char *)*p); + + if (S8_Seek(p8, "Name")) { + S8_String new_name = S8_ReplaceAll(L->arena, p8, "Name", S8_MakeFromChar((char *)user)); + *p = LC_InternStrLen(new_name.str, (int)new_name.len); + } + } +} + +void BeforeCallArgsResolved(LC_AST *n, LC_Type *type) { +} + +} // namespace Sandbox + +bool sandbox() { + using namespace Sandbox; + + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + lang->on_typespec_parsed = RegisterMarkedTypes; + lang->before_call_args_resolved = BeforeCallArgsResolved; + LC_LangBegin(lang); + + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("sandbox"); + LC_ParsePackagesUsingRegistry(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + TypesToGen.allocator = MA_GetAllocator(lang->arena); + + // + // Remove dynamic array file + // + LC_AST *package = LC_GetPackageByName(name); + LC_AST *dynamic_array_file = NULL; + LC_ASTFor(it, package->apackage.ffile) { + S8_String path = S8_MakeFromChar((char *)it->afile.x->file); + if (S8_EndsWith(path, "dynamic_array.lc")) { + dynamic_array_file = it; + DLL_QUEUE_REMOVE(package->apackage.ffile, package->apackage.lfile, it); + break; + } + } + + // Generate copies + LC_ASTWalker walker = LC_GetDefaultWalker(L->arena, WalkAndRename); + For(TypesToGen) { + LC_AST *new_array_file = LC_CopyAST(L->arena, dynamic_array_file); + + walker.user_data = (void *)⁢ + LC_WalkAST(&walker, new_array_file); + LC_DLLAdd(package->apackage.ffile, package->apackage.lfile, new_array_file); + } + + LC_OrderAndResolveTopLevelDecls(name); + LC_ResolveAllProcBodies(); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + S8_String code = LC_GenerateUnityBuild(L->ordered_packages); + S8_String path = "examples/sandbox/sandbox.c"; + + OS_MakeDir("examples/sandbox"); + OS_WriteFile(path, code); + LC_LangEnd(lang); + + if (UseCL) { + OS_CopyFile(RaylibDLL, "examples/sandbox/raylib.dll", true); + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/sandbox/a.pdb -Fe:examples/sandbox/sandbox.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + int errcode = Run(cmd); + if (errcode != 0) return false; + } + + return true; +} \ No newline at end of file diff --git a/examples/sandbox/common.lc b/examples/sandbox/common.lc new file mode 100644 index 0000000..2a00b21 --- /dev/null +++ b/examples/sandbox/common.lc @@ -0,0 +1,96 @@ +FloatMin :: proc(a: float, b: float): float { + if (a > b) return b; + return a; +} + +FloatMax :: proc(a: float, b: float): float { + if (a > b) return a; + return a; +} + +FloatClamp :: proc(val: float, min: float, max: float): float { + if (val > max) return max; + if (val < min) return min; + return val; +} + +IntMin :: proc(a: int, b: int): int { + if (a > b) return b; + return a; +} + +IntMax :: proc(a: int, b: int): int { + if (a > b) return a; + return a; +} + +IntClamp :: proc(val: int, min: int, max: int): int { + if (val > max) return max; + if (val < min) return min; + return val; +} + +Rect2 :: struct { + min: Vector2; + max: Vector2; +} + +CutLeft :: proc(r: *Rect2, value: float): Rect2 { + minx := r.min.x; + r.min.x = FloatMin(r.max.x, r.min.x + value); + return :Rect2{ + { minx, r.min.y}, + {r.min.x, r.max.y}, + }; +} + +CutRight :: proc(r: *Rect2, value: float): Rect2 { + maxx := r.max.x; + r.max.x = FloatMax(r.max.x - value, r.min.x); + return :Rect2{ + {r.max.x, r.min.y}, + { maxx, r.max.y}, + }; +} + +CutBottom :: proc(r: *Rect2, value: float): Rect2 { // Y is down + maxy := r.max.y; + r.max.y = FloatMax(r.min.y, r.max.y - value); + return :Rect2{ + {r.min.x, r.max.y}, + {r.max.x, maxy}, + }; +} + +CutTop :: proc(r: *Rect2, value: float): Rect2 { // Y is down + miny := r.min.y; + r.min.y = FloatMin(r.min.y + value, r.max.y); + return :Rect2{ + {r.min.x, miny}, + {r.max.x, r.min.y}, + }; +} + +Shrink :: proc(r: Rect2, value: float): Rect2 { + r.min.x += value; + r.max.x -= value; + r.min.y += value; + r.max.y -= value; + return r; +} + +RectFromSize :: proc(pos: Vector2, size: Vector2): Rect2 { + result: Rect2 = {pos, Vector2Add(pos, size)}; + return result; +} + +GetRectSize :: proc(rect: Rect2): Vector2 { + result: Vector2 = {rect.max.x - rect.min.x, rect.max.y - rect.min.y}; + return result; +} + +RectToRectangle :: proc(rect: Rect2): Rectangle { + size := GetRectSize(rect); + result: Rectangle = {rect.min.x, rect.min.y, size.x, size.y}; + return result; +} \ No newline at end of file diff --git a/examples/sandbox/dynamic_array.lc b/examples/sandbox/dynamic_array.lc new file mode 100644 index 0000000..72943bf --- /dev/null +++ b/examples/sandbox/dynamic_array.lc @@ -0,0 +1,49 @@ +ArrayOfName :: struct { + data: *Name; + len: int; + cap: int; +} + +TryGrowingNameArray :: proc(arr: *ArrayOfName) { + if (arr.len + 1 > arr.cap) { + cap := arr.cap * 2; + if (cap == 0) cap = 16; + + arr.data = libc.realloc(arr.data, sizeof(arr.data[0]) * :libc.size_t(cap)); + arr.cap = cap; + } +} + +AddName :: proc(arr: *ArrayOfName, item: Name) { + TryGrowingNameArray(arr); + arr.data[arr.len] = item; + arr.len += 1; +} + +InsertName :: proc(a: *ArrayOfName, item: Name, index: int) { + if index == a.len { + AddName(a, item); + return; + } + + libc.assert(index < a.len); + libc.assert(index >= 0); + + TryGrowingNameArray(a); + right_len := :libc.size_t(a.len - index); + libc.memmove(&a.data[index + 1], &a.data[index], sizeof(a.data[0]) * right_len); + a.data[index] = item; + a.len += 1; +} + +GetLastName :: proc(a: ArrayOfName): *Name { + libc.assert(a.len > 0); + result := &a.data[a.len - 1]; + return result; +} + +PopName :: proc(a: *ArrayOfName): Name { + a.len -= 1; + result := a.data[a.len]; + return result; +} \ No newline at end of file diff --git a/examples/sandbox/main.lc b/examples/sandbox/main.lc new file mode 100644 index 0000000..4acb5a1 --- /dev/null +++ b/examples/sandbox/main.lc @@ -0,0 +1,93 @@ +import "raylib"; + +Tile :: struct { + value: int; +} + +Map :: struct { + tiles: *Tile; + x: int; + y: int; +} + +CreateMap :: proc(x: int, y: int, map: *int): Map { + result: Map = {x = x, y = y}; + result.tiles = MemAlloc(:uint(x*y) * sizeof(:Tile)); + + for i := 0; i < x*y; i += 1 { + result.tiles[i].value = map[i]; + } + return result; +} + +main :: proc(): int { + TestArena(); + return 0; + InitWindow(800, 600, "Thing"); + SetTargetFPS(60); + + XPIX :: 32; + YPIX :: 32; + + camera: Camera2D = { + zoom = 1.0, + }; + + _map_x :: 8; + _map_y :: 8; + map := CreateMap(_map_x, _map_y, &:[_map_x * _map_y]int{ + 1,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + 1,0,0,0,0,0,0,1, + 0,0,0,0,1,0,0,0, + 0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0, + }[0]); + + for !WindowShouldClose() { + if IsMouseButtonDown(MOUSE_BUTTON_LEFT) { + delta := GetMouseDelta(); + camera.offset = Vector2Add(camera.offset, delta); + } + + BeginDrawing(); + ClearBackground(RAYWHITE); + + BeginMode2D(camera); + for y_it := 0; y_it < map.y; y_it += 1 { + for x_it := 0; x_it < map.x; x_it += 1 { + tile := &map.tiles[x_it + y_it * map.x]; + original_rect := RectFromSize({XPIX * :float(x_it), YPIX * :float(y_it)}, {XPIX, YPIX}); + rect := Shrink(original_rect, 2); + + r := RectToRectangle(rect); + + min_screen := GetWorldToScreen2D(original_rect.min, camera); + size := GetRectSize(original_rect); + + screen_rect: Rectangle = {min_screen.x, min_screen.y, size.x, size.y}; + mouse_p := GetMousePosition(); + + if tile.value == 1 { + DrawRectangleRec(r, RED); + } else { + DrawRectangleRec(r, GREEN); + } + + if CheckCollisionPointRec(mouse_p, screen_rect) { + DrawRectangleRec(r, BLUE); + } + } + } + EndMode2D(); + + // DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); + EndDrawing(); + } + + CloseWindow(); + return 0; +} + diff --git a/examples/text_editor/buffer.lc b/examples/text_editor/buffer.lc new file mode 100644 index 0000000..f703ea6 --- /dev/null +++ b/examples/text_editor/buffer.lc @@ -0,0 +1,249 @@ +Buffer :: struct { + data: *u8; + len: int; + cap: int; + + lines: Lines; +} + +Lines :: struct { + data: *Range; + len: int; + cap: int; +} + +Range :: struct { + min: int; + max: int; +} + +LineInfo :: struct { + number: int; + range: Range; +} + +GetRangeSize :: proc(range: Range): int { + result := range.max - range.min; + return result; +} + +ClampInt :: proc(val: int, min: int, max: int): int { + result := val; + if (val < min) result = min; + if (val > max) result = max; + return result; +} + +MinInt :: proc(a: int, b: int): int { + result := a; + if (a > b) result = b; + return result; +} + +MaxInt :: proc(a: int, b: int): int { + result := b; + if (a > b) result = a; + return result; +} + +AdjustUTF8PosUnsafe :: proc(buffer: *Buffer, pos: int, direction: int = 1): int { + for pos >= 0 && pos < buffer.len && IsUTF8ContinuationByte(buffer.data[pos]) { + pos += direction; + } + return pos; +} + +AdjustUTF8Pos :: proc(buffer: *Buffer, pos: int, direction: int = 1): int { + assert(direction == 1 || direction == -1); + pos = AdjustUTF8PosUnsafe(buffer, pos, direction); + pos = ClampInt(pos, 0, buffer.len - 1); + if (buffer.data) assert(!IsUTF8ContinuationByte(buffer.data[pos])); + return pos; +} + +AdjustRange :: proc(buffer: *Buffer, range: *Range) { + range.min = AdjustUTF8Pos(buffer, range.min, direction = -1); + range.max = AdjustUTF8Pos(buffer, range.max, direction = +1); +} + +ReplaceText :: proc(buffer: *Buffer, replace: Range, with: String) { + AdjustRange(buffer, &replace); + + new_buffer_len := buffer.len + :int(with.len) - GetRangeSize(replace); + new_buffer_size := new_buffer_len + 1; // possible addition of a null terminator + if new_buffer_size > buffer.cap { + new_buffer_cap := MaxInt(4096, new_buffer_size * 2); + new_buffer := malloc(:usize(new_buffer_cap)); + if (buffer.data) { + memcpy(new_buffer, buffer.data, :usize(buffer.len)); + free(buffer.data); + } + buffer.data = new_buffer; + buffer.cap = new_buffer_cap; + } + + old_text_range: Range = replace; + new_text_range: Range = {old_text_range.min, old_text_range.min + :int(with.len)}; + right_range: Range = {old_text_range.max, buffer.len}; + + memmove(&buffer.data[new_text_range.max], &buffer.data[right_range.min], :usize(GetRangeSize(right_range))); + memmove(&buffer.data[new_text_range.min], with.str, :usize(GetRangeSize(new_text_range))); + + buffer.len = new_buffer_len; + if buffer.len && buffer.data[buffer.len - 1] != 0 { + buffer.data[buffer.len] = 0; + buffer.len += 1; + assert(buffer.len <= buffer.cap); + } + + UpdateBufferLines(buffer); +} + +AddLine :: proc(lines: *Lines, line: Range) { + if lines.len + 1 > lines.cap { + new_cap := MaxInt(16, lines.cap * 2); + lines.data = realloc(lines.data, :usize(new_cap) * sizeof(:Range)); + lines.cap = new_cap; + } + lines.data[lines.len] = line; + lines.len += 1; +} + +UpdateBufferLines :: proc(buffer: *Buffer) { + buffer.lines.len = 0; + + line: Range = {0, 0}; + for i := 0; i < buffer.len; i += 1 { + if buffer.data[i] == '\n' { + AddLine(&buffer.lines, line); + line.min = i + 1; + line.max = i + 1; + } else { + line.max += 1; + } + } + + line.min = AdjustUTF8Pos(buffer, line.min); + line.max = AdjustUTF8Pos(buffer, line.max); + AddLine(&buffer.lines, line); +} + +AllocStringFromBuffer :: proc(buffer: *Buffer, range: Range, null_terminate: bool = false): String { + AdjustRange(buffer, &range); + size := GetRangeSize(range); + + alloc_size := :usize(size); + if (null_terminate) alloc_size += 1; + data := malloc(alloc_size); + memcpy(data, &buffer.data[range.min], :usize(size)); + + result: String = {data, size}; + if (null_terminate) result.str[result.len] = 0; + return result; +} + +GetStringFromBuffer :: proc(buffer: *Buffer, range: Range): String { + AdjustRange(buffer, &range); + size := GetRangeSize(range); + result: String = {:*char(&buffer.data[range.min]), size}; + return result; +} + +AddText :: proc(buffer: *Buffer, text: String) { + end_of_buffer: Range = {buffer.len - 1, buffer.len - 1}; + ReplaceText(buffer, end_of_buffer, text); +} + +FindLineOfPos :: proc(buffer: *Buffer, pos: int): LineInfo { + for i := 0; i < buffer.lines.len; i += 1 { + line := buffer.lines.data[i]; + if pos >= line.min && pos <= line.max { + return {i, line}; + } + } + return {}; +} + +IsLineValid :: proc(buffer: *Buffer, line: int): bool { + result := line >= 0 && line < buffer.lines.len; + return result; +} + +GetLine :: proc(buffer: *Buffer, line: int): LineInfo { + line = ClampInt(line, 0, buffer.lines.len - 1); + range := buffer.lines.data[line]; + return {line, range}; +} + +IsPosInBounds :: proc(buffer: *Buffer, pos: int): bool { + result := buffer.len != 0 && pos >= 0 && pos < buffer.len; + return result; +} + +GetChar :: proc(buffer: *Buffer, pos: int): u8 { + result: u8; + if IsPosInBounds(buffer, pos) { + result = buffer.data[pos]; + } + return result; +} + +GetUTF32 :: proc(buffer: *Buffer, pos: int, codepoint_size: *int = nil): u32 { + if !IsPosInBounds(buffer, pos) return 0; + p := &buffer.data[pos]; + max := buffer.len - pos; + utf32 := UTF8ToUTF32(:*uchar(p), max); + assert(utf32.error == 0); + if (utf32.error != 0) return 0; + if (codepoint_size) codepoint_size[0] = utf32.advance; + return utf32.out_str; +} + +IsWhitespace :: proc(w: u8): bool { + result := w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r'; + return result; +} + +SeekOnWordBoundary :: proc(buffer: *Buffer, pos: int, direction: int = GO_FORWARD): int { + assert(direction == GO_FORWARD || direction == GO_BACKWARD); + check_pos: int; + if direction == GO_FORWARD { + check_pos = AdjustUTF8Pos(buffer, pos + 1, direction); + pos = check_pos; + // this difference here because the Backward for loop is not inclusive. + // It doesn't move an inch forward after "pos" + // - - - - pos - - + // It goes backward on first Advance + } else { + check_pos = AdjustUTF8Pos(buffer, pos - 1, direction); + } + + cursor_char := GetChar(buffer, check_pos); + standing_on_whitespace := IsWhitespace(cursor_char); + seek_whitespace := standing_on_whitespace == false; + seek_word := standing_on_whitespace; + + end := buffer.len - 1; + if (direction == GO_BACKWARD) end = 0; + + result := end; + iter := Iterate(buffer, pos, end, direction); + prev_pos := iter.pos; + for IsValid(iter); Advance(&iter) { + if seek_word && !IsWhitespace(:u8(iter.item)) { + result = prev_pos; + break; + } + if seek_whitespace && IsWhitespace(:u8(iter.item)) { + if direction == GO_FORWARD { + result = iter.pos; + } else { + result = prev_pos; + } + break; + } + prev_pos = iter.pos; + } + + return result; +} \ No newline at end of file diff --git a/examples/text_editor/buffer_iter.lc b/examples/text_editor/buffer_iter.lc new file mode 100644 index 0000000..d133f18 --- /dev/null +++ b/examples/text_editor/buffer_iter.lc @@ -0,0 +1,54 @@ +GO_FORWARD :: 1; +GO_BACKWARD :: -1; + +BufferIter :: struct { + buffer: *Buffer; + pos: int; + end: int; + item: u32; + + utf8_codepoint_size: int; + direction: int; + codepoint_index: int; +} + +IsValid :: proc(iter: BufferIter): bool { + assert(iter.direction == GO_FORWARD || iter.direction == GO_BACKWARD); + + result := false; + if iter.direction == GO_BACKWARD { + result = iter.pos >= iter.end; + } else { + result = iter.pos < iter.end; + } + + if result { + assert(!IsUTF8ContinuationByte(GetChar(iter.buffer, iter.pos))); + assert(IsPosInBounds(iter.buffer, iter.pos)); + } + return result; +} + +Advance :: proc(iter: *BufferIter) { + assert(iter.direction == GO_FORWARD || iter.direction == GO_BACKWARD); + + iter.codepoint_index += 1; + if iter.direction == GO_FORWARD { + iter.pos += iter.utf8_codepoint_size; + } else { + iter.pos = AdjustUTF8PosUnsafe(iter.buffer, iter.pos - 1, GO_BACKWARD); + } + + if !IsValid(*iter) return; + iter.item = GetUTF32(iter.buffer, iter.pos, &iter.utf8_codepoint_size); +} + +Iterate :: proc(buffer: *Buffer, pos: int, end: int, direction: int = GO_FORWARD): BufferIter { + assert(!IsUTF8ContinuationByte(GetChar(buffer, pos))); + assert(!IsUTF8ContinuationByte(GetChar(buffer, end))); + assert(direction == GO_FORWARD || direction == GO_BACKWARD); + + result: BufferIter = {buffer = buffer, pos = pos, end = end, direction = direction, codepoint_index = -1}; + Advance(&result); + return result; +} \ No newline at end of file diff --git a/examples/text_editor/build.cpp b/examples/text_editor/build.cpp new file mode 100644 index 0000000..2d117bb --- /dev/null +++ b/examples/text_editor/build.cpp @@ -0,0 +1,34 @@ +bool text_editor() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + LC_LangBegin(lang); + defer { LC_LangEnd(lang); }; + + LC_RegisterPackageDir("../pkgs"); + LC_RegisterPackageDir("../examples"); + + LC_Intern name = LC_ILit("text_editor"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) return false; + + DebugVerifyAST(packages); + if (L->errors) return false; + + LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls(); + + OS_MakeDir("examples"); + OS_MakeDir("examples/text_editor"); + OS_CopyFile(RaylibDLL, "examples/text_editor/raylib.dll", true); + + S8_String code = LC_GenerateUnityBuild(packages); + S8_String path = "examples/text_editor/text_editor.c"; + OS_WriteFile(path, code); + + if (!UseCL) return true; + S8_String cmd = Fmt("cl %.*s -Zi -std:c11 -nologo -FC -Fd:examples/text_editor/a.pdb -Fe:examples/text_editor/text_editor.exe %.*s", S8_Expand(path), S8_Expand(RaylibLIB)); + int errcode = Run(cmd); + if (errcode != 0) return false; + + return true; +} \ No newline at end of file diff --git a/examples/text_editor/main.lc b/examples/text_editor/main.lc new file mode 100644 index 0000000..7af6307 --- /dev/null +++ b/examples/text_editor/main.lc @@ -0,0 +1,362 @@ +import "raylib"; +import "std_types"; +import "libc"; + +MainCursor: Selection; + +Selection :: struct { + a: int; + b: int; +} + +GetRange :: proc(s: Selection): Range { + result: Range = {MinInt(s.a, s.b), MaxInt(s.a, s.b)}; + return result; +} + +main :: proc(): int { + InitWindow(800, 600, "TextEditor"); + SetTargetFPS(60); + + font_size: float = 35; + font_spacing: float = 1; + font: Font = LoadFontEx("C:/Windows/Fonts/consola.ttf", :int(font_size), nil, 0); + + glyph_info: GlyphInfo = GetGlyphInfo(font, 'A'); + size := MeasureTextEx(font, "A", font_size, font_spacing); + Monosize = {:float(glyph_info.image.width), size.y}; + + buffer: Buffer; + AddText(&buffer, "1Testing and stuff 1Testing and stuff 1Testing and stuff 1Testing and stuff\n"); + AddText(&buffer, "2Testing and stuff\n"); + AddText(&buffer, "3Testing and stuff\n"); + AddText(&buffer, "4Testing and stuff\n"); + AddText(&buffer, "5Testing and stuff\n"); + AddText(&buffer, "6Testing and stuff\n"); + AddText(&buffer, "7Testing and stuff\n"); + AddText(&buffer, "8Testing and stuff\n"); + AddText(&buffer, "9Testing and stuff\n"); + AddText(&buffer, "1Testing and stuff\n"); + AddText(&buffer, "2Testing and stuff\n"); + AddText(&buffer, "3Testing and stuff\n"); + AddText(&buffer, "4Testing and stuff\n"); + AddText(&buffer, "5Testing and stuff\n"); + AddText(&buffer, "6Testing and stuff\n"); + AddText(&buffer, "7Testing and stuff\n"); + AddText(&buffer, "8Testing and stuff\n"); + AddText(&buffer, "9Testing and stuff\n"); + AddText(&buffer, "1Testing and stuff\n"); + AddText(&buffer, "22esting and stuff\n"); + AddText(&buffer, "3Testing and stuff\n"); + AddText(&buffer, "4Testing and stuff\n"); + AddText(&buffer, "5Testing and stuff\n"); + AddText(&buffer, "6Testing and stuff\n"); + AddText(&buffer, "7Testing and stuff\n"); + AddText(&buffer, "8Testing and stuff\n"); + AddText(&buffer, "9Testing and stuff\n"); + AddText(&buffer, "1Testing and stuff\n"); + AddText(&buffer, "2Testing and stuff\n"); + AddText(&buffer, "3Testing and stuff\n"); + AddText(&buffer, "4Testing and stuff\n"); + + for !WindowShouldClose() { + ScreenSize = {:f32(GetScreenWidth()), :f32(GetScreenHeight())}; + initial_cursor: Selection = MainCursor; + + if IsKeyPressed(KEY_LEFT) || IsKeyPressedRepeat(KEY_LEFT) { + if IsKeyDown(KEY_LEFT_SHIFT) { + if IsKeyDown(KEY_LEFT_CONTROL) { + MainCursor.b = SeekOnWordBoundary(&buffer, MainCursor.b, GO_BACKWARD); + } else { + MainCursor.b = MoveLeft(&buffer, MainCursor.b); + } + } else { + if IsKeyDown(KEY_LEFT_CONTROL) { + MainCursor.a = SeekOnWordBoundary(&buffer, MainCursor.a, GO_BACKWARD); + MainCursor.b = MainCursor.a; + } else { + MainCursor.a = MoveLeft(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + } + } + + if IsKeyPressed(KEY_RIGHT) || IsKeyPressedRepeat(KEY_RIGHT) { + if IsKeyDown(KEY_LEFT_SHIFT) { + if IsKeyDown(KEY_LEFT_CONTROL) { + MainCursor.b = SeekOnWordBoundary(&buffer, MainCursor.b, GO_FORWARD); + } else { + MainCursor.b = MoveRight(&buffer, MainCursor.b); + } + } else { + if IsKeyDown(KEY_LEFT_CONTROL) { + MainCursor.a = SeekOnWordBoundary(&buffer, MainCursor.a, GO_FORWARD); + MainCursor.b = MainCursor.a; + } else { + MainCursor.a = MoveRight(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + } + } + + if (IsKeyPressed(KEY_DOWN) || IsKeyPressedRepeat(KEY_DOWN)) { + if IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.b = MoveDown(&buffer, MainCursor.b); + } else { + range := GetRange(MainCursor); + if GetRangeSize(range) > 0 { + MainCursor.b = range.max; + MainCursor.a = range.max; + } + MainCursor.a = MoveDown(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + } + + if (IsKeyPressed(KEY_UP) || IsKeyPressedRepeat(KEY_UP)) { + if IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.b = MoveUp(&buffer, MainCursor.b); + } else { + range := GetRange(MainCursor); + if GetRangeSize(range) > 0 { + MainCursor.b = range.min; + MainCursor.a = range.min; + } + MainCursor.a = MoveUp(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + } + + if IsKeyPressed(KEY_BACKSPACE) || IsKeyPressedRepeat(KEY_BACKSPACE) { + range := GetRange(MainCursor); + range_size := GetRangeSize(range); + + if range_size == 0 { + if IsKeyDown(KEY_LEFT_CONTROL) { + left := SeekOnWordBoundary(&buffer, MainCursor.a, GO_BACKWARD); + ReplaceText(&buffer, {left, MainCursor.a}, ""); + MainCursor.a = left; + MainCursor.b = MainCursor.a; + } else { + left := MoveLeft(&buffer, MainCursor.a); + ReplaceText(&buffer, {left, MainCursor.a}, ""); + MainCursor.a = left; + MainCursor.b = MainCursor.a; + } + } else { + ReplaceText(&buffer, range, ""); + MainCursor.b = range.min; + MainCursor.a = MainCursor.b; + } + } + + if IsKeyPressed(KEY_DELETE) || IsKeyPressedRepeat(KEY_DELETE) { + range := GetRange(MainCursor); + range_size := GetRangeSize(range); + + if range_size == 0 { + if IsKeyDown(KEY_LEFT_CONTROL) { + right := SeekOnWordBoundary(&buffer, MainCursor.a); + ReplaceText(&buffer, {MainCursor.a, right}, ""); + } else { + right := MoveRight(&buffer, MainCursor.a); + ReplaceText(&buffer, {MainCursor.a, right}, ""); + } + MainCursor.b = MainCursor.a; + } else { + ReplaceText(&buffer, range, ""); + MainCursor.b = range.min; + MainCursor.a = MainCursor.b; + } + } + + if IsKeyPressed(KEY_ENTER) || IsKeyPressedRepeat(KEY_ENTER) { + ReplaceText(&buffer, GetRange(MainCursor), "\n"); + MainCursor.a = MoveRight(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + + if IsKeyPressed(KEY_HOME) { + line := FindLineOfPos(&buffer, MainCursor.b); + if IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.b = line.range.min; + } else { + MainCursor.a = line.range.min; + MainCursor.b = line.range.min; + } + } + if IsKeyPressed(KEY_END) { + line := FindLineOfPos(&buffer, MainCursor.b); + if IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.b = line.range.max; + } else { + MainCursor.a = line.range.max; + MainCursor.b = line.range.max; + } + } + + if IsKeyPressed(KEY_PAGE_DOWN) || IsKeyPressedRepeat(KEY_PAGE_DOWN) { + vpos := CalculateVisualPos(&buffer, MainCursor.b); + move_by := :int(roundf(ScreenSize.y / Monosize.y)); + vpos.y += move_by; + MainCursor.b = CalculatePosFromVisualPos(&buffer, vpos); + if !IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.a = MainCursor.b; + } + } + if IsKeyPressed(KEY_PAGE_UP) || IsKeyPressedRepeat(KEY_PAGE_UP) { + vpos := CalculateVisualPos(&buffer, MainCursor.b); + move_by := :int(roundf(ScreenSize.y / Monosize.y)); + vpos.y -= move_by; + MainCursor.b = CalculatePosFromVisualPos(&buffer, vpos); + if !IsKeyDown(KEY_LEFT_SHIFT) { + MainCursor.a = MainCursor.b; + } + } + + mouse_p := GetMousePosition(); + if IsMouseButtonDown(MOUSE_BUTTON_LEFT) { + p := Vector2Add(mouse_p, Scroll); + p = Vector2Divide(p, Monosize); + x := :int(floorf(p.x)); + y := :int(floorf(p.y)); + MainCursor.a = CalculatePosFromVisualPos(&buffer, {x, y}); + MainCursor.b = MainCursor.a; + } + + if CheckCollisionPointRec(mouse_p, {0, 0, ScreenSize.x, ScreenSize.y}) { + SetMouseCursor(MOUSE_CURSOR_IBEAM); + } else { + SetMouseCursor(MOUSE_CURSOR_DEFAULT); + } + + for key := GetCharPressed(); key; key = GetCharPressed() { + selection_range := GetRange(MainCursor); + + result: UTF8_Result = UTF32ToUTF8(:u32(key)); + if result.error == 0 { + ReplaceText(&buffer, selection_range, {:*char(&result.out_str[0]), result.len}); + } else { + ReplaceText(&buffer, selection_range, "?"); + } + + range_size := GetRangeSize(selection_range); + if range_size != 0 { + MainCursor.a = selection_range.min; + MainCursor.b = selection_range.min; + } + MainCursor.a = MoveRight(&buffer, MainCursor.a); + MainCursor.b = MainCursor.a; + } + + // + // Scrolling + // + mouse_wheel := GetMouseWheelMove() * 16; + Scroll.y -= mouse_wheel; + + if initial_cursor.b != MainCursor.b { + cursor_vpos := CalculateVisualPos(&buffer, MainCursor.b); + + world_pos := CalculateWorldPosUnscrolled(cursor_vpos); + world_pos_cursor_end := Vector2Add(world_pos, Monosize); + + scrolled_begin := Scroll; + scrolled_end := Vector2Add(Scroll, ScreenSize); + + if world_pos_cursor_end.x > scrolled_end.x { + Scroll.x += world_pos_cursor_end.x - scrolled_end.x; + } + if world_pos.x < scrolled_begin.x { + Scroll.x -= scrolled_begin.x - world_pos.x; + } + if world_pos_cursor_end.y > scrolled_end.y { + Scroll.y += world_pos_cursor_end.y - scrolled_end.y; + } + if world_pos.y < scrolled_begin.y { + Scroll.y -= scrolled_begin.y - world_pos.y; + } + } + if (Scroll.x < 0) Scroll.x = 0; + if (Scroll.y < 0) Scroll.y = 0; + + + + BeginDrawing(); + ClearBackground(RAYWHITE); + + _miny := Scroll.y / Monosize.y; + _maxy := (Scroll.y + ScreenSize.y) / Monosize.y; + + _minx := Scroll.x / Monosize.x; + _maxx := (Scroll.x + ScreenSize.x) / Monosize.x; + + miny := :int(floorf(_miny)); + minx := :int(floorf(_minx)); + + maxy := :int(ceilf(_maxy)); + maxx := :int(ceilf(_maxx)); + + // Draw grid + { + for y := miny; y < maxy; y += 1 { + for x := minx; x < maxx; x += 1 { + p := CalculateWorldPos({x, y}); + rect := Rect2PSize(p.x, p.y, Monosize.x, Monosize.y); + rect = Shrink(rect, 1); + DrawRect(rect, {255, 0, 0, 40}); + } + } + } + + // Draw text + { + miny = ClampInt(miny, 0, buffer.lines.len - 1); + maxy = ClampInt(maxy, 0, buffer.lines.len - 1); + for y := miny; y <= maxy; y += 1 { + line := buffer.lines.data[y]; + + string := AllocStringFromBuffer(&buffer, line, null_terminate = true); + defer free(string.str); + + pos := CalculateWorldPos({0, y}); + DrawTextEx(font, string.str, pos, font_size, font_spacing, BLACK); + } + } + + // Draw selection + { + range := GetRange(MainCursor); + start_vpos := CalculateVisualPos(&buffer, range.min); + pos := start_vpos; + for iter := Iterate(&buffer, range.min, range.max); IsValid(iter); Advance(&iter) { + world_pos := CalculateWorldPos(pos); + rect := Rect2PSize(world_pos.x, world_pos.y, Monosize.x, Monosize.y); + DrawRect(rect, {0, 255, 0, 40}); + + pos.x += 1; + if iter.item == '\n' { + pos.x = 0; + pos.y += 1; + } + } + } + + // Draw cursor + { + c := CalculateVisualPos(&buffer, MainCursor.b); + p := CalculateWorldPos(c); + + cursor_size: f32 = Monosize.x * 0.2; + rect := Rect2PSize(p.x, p.y, Monosize.x, Monosize.y); + rect = CutLeft(&rect, cursor_size); + + DrawRect(rect, RED); + } + + + EndDrawing(); + } + CloseWindow(); + return 0; +} \ No newline at end of file diff --git a/examples/text_editor/rect2p.lc b/examples/text_editor/rect2p.lc new file mode 100644 index 0000000..ed3df06 --- /dev/null +++ b/examples/text_editor/rect2p.lc @@ -0,0 +1,79 @@ +Rect2P :: struct { + min: Vector2; + max: Vector2; +} + +F32_Max :: proc(a: f32, b: f32): f32 { + if a > b return a; + return b; +} + +F32_Min :: proc(a: f32, b: f32): f32 { + if a > b return b; + return a; +} + +F32_Clamp :: proc(val: f32, min: f32, max: f32): f32 { + if (val > max) return max; + if (val < min) return min; + return val; +} + +GetRectSize :: proc(rect: Rect2P): Vector2 { + result: Vector2 = {rect.max.x - rect.min.x, rect.max.y - rect.min.y}; + return result; +} + +CutLeft :: proc(r: *Rect2P, value: f32): Rect2P { + minx := r.min.x; + r.min.x = F32_Min(r.max.x, r.min.x + value); + return :Rect2P{ + { minx, r.min.y}, + {r.min.x, r.max.y}, + }; +} + +CutRight :: proc(r: *Rect2P, value: f32): Rect2P { + maxx := r.max.x; + r.max.x = F32_Max(r.max.x - value, r.min.x); + return :Rect2P{ + {r.max.x, r.min.y}, + { maxx, r.max.y}, + }; +} + +CutBottom :: proc(r: *Rect2P, value: f32): Rect2P { // Y is down + maxy := r.max.y; + r.max.y = F32_Max(r.min.y, r.max.y - value); + return :Rect2P{ + {r.min.x, r.max.y}, + {r.max.x, maxy}, + }; +} + +CutTop :: proc(r: *Rect2P, value: f32): Rect2P { // Y is down + miny := r.min.y; + r.min.y = F32_Min(r.min.y + value, r.max.y); + return :Rect2P{ + {r.min.x, miny}, + {r.max.x, r.min.y}, + }; +} + +Rect2PToRectangle :: proc(r: Rect2P): Rectangle { + result: Rectangle = {r.min.x, r.min.y, r.max.x - r.min.x, r.max.y - r.min.y}; + return result; +} + +Rect2PSize :: proc(x: f32, y: f32, w: f32, h: f32): Rect2P { + result: Rect2P = {{x, y}, {x+w, y+h}}; + return result; +} + +Shrink :: proc(r: Rect2P, v: f32): Rect2P { + r.min.x += v; + r.min.y += v; + r.max.x -= v; + r.max.y -= v; + return r; +} \ No newline at end of file diff --git a/examples/text_editor/unicode.lc b/examples/text_editor/unicode.lc new file mode 100644 index 0000000..149ba8a --- /dev/null +++ b/examples/text_editor/unicode.lc @@ -0,0 +1,94 @@ +UTF32_Result :: struct { + out_str: u32; + advance: int; + error: int; +} + +UTF8_Result :: struct { + out_str: [4]u8; + len: int; + error: int; +} + +IsUTF8ContinuationByte :: proc(c: u8): bool { + result := (c & 0b11000000) == 0b10000000; + return result; +} + +UTF8ToUTF32 :: proc(c: *uchar, max_advance: int): UTF32_Result { + result: UTF32_Result; + + if (c[0] & 0x80) == 0 { // Check if leftmost zero of first byte is unset + if max_advance >= 1 { + result.out_str = :u32(c[0]); + result.advance = 1; + } + else result.error = 1; + } + + else if (c[0] & 0xe0) == 0xc0 { + if (c[1] & 0xc0) == 0x80 { // Continuation byte required + if max_advance >= 2 { + result.out_str = (:u32(c[0] & 0x1f) << 6) | :u32(c[1] & 0x3f); + result.advance = 2; + } + else result.error = 2; + } + else result.error = 2; + } + + else if (c[0] & 0xf0) == 0xe0 { + if ((c[1] & 0xc0) == 0x80) && ((c[2] & 0xc0) == 0x80) { // Two continuation bytes required + if max_advance >= 3 { + result.out_str = (:u32(c[0] & 0xf) << 12) | (:u32(c[1] & 0x3f) << 6) | :u32(c[2] & 0x3f); + result.advance = 3; + } + else result.error = 3; + } + else result.error = 3; + } + + else if (c[0] & 0xf8) == 0xf0 { + if (c[1] & 0xc0) == 0x80 && (c[2] & 0xc0) == 0x80 && (c[3] & 0xc0) == 0x80 { // Three continuation bytes required + if max_advance >= 4 { + result.out_str = :u32(c[0] & 0xf) << 18 | :u32(c[1] & 0x3f) << 12 | :u32(c[2] & 0x3f) << 6 | :u32(c[3] & 0x3f); + result.advance = 4; + } + else result.error = 4; + } + else result.error = 4; + } + else result.error = 4; + + return result; +} + +UTF32ToUTF8 :: proc(codepoint: u32): UTF8_Result { + result: UTF8_Result; + + if codepoint <= 0x7F { + result.len = 1; + result.out_str[0] = :u8(codepoint); + } + else if codepoint <= 0x7FF { + result.len = 2; + result.out_str[0] = :u8 (0xc0 | 0x1f & (codepoint >> 6)); + result.out_str[1] = :u8 (0x80 | 0x3f & codepoint); + } + else if codepoint <= 0xFFFF { // 16 bit word + result.len = 3; + result.out_str[0] = :u8 (0xe0 | 0xf & (codepoint >> 12)); // 4 bits + result.out_str[1] = :u8 (0x80 | 0x3f & (codepoint >> 6)); // 6 bits + result.out_str[2] = :u8 (0x80 | 0x3f & codepoint); // 6 bits + } + else if codepoint <= 0x10FFFF { // 21 bit word + result.len = 4; + result.out_str[0] = :u8 (0xf0 | 0x7 & (codepoint >> 18)); // 3 bits + result.out_str[1] = :u8 (0x80 | 0x3f & (codepoint >> 12)); // 6 bits + result.out_str[2] = :u8 (0x80 | 0x3f & (codepoint >> 6)); // 6 bits + result.out_str[3] = :u8 (0x80 | 0x3f & codepoint); // 6 bits + } + else result.error = 1; + + return result; +} diff --git a/examples/text_editor/visual_pos.lc b/examples/text_editor/visual_pos.lc new file mode 100644 index 0000000..88bbb9a --- /dev/null +++ b/examples/text_editor/visual_pos.lc @@ -0,0 +1,76 @@ +Monosize: Vector2; +ScreenSize: Vector2; +Scroll: Vector2; + +Vec2I :: struct { + x: int; + y: int; +} + +MoveLeft :: proc(buffer: *Buffer, pos: int): int { + pos -= 1; + pos = AdjustUTF8Pos(buffer, pos, direction = -1); + return pos; +} + +MoveRight :: proc(buffer: *Buffer, pos: int): int { + pos += 1; + pos = AdjustUTF8Pos(buffer, pos, direction = +1); + return pos; +} + +CalculateVisualPos :: proc(buffer: *Buffer, pos: int): Vec2I { + line: LineInfo = FindLineOfPos(buffer, pos); + + iter := Iterate(buffer, line.range.min, line.range.max); + for IsValid(iter); Advance(&iter) { + if iter.pos == pos { + break; + } + } + + result: Vec2I = {iter.codepoint_index, line.number}; + return result; +} + +CalculatePosFromVisualPos :: proc(buffer: *Buffer, vpos: Vec2I): int { + line := GetLine(buffer, vpos.y); + iter := Iterate(buffer, line.range.min, line.range.max); + for IsValid(iter); Advance(&iter) { + if iter.codepoint_index == vpos.x { + break; + } + } + return iter.pos; +} + +CalculateWorldPosUnscrolled :: proc(vpos: Vec2I): Vector2 { + result: Vector2 = {Monosize.x * :f32(vpos.x), Monosize.y * :f32(vpos.y)}; + return result; +} + +CalculateWorldPos :: proc(vpos: Vec2I): Vector2 { + result: Vector2 = {Monosize.x * :f32(vpos.x) - Scroll.x, Monosize.y * :f32(vpos.y) - Scroll.y}; + return result; +} + +MoveDown :: proc(buffer: *Buffer, pos: int): int { + vpos := CalculateVisualPos(buffer, pos); + if !IsLineValid(buffer, vpos.y + 1) return pos; + + result := CalculatePosFromVisualPos(buffer, {vpos.x, vpos.y + 1}); + return result; +} + +MoveUp :: proc(buffer: *Buffer, pos: int): int { + vpos := CalculateVisualPos(buffer, pos); + if !IsLineValid(buffer, vpos.y - 1) return pos; + + result := CalculatePosFromVisualPos(buffer, {vpos.x, vpos.y - 1}); + return result; +} + +DrawRect :: proc(rec: Rect2P, color: Color) { + rectangle := Rect2PToRectangle(rec); + DrawRectangleRec(rectangle, color); +} diff --git a/examples/use_as_data_format_with_typechecking/build.cpp b/examples/use_as_data_format_with_typechecking/build.cpp new file mode 100644 index 0000000..865189e --- /dev/null +++ b/examples/use_as_data_format_with_typechecking/build.cpp @@ -0,0 +1,105 @@ +void OnExprResolved_MakeSureConstantsWork(LC_AST *n, LC_Operand *op); +bool use_as_data_format_with_typechecking() { + LC_Lang *lang = LC_LangAlloc(); + lang->use_colored_terminal_output = UseColoredIO; + lang->breakpoint_on_error = BreakpointOnError; + lang->on_expr_resolved = OnExprResolved_MakeSureConstantsWork; + LC_LangBegin(lang); + LC_RegisterPackageDir("../examples/"); + LC_RegisterPackageDir("../pkgs"); + + LC_Intern name = LC_ILit("use_as_data_format_with_typechecking"); + LC_ASTRefList packages = LC_ResolvePackageByName(name); + if (L->errors) { + LC_LangEnd(lang); + return false; + } + + LC_AST *package = LC_GetPackageByName(name); + + // Constants + { + LC_Decl *int_value = LC_FindDeclInScope(package->apackage.scope, LC_ILit("IntValue")); + int64_t IntValue = LC_Bigint_as_signed(&int_value->val.i); + IO_Assert(IntValue == 232); + } + + { + LC_Decl *decl = LC_FindDeclInScope(package->apackage.scope, LC_ILit("FloatValue")); + IO_Assert(decl->val.d == 13.0); + } + + { + LC_Decl *decl = LC_FindDeclInScope(package->apackage.scope, LC_ILit("SomeString")); + IO_Assert(decl->val.name == LC_ILit("Thing")); + } + + // Player + + int64_t LEVEL_BEGIN = -1; + { + LC_Decl *int_value = LC_FindDeclInScope(package->apackage.scope, LC_ILit("LEVEL_BEGIN")); + LEVEL_BEGIN = LC_Bigint_as_signed(&int_value->val.i); + IO_Assert(LEVEL_BEGIN == 2); + } + + { + /* @todo: + double DashSpeed = GetFloatValue(p, "Player.DashSpeed"); + double Hurtbox = GetFloatValue(p, "Player[0].Something.min.x"); + int64_t DashVFloorSnapDist = GetIntValue(p, "Player.DashVFloorSnapDist"); + + double Variable = GetFloatValue(p, "Variable"); + */ + + LC_Decl *decl = LC_FindDeclInScope(package->apackage.scope, LC_ILit("Player")); + LC_ResolvedCompo *items = decl->ast->dvar.expr->ecompo.resolved_items; + for (LC_ResolvedCompoItem *it = items->first; it; it = it->next) { + LC_Intern name = it->t->name; + + if (name == LC_ILit("DashSpeed")) { + double DashSpeed = it->expr->const_val.d; + IO_Assert(DashSpeed == 240.0); + } else if (name == LC_ILit("DashCooldown")) { + double DashCooldown = it->expr->const_val.d; + IO_Assert(DashCooldown > 0.19 && DashCooldown < 0.21); + } else if (name == LC_ILit("Level")) { + int64_t Level = LC_Bigint_as_signed(&it->expr->const_val.i); + IO_Assert(Level == LEVEL_BEGIN); + } + } + } + + { + LC_Decl *decl = LC_FindDeclInScope(package->apackage.scope, LC_ILit("Variable")); + IO_Assert(decl->val.d == 32.0); + } + + { + LC_Decl *decl = LC_FindDeclInScope(package->apackage.scope, LC_ILit("Reference")); + IO_Assert(decl->val.d == 64.0); + } + + LC_LangEnd(lang); + return true; +} + +void OnExprResolved_MakeSureConstantsWork(LC_AST *n, LC_Operand *op) { + switch (n->kind) { + case LC_ASTKind_ExprCast: + case LC_ASTKind_ExprAddPtr: + case LC_ASTKind_ExprIndex: + case LC_ASTKind_ExprGetPointerOfValue: + case LC_ASTKind_ExprGetValueOfPointer: + case LC_ASTKind_ExprCall: + LC_ReportASTError(n, "illegal expression kind"); + return; + default: { + } + } + + if (LC_IsFloat(op->type)) op->type = L->tuntypedfloat; + if (LC_IsInt(op->type)) op->type = L->tuntypedint; + if (LC_IsStr(op->type)) op->type = L->tuntypedstring; + op->flags |= LC_OPF_UTConst; +} \ No newline at end of file diff --git a/examples/use_as_data_format_with_typechecking/data.lc b/examples/use_as_data_format_with_typechecking/data.lc new file mode 100644 index 0000000..03a3005 --- /dev/null +++ b/examples/use_as_data_format_with_typechecking/data.lc @@ -0,0 +1,57 @@ +Vector2 :: struct { + x: float; + y: float; +} + +Hitbox :: struct { + min: Vector2; + max: Vector2; +} + +TPlayer :: struct { + DashSpeed: float; + EndDashSpeed: float; + EndDashUpMult: float; + DashTime: float; + DashCooldown: float; + DashRefillCooldown: float; + DashHJumpThruNudge: int; + DashCornerCorrection: int; + DashVFloorSnapDist: int; + DashAttackTime: float; + + Level: int; + NormalHitbox: Hitbox; + DuckHitbox: Hitbox; + + NormalHurtbox: Hitbox; + DuckHurtbox: Hitbox; +} + +Player: TPlayer = { + DashSpeed = 240, + EndDashSpeed = 160, + EndDashUpMult = 0.75, + DashTime = 0.15, + DashCooldown = 0.2, + DashRefillCooldown = 0.1, + DashHJumpThruNudge = 6, + DashCornerCorrection = 4, + DashVFloorSnapDist = 3, + DashAttackTime = 0.3, + + Level = LEVEL_BEGIN, + NormalHitbox = { { 1, 1 }, { 2, 2 } }, + NormalHurtbox = { min = { x = 1, y = 1 }, max = { 2 } }, +}; + +LEVEL_TUTORIAL :: 1; +LEVEL_BEGIN :: ^; + +IntValue :: 232; +FloatValue :: 13.0; +SomeString :: "Thing"; + +Variable: float = 32.0; +Reference := Variable + Variable; + diff --git a/lib_compiler.h b/lib_compiler.h new file mode 100644 index 0000000..18ed716 --- /dev/null +++ b/lib_compiler.h @@ -0,0 +1,11089 @@ +/* +This is a compiler frontend in a single-header-file library form. +In **beta** version so things may change between versions! + +# How to use + +In *one* of your C or C++ files to create the implementation: + +``` +#define LIB_COMPILER_IMPLEMENTATION +#include "lib_compiler.h" +``` + +In the rest of your files you can just include it like a regular +header. + +# Examples + +See online repository for code examples + +# Overrides + +You can override libc calls, the arena implementation using +preprocessor at compile time, here is an example of how you +would go about it: + +``` +#define LC_vsnprintf stbsp_vsnprintf +#define LC_MemoryZero(p, size) __builtin_memset(p, 0, size); +#define LC_MemoryCopy(dst, src, size) __builtin_memcpy(dst, src, size) + +#define LIB_COMPILER_IMPLEMENTATION +#include "lib_compiler.h" +``` + +Look for '@override' to find things that can be overridden using macro preprocessor +Look for '@api' to find the main functions that you are supposed to use +Look for '@configurable' to find runtime callbacks you can register and other settings + +# License (MIT) + +See end of file + +*/ +#ifndef LIB_COMPILER_HEADER +#define LIB_COMPILER_HEADER + +#define LIB_COMPILER_MAJOR 0 +#define LIB_COMPILER_MINOR 6 + +#include +#include +#include +#include + +#ifndef LC_THREAD_LOCAL // @override + #if defined(__cplusplus) && __cplusplus >= 201103L + #define LC_THREAD_LOCAL thread_local + #elif defined(__GNUC__) + #define LC_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define LC_THREAD_LOCAL __declspec(thread) + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define LC_THREAD_LOCAL _Thread_local + #elif defined(__TINYC__) + #define LC_THREAD_LOCAL _Thread_local + #else + #error Couldnt figure out thread local, needs to be provided manually + #endif +#endif + +#ifndef LC_FUNCTION // @override + #define LC_FUNCTION +#endif + +#ifndef LC_String // @override +typedef struct { + char *str; + int64_t len; +} LC_String; +#endif + +#ifndef LC_USE_CUSTOM_ARENA // @override +typedef struct LC_VMemory LC_VMemory; +typedef struct LC_TempArena LC_TempArena; +typedef struct LC_Arena LC_Arena; +typedef struct LC_SourceLoc LC_SourceLoc; + +struct LC_VMemory { + size_t commit; + size_t reserve; + uint8_t *data; +}; + +struct LC_Arena { + LC_VMemory memory; + int alignment; + size_t len; + size_t base_len; // When popping to 0 this is the minimum "len" value + // It's so that Bootstrapped arena won't delete itself when Reseting. +}; + +struct LC_TempArena { + LC_Arena *arena; + size_t pos; +}; +#endif + +typedef struct LC_MapEntry LC_MapEntry; +typedef struct LC_Map LC_Map; +typedef struct LC_AST LC_AST; +typedef struct LC_ASTPackage LC_ASTPackage; +typedef struct LC_ASTNoteList LC_ASTNoteList; +typedef struct LC_ExprCompo LC_ExprCompo; +typedef union LC_Val LC_Val; +typedef struct LC_ExprIdent LC_ExprIdent; +typedef struct LC_ExprUnary LC_ExprUnary; +typedef struct LC_ExprBinary LC_ExprBinary; +typedef struct LC_ExprField LC_ExprField; +typedef struct LC_ExprIndex LC_ExprIndex; +typedef struct LC_ExprCompoItem LC_ExprCompoItem; +typedef struct LC_ExprType LC_ExprType; +typedef struct LC_ExprCast LC_ExprCast; +typedef struct LC_ExprNote LC_ExprNote; +typedef struct LC_StmtBlock LC_StmtBlock; +typedef struct LC_StmtFor LC_StmtFor; +typedef struct LC_StmtDefer LC_StmtDefer; +typedef struct LC_StmtSwitch LC_StmtSwitch; +typedef struct LC_StmtCase LC_StmtCase; +typedef struct LC_StmtIf LC_StmtIf; +typedef struct LC_StmtBreak LC_StmtBreak; +typedef struct LC_StmtAssign LC_StmtAssign; +typedef struct LC_StmtExpr LC_StmtExpr; +typedef struct LC_StmtVar LC_StmtVar; +typedef struct LC_StmtConst LC_StmtConst; +typedef struct LC_StmtReturn LC_StmtReturn; +typedef struct LC_StmtNote LC_StmtNote; +typedef struct LC_TypespecArray LC_TypespecArray; +typedef struct LC_TypespecProc LC_TypespecProc; +typedef struct LC_TypespecAggMem LC_TypespecAggMem; +typedef struct LC_TypespecProcArg LC_TypespecProcArg; +typedef struct LC_DeclBase LC_DeclBase; +typedef struct LC_DeclProc LC_DeclProc; +typedef struct LC_DeclTypedef LC_DeclTypedef; +typedef struct LC_DeclAgg LC_DeclAgg; +typedef struct LC_DeclVar LC_DeclVar; +typedef struct LC_DeclConst LC_DeclConst; +typedef struct LC_DeclNote LC_DeclNote; +typedef union LC_ASTValue LC_ASTValue; +typedef struct LC_TypeAndVal LC_TypeAndVal; +typedef struct LC_TypeArray LC_TypeArray; +typedef struct LC_TypePtr LC_TypePtr; +typedef struct LC_TypeMemberList LC_TypeMemberList; +typedef struct LC_TypeProc LC_TypeProc; +typedef struct LC_TypeAgg LC_TypeAgg; +typedef union LC_TypeValue LC_TypeValue; +typedef struct LC_Type LC_Type; +typedef struct LC_TypeMember LC_TypeMember; +typedef struct LC_Decl LC_Decl; +typedef struct LC_DeclStack LC_DeclStack; +typedef struct LC_Map DeclScope; +typedef struct LC_ResolvedCompo LC_ResolvedCompo; +typedef struct LC_ResolvedCompoItem LC_ResolvedCompoItem; +typedef struct LC_ResolvedCompoArrayItem LC_ResolvedCompoArrayItem; +typedef struct LC_ResolvedArrayCompo LC_ResolvedArrayCompo; +typedef union LC_TokenVal LC_TokenVal; +typedef struct LC_Token LC_Token; +typedef struct LC_Lex LC_Lex; +typedef struct LC_Parser LC_Parser; +typedef struct LC_Resolver LC_Resolver; +typedef struct LC_Lang LC_Lang; +typedef struct LC_ASTRef LC_ASTRef; +typedef struct LC_ASTRefList LC_ASTRefList; +typedef struct LC_ASTFile LC_ASTFile; +typedef LC_Val Expr_Atom; +typedef LC_TypespecArray Typespec_Pointer; +typedef uintptr_t LC_Intern; +typedef struct LC_GlobImport LC_GlobImport; +typedef struct LC_UTF32Result LC_UTF32Result; +typedef struct LC_UTF8Result LC_UTF8Result; +typedef struct LC_UTF16Result LC_UTF16Result; + +typedef struct LC_StringNode LC_StringNode; +struct LC_StringNode { + LC_StringNode *next; + LC_String string; +}; + +typedef struct LC_StringList LC_StringList; +struct LC_StringList { + int64_t node_count; + int64_t char_count; + LC_StringNode *first; + LC_StringNode *last; +}; + +typedef struct LC_String16 { + wchar_t *str; + int64_t len; +} LC_String16; + +struct LC_MapEntry { + uint64_t key; + uint64_t value; +}; + +struct LC_Map { + LC_Arena *arena; + LC_MapEntry *entries; + int cap; + int len; +}; + +typedef struct LC_BigInt LC_BigInt; +struct LC_BigInt { + unsigned digit_count; + bool is_negative; + union { + uint64_t digit; + uint64_t *digits; + }; +}; + +typedef enum LC_ASTKind { + LC_ASTKind_Null, + LC_ASTKind_Error, + LC_ASTKind_Note, + LC_ASTKind_NoteList, + LC_ASTKind_File, + LC_ASTKind_Package, + LC_ASTKind_Ignore, + LC_ASTKind_TypespecProcArg, + LC_ASTKind_TypespecAggMem, + LC_ASTKind_ExprCallItem, + LC_ASTKind_ExprCompoundItem, + LC_ASTKind_ExprNote, // a: int = #`sizeof(int)`; + LC_ASTKind_StmtSwitchCase, + LC_ASTKind_StmtSwitchDefault, + LC_ASTKind_StmtElseIf, + LC_ASTKind_StmtElse, + LC_ASTKind_GlobImport, + LC_ASTKind_DeclNote, + LC_ASTKind_DeclProc, + LC_ASTKind_DeclStruct, + LC_ASTKind_DeclUnion, + LC_ASTKind_DeclVar, + LC_ASTKind_DeclConst, + LC_ASTKind_DeclTypedef, + LC_ASTKind_TypespecIdent, + LC_ASTKind_TypespecField, + LC_ASTKind_TypespecPointer, + LC_ASTKind_TypespecArray, + LC_ASTKind_TypespecProc, + LC_ASTKind_StmtBlock, + LC_ASTKind_StmtNote, + LC_ASTKind_StmtReturn, + LC_ASTKind_StmtBreak, + LC_ASTKind_StmtContinue, + LC_ASTKind_StmtDefer, + LC_ASTKind_StmtFor, + LC_ASTKind_StmtIf, + LC_ASTKind_StmtSwitch, + LC_ASTKind_StmtAssign, + LC_ASTKind_StmtExpr, + LC_ASTKind_StmtVar, + LC_ASTKind_StmtConst, + LC_ASTKind_ExprIdent, + LC_ASTKind_ExprString, + LC_ASTKind_ExprInt, + LC_ASTKind_ExprFloat, + LC_ASTKind_ExprBool, + LC_ASTKind_ExprType, + LC_ASTKind_ExprBinary, + LC_ASTKind_ExprUnary, + LC_ASTKind_ExprBuiltin, + LC_ASTKind_ExprCall, + LC_ASTKind_ExprCompound, + LC_ASTKind_ExprCast, + LC_ASTKind_ExprField, + LC_ASTKind_ExprIndex, + LC_ASTKind_ExprAddPtr, + LC_ASTKind_ExprGetValueOfPointer, + LC_ASTKind_ExprGetPointerOfValue, + LC_ASTKind_Count, + LC_ASTKind_FirstExpr = LC_ASTKind_ExprIdent, + LC_ASTKind_LastExpr = LC_ASTKind_ExprGetPointerOfValue, + LC_ASTKind_FirstStmt = LC_ASTKind_StmtBlock, + LC_ASTKind_LastStmt = LC_ASTKind_StmtConst, + LC_ASTKind_FirstTypespec = LC_ASTKind_TypespecIdent, + LC_ASTKind_LastTypespec = LC_ASTKind_TypespecProc, + LC_ASTKind_FirstDecl = LC_ASTKind_DeclProc, + LC_ASTKind_LastDecl = LC_ASTKind_DeclTypedef, +} LC_ASTKind; + +typedef enum LC_TypeKind { + LC_TypeKind_char, + LC_TypeKind_uchar, + LC_TypeKind_short, + LC_TypeKind_ushort, + LC_TypeKind_bool, + LC_TypeKind_int, + LC_TypeKind_uint, + LC_TypeKind_long, + LC_TypeKind_ulong, + LC_TypeKind_llong, + LC_TypeKind_ullong, + LC_TypeKind_float, + LC_TypeKind_double, + LC_TypeKind_void, + LC_TypeKind_Struct, + LC_TypeKind_Union, + LC_TypeKind_Pointer, + LC_TypeKind_Array, + LC_TypeKind_Proc, + LC_TypeKind_UntypedInt, + LC_TypeKind_UntypedFloat, + LC_TypeKind_UntypedString, + LC_TypeKind_Incomplete, + LC_TypeKind_Completing, + LC_TypeKind_Error, + T_TotalCount, + T_NumericCount = LC_TypeKind_void, + T_Count = LC_TypeKind_void + 1, +} LC_TypeKind; + +typedef enum LC_DeclState { + LC_DeclState_Unresolved, + LC_DeclState_Resolving, + LC_DeclState_Resolved, + LC_DeclState_ResolvedBody, // proc + LC_DeclState_Error, + LC_DeclState_Count, +} LC_DeclState; + +typedef enum LC_DeclKind { + LC_DeclKind_Error, + LC_DeclKind_Type, + LC_DeclKind_Const, + LC_DeclKind_Var, + LC_DeclKind_Proc, + LC_DeclKind_Import, + LC_DeclKind_Count, +} LC_DeclKind; + +typedef enum LC_TokenKind { + LC_TokenKind_EOF, + LC_TokenKind_Error, + LC_TokenKind_Comment, + LC_TokenKind_DocComment, + LC_TokenKind_FileDocComment, + LC_TokenKind_PackageDocComment, + LC_TokenKind_Note, + LC_TokenKind_Hash, + LC_TokenKind_Ident, + LC_TokenKind_Keyword, + LC_TokenKind_String, + LC_TokenKind_RawString, + LC_TokenKind_Int, + LC_TokenKind_Float, + LC_TokenKind_Unicode, + LC_TokenKind_OpenParen, + LC_TokenKind_CloseParen, + LC_TokenKind_OpenBrace, + LC_TokenKind_CloseBrace, + LC_TokenKind_OpenBracket, + LC_TokenKind_CloseBracket, + LC_TokenKind_Comma, + LC_TokenKind_Question, + LC_TokenKind_Semicolon, + LC_TokenKind_Dot, + LC_TokenKind_ThreeDots, + LC_TokenKind_Colon, + LC_TokenKind_Mul, + LC_TokenKind_Div, + LC_TokenKind_Mod, + LC_TokenKind_LeftShift, + LC_TokenKind_RightShift, + LC_TokenKind_Add, + LC_TokenKind_Sub, + LC_TokenKind_Equals, + LC_TokenKind_LesserThen, + LC_TokenKind_GreaterThen, + LC_TokenKind_LesserThenEq, + LC_TokenKind_GreaterThenEq, + LC_TokenKind_NotEquals, + LC_TokenKind_BitAnd, + LC_TokenKind_BitOr, + LC_TokenKind_BitXor, + LC_TokenKind_And, + LC_TokenKind_Or, + LC_TokenKind_AddPtr, + LC_TokenKind_Neg, + LC_TokenKind_Not, + LC_TokenKind_Assign, + LC_TokenKind_DivAssign, + LC_TokenKind_MulAssign, + LC_TokenKind_ModAssign, + LC_TokenKind_SubAssign, + LC_TokenKind_AddAssign, + LC_TokenKind_BitAndAssign, + LC_TokenKind_BitOrAssign, + LC_TokenKind_BitXorAssign, + LC_TokenKind_LeftShiftAssign, + LC_TokenKind_RightShiftAssign, + LC_TokenKind_Count, +} LC_TokenKind; + +struct LC_ASTFile { + LC_AST *package; + LC_Lex *x; + + LC_AST *fimport; + LC_AST *limport; + LC_AST *fdecl; + LC_AST *ldecl; + LC_AST *fdiscarded; + LC_AST *ldiscarded; // @build_if + + LC_Token *doc_comment; + + bool build_if; +}; + +struct LC_ASTPackage { + LC_Intern name; + LC_DeclState state; + LC_String path; + LC_StringList injected_filepaths; // to sidestep regular file finding, implement single file packages etc. + LC_AST *ffile; + LC_AST *lfile; + LC_AST *fdiscarded; + LC_AST *ldiscarded; // #build_if + + LC_Token *doc_comment; + + // These are resolved later: + // @todo: add foreign name? + LC_Decl *first_ordered; + LC_Decl *last_ordered; + DeclScope *scope; +}; + +struct LC_ASTNoteList { + LC_AST *first; + LC_AST *last; +}; + +struct LC_ResolvedCompo { + int count; + LC_ResolvedCompoItem *first; + LC_ResolvedCompoItem *last; +}; + +struct LC_ResolvedCompoItem { + LC_ResolvedCompoItem *next; + LC_AST *comp; // for proc this may be null because we might match default value + LC_AST *expr; // for proc this is very important, the result, ordered expression + LC_TypeMember *t; + bool varg; + bool defaultarg; +}; + +struct LC_ResolvedCompoArrayItem { + LC_ResolvedCompoArrayItem *next; + LC_AST *comp; + int index; +}; + +struct LC_ResolvedArrayCompo { + int count; + LC_ResolvedCompoArrayItem *first; + LC_ResolvedCompoArrayItem *last; +}; + +struct LC_ExprCompo { + LC_AST *name; // :name{thing} or name(thing) + LC_AST *first; // {LC_ExprCompoItem, LC_ExprCompoItem} + LC_AST *last; + int size; + union { + LC_ResolvedCompo *resolved_items; + LC_ResolvedArrayCompo *resolved_array_items; + }; +}; + +struct LC_ExprCompoItem { + LC_Intern name; + LC_AST *index; + LC_AST *expr; +}; + +// clang-format off +union LC_Val { LC_BigInt i; double d; LC_Intern name; }; +struct LC_ExprIdent { LC_Intern name; LC_Decl *resolved_decl; }; +struct LC_ExprUnary { LC_TokenKind op; LC_AST *expr; }; +struct LC_ExprBinary { LC_TokenKind op; LC_AST *left; LC_AST *right; }; +struct LC_ExprField { LC_AST *left; LC_Intern right; LC_Decl *resolved_decl; LC_Decl *parent_decl; }; +struct LC_ExprIndex { LC_AST *base; LC_AST *index; }; +struct LC_ExprType { LC_AST *type; }; +struct LC_ExprCast { LC_AST *type; LC_AST *expr; }; +struct LC_ExprNote { LC_AST *expr; }; // v := #c(``) + +typedef enum { SBLK_Norm, SBLK_Loop, SBLK_Proc, SBLK_Defer } LC_StmtBlockKind; +struct LC_StmtBlock { LC_AST *first; LC_AST *last; LC_AST *first_defer; LC_StmtBlockKind kind; LC_Intern name; }; +struct LC_StmtFor { LC_AST *init; LC_AST *cond; LC_AST *inc; LC_AST *body; }; +struct LC_StmtDefer { LC_AST *next; LC_AST *body; }; +struct LC_StmtSwitch { LC_AST *first; LC_AST *last; LC_AST *expr; int total_switch_case_count; }; +struct LC_StmtCase { LC_AST *first; LC_AST *last; LC_AST *body; }; +// 'else if' and 'else' is avaialable from 'first'. +// The else_if and else are also LC_StmtIf but +// have different kinds and don't use 'first', 'last' +struct LC_StmtIf { LC_AST *expr; LC_AST *body; LC_AST *first; LC_AST *last; }; +struct LC_StmtBreak { LC_Intern name; }; +struct LC_StmtAssign { LC_TokenKind op; LC_AST *left; LC_AST *right; }; +struct LC_StmtExpr { LC_AST *expr; }; +struct LC_StmtVar { LC_AST *expr; LC_AST *type; LC_Intern name; LC_Decl *resolved_decl; }; +struct LC_StmtConst { LC_AST *expr; LC_Intern name; }; +struct LC_StmtReturn { LC_AST *expr; }; +struct LC_StmtNote { LC_AST *expr; }; // #c(``) in block +struct LC_TypespecArray { LC_AST *base; LC_AST *index; }; +struct LC_TypespecProc { LC_AST *first; LC_AST *last; LC_AST *ret; bool vargs; bool vargs_any_promotion; }; +struct LC_TypespecAggMem { LC_Intern name; LC_AST *type; }; +struct LC_TypespecProcArg { LC_Intern name; LC_AST *type; LC_AST *expr; LC_Decl *resolved_decl; }; +struct LC_DeclBase { LC_Intern name; LC_Token *doc_comment; LC_Decl *resolved_decl; }; +struct LC_DeclProc { LC_DeclBase base; LC_AST *body; LC_AST *type; }; +struct LC_DeclTypedef { LC_DeclBase base; LC_AST *type; }; +struct LC_DeclAgg { LC_DeclBase base; LC_AST *first; LC_AST *last; }; +struct LC_DeclVar { LC_DeclBase base; LC_AST *expr; LC_AST *type; }; +struct LC_DeclConst { LC_DeclBase base; LC_AST *expr; }; +struct LC_DeclNote { LC_DeclBase base; LC_AST *expr; bool processed; }; // #c(``) in file note list +struct LC_GlobImport { LC_Intern name; LC_Intern path; bool resolved; LC_Decl *resolved_decl; }; + +struct LC_ASTRef { LC_ASTRef *next; LC_ASTRef *prev; LC_AST *ast; }; +struct LC_ASTRefList { LC_ASTRef *first; LC_ASTRef *last; }; +// clang-format on + +struct LC_TypeAndVal { + LC_Type *type; + union { + LC_Val v; + union { + LC_BigInt i; + double d; + LC_Intern name; + }; + }; +}; + +struct LC_AST { + LC_ASTKind kind; + uint32_t id; + LC_AST *next; + LC_AST *prev; + LC_AST *notes; + LC_Token *pos; + + LC_TypeAndVal const_val; + LC_Type *type; + union { + LC_ASTFile afile; + LC_ASTPackage apackage; + LC_ASTNoteList anote_list; + LC_ExprCompo anote; + LC_Val eatom; + LC_ExprIdent eident; + LC_ExprUnary eunary; + LC_ExprBinary ebinary; + LC_ExprField efield; + LC_ExprIndex eindex; + LC_ExprCompo ecompo; + LC_ExprCompoItem ecompo_item; + LC_ExprType etype; + LC_ExprCast ecast; + LC_ExprNote enote; + LC_StmtBlock sblock; + LC_StmtFor sfor; + LC_StmtDefer sdefer; + LC_StmtSwitch sswitch; + LC_StmtCase scase; + LC_StmtIf sif; + LC_StmtBreak sbreak; + LC_StmtBreak scontinue; + LC_StmtAssign sassign; + LC_StmtExpr sexpr; + LC_StmtVar svar; + LC_StmtConst sconst; + LC_StmtReturn sreturn; + LC_StmtNote snote; + LC_ExprIdent tident; + LC_TypespecArray tarray; + LC_TypespecArray tpointer; + LC_TypespecProc tproc; + LC_TypespecAggMem tagg_mem; + LC_TypespecProcArg tproc_arg; + LC_DeclBase dbase; + LC_DeclProc dproc; + LC_DeclTypedef dtypedef; + LC_DeclAgg dagg; + LC_DeclVar dvar; + LC_DeclConst dconst; + LC_DeclNote dnote; + LC_GlobImport gimport; + }; +}; + +struct LC_TypeArray { + LC_Type *base; + int size; +}; + +struct LC_TypePtr { + LC_Type *base; +}; + +struct LC_TypeMemberList { + LC_TypeMember *first; + LC_TypeMember *last; + int count; +}; + +struct LC_TypeProc { + LC_TypeMemberList args; + LC_Type *ret; + bool vargs; + bool vargs_any_promotion; +}; + +struct LC_TypeAgg { + LC_TypeMemberList mems; +}; + +struct LC_Type { + LC_TypeKind kind; + int size; + int align; + int is_unsigned; + int id; + int padding; + LC_Decl *decl; + union { + LC_TypeArray tarray; + LC_TypePtr tptr; + LC_TypeProc tproc; + LC_TypeAgg tagg; + LC_Type *tbase; + LC_Type *tutdefault; + }; +}; + +struct LC_TypeMember { + LC_TypeMember *next; + LC_TypeMember *prev; + LC_Intern name; + LC_Type *type; + LC_AST *default_value_expr; + LC_AST *ast; + int offset; +}; + +struct LC_Decl { + LC_DeclKind kind; + LC_DeclState state; + uint8_t is_foreign; + + LC_Decl *next; + LC_Decl *prev; + LC_Intern name; + LC_Intern foreign_name; + LC_AST *ast; + LC_AST *package; + + LC_TypeMember *type_member; + DeclScope *scope; + LC_Decl *typedef_renamed_type_decl; + union { + LC_TypeAndVal val; + struct { + LC_Type *type; + LC_Val v; + }; + }; +}; + +typedef struct { + LC_Arena *arena; + LC_AST **data; + int cap; + int len; +} LC_ASTArray; + +typedef struct LC_ASTWalker LC_ASTWalker; +typedef void LC_ASTWalkProc(LC_ASTWalker *, LC_AST *); +struct LC_ASTWalker { + LC_ASTArray stack; + + int inside_builtin; + int inside_discarded; + int inside_note; + + uint8_t visit_discarded; + uint8_t visit_notes; + uint8_t depth_first; + uint8_t dont_recurse; // breathfirst only + void *user_data; + LC_ASTWalkProc *proc; +}; + +struct LC_DeclStack { + LC_Decl **stack; + int len; + int cap; +}; + +union LC_TokenVal { + LC_BigInt i; + double f64; + LC_Intern ident; +}; + +struct LC_Token { + LC_TokenKind kind; + int line; + int column; + int len; + char *str; + LC_Lex *lex; + union { + LC_BigInt i; + double f64; + LC_Intern ident; + }; +}; + +struct LC_Lex { + char *at; + char *begin; + LC_Intern file; + int line; + int column; + LC_Token *tokens; + int token_count; + bool insert_semicolon; +}; + +struct LC_Parser { + LC_Token *at; + LC_Token *begin; + LC_Token *end; + LC_Lex *x; +}; + +struct LC_Resolver { + LC_Type *compo_context_type; + int compo_context_array_size; + LC_Type *expected_ret_type; + LC_AST *package; + DeclScope *active_scope; + LC_DeclStack locals; + LC_Map duplicate_map; // currently used for finding duplicates in compos + LC_ASTArray stmt_block_stack; +}; + +typedef struct LC_Printer LC_Printer; +struct LC_Printer { + LC_Arena *arena; + LC_StringList list; + int indent; + LC_Intern last_filename; + int last_line_num; + LC_ASTArray out_block_stack; +}; + +const int LC_OPF_Error = 1; +const int LC_OPF_UTConst = 2; +const int LC_OPF_LValue = 4; +const int LC_OPF_Const = 8; +const int LC_OPF_Returned = 16; + +// warning: I introduced a null compare using the values in the operand +// make sure to revisit that when modifying the struct +typedef struct { + int flags; + union { + LC_Decl *decl; + LC_TypeAndVal val; + struct { + LC_Type *type; + LC_Val v; + }; + }; +} LC_Operand; + +typedef enum { + LC_ARCH_Invalid, + LC_ARCH_X64, + LC_ARCH_X86, + LC_ARCH_Count, +} LC_ARCH; + +typedef enum { + LC_GEN_Invalid, + LC_GEN_C, + LC_GEN_Count, +} LC_GEN; + +typedef enum { + LC_OS_Invalid, + LC_OS_WINDOWS, + LC_OS_LINUX, + LC_OS_MAC, + LC_OS_Count, +} LC_OS; + +typedef struct { + LC_String path; + LC_String content; + int line; +} LoadedFile; + +typedef enum { + LC_OPResult_Error, + LC_OPResult_Ok, + LC_OPResult_Bool, +} LC_OPResult; + +typedef struct { + int left; + int right; +} LC_BindingPower; + +typedef enum { + LC_Binding_Prefix, + LC_Binding_Infix, + LC_Binding_Postfix, +} LC_Binding; + +typedef enum { + LC_CmpRes_LT, + LC_CmpRes_GT, + LC_CmpRes_EQ, +} LC_CmpRes; + +typedef struct LC_FileIter LC_FileIter; +struct LC_FileIter { + bool is_valid; + bool is_directory; + LC_String absolute_path; + LC_String relative_path; + LC_String filename; + + LC_String path; + LC_Arena *arena; + union { + struct LC_Win32_FileIter *w32; + void *dir; + }; +}; + +#define LC_LIST_KEYWORDS \ + X(for) \ + X(import) \ + X(if) \ + X(else) \ + X(return) \ + X(defer) \ + X(continue) \ + X(break) \ + X(default) \ + X(case) \ + X(typedef) \ + X(switch) \ + X(proc) \ + X(struct) \ + X(union) \ + X(addptr) \ + X(and) \ + X(or) \ + X(bit_and) \ + X(bit_or) \ + X(bit_xor) \ + X(not ) \ + X(true) \ + X(false) + +#define LC_LIST_INTERNS \ + X(foreign, true) \ + X(api, true) \ + X(weak, true) \ + X(c, true) \ + X(fallthrough, true) \ + X(packed, true) \ + X(not_init, true) \ + X(unused, true) \ + X(static_assert, true) \ + X(str, true) \ + X(thread_local, true) \ + X(dont_mangle, true) \ + X(build_if, true) \ + X(Any, false) \ + X(main, false) \ + X(debug_break, false) \ + X(sizeof, false) \ + X(alignof, false) \ + X(typeof, false) \ + X(lengthof, false) \ + X(offsetof, false) + +#define LC_LIST_TYPES \ + X(char, false) \ + X(uchar, true) \ + X(short, false) \ + X(ushort, true) \ + X(bool, false) \ + X(int, false) \ + X(uint, true) \ + X(long, false) \ + X(ulong, true) \ + X(llong, false) \ + X(ullong, true) \ + X(float, false) \ + X(double, false) + +struct LC_Lang { + LC_Arena *arena; + + LC_Arena *lex_arena; + + LC_Arena *ast_arena; + int ast_count; + + LC_Arena *decl_arena; + int decl_count; + + LC_Arena *type_arena; + int type_count; + + int errors; + + int typeids; + LC_Map type_map; + + LC_AST *builtin_package; + LC_Resolver resolver; + LC_Parser *parser; + + // Package registry + LC_AST *fpackage; + LC_AST *lpackage; + LC_Intern first_package; + LC_ASTRefList ordered_packages; + LC_StringList package_dirs; + + LC_Map interns; + LC_Map declared_notes; + LC_Map foreign_names; + LC_Map implicit_any; + unsigned unique_counter; + + LC_Intern first_keyword; + LC_Intern last_keyword; + +#define X(x) LC_Intern k##x; + LC_LIST_KEYWORDS +#undef X + +#define X(x, declare) LC_Intern i##x; + LC_LIST_INTERNS +#undef X + + LC_Type types[14]; // be careful when changing +#define X(TNAME, IS_UNSIGNED) LC_Type *t##TNAME; + LC_LIST_TYPES +#undef X + + // When adding new special pointer types make sure to + // also update LC_SetPointerSizeAndAlign so that it properly + // updates the types after LC_LangBegin + int pointer_size; + int pointer_align; + LC_Type *tvoid; + LC_Type *tpvoid; + LC_Type *tpchar; + + LC_Type ttstring; + LC_Type *tstring; + LC_Type *tuntypednil; + LC_Type *tuntypedbool; + LC_Type *tuntypedint; + LC_Type ttuntypedfloat; + LC_Type *tuntypedfloat; + LC_Type ttuntypedstring; + LC_Type *tuntypedstring; + LC_Type ttany; + LC_Type *tany; + + LC_Token NullToken; + LC_AST NullAST; + LC_Token BuiltinToken; + LC_Lex NullLEX; + + LC_Printer printer; + LC_Parser quick_parser; + + // @configurable + LC_ARCH arch; + LC_GEN gen; + LC_OS os; + + bool emit_line_directives; + bool breakpoint_on_error; + bool use_colored_terminal_output; + + bool (*on_decl_parsed)(bool discarded, LC_AST *n); // returning 'true' from here indicates that declaration should be discarded + void (*on_expr_parsed)(LC_AST *n); + void (*on_stmt_parsed)(LC_AST *n); + void (*on_typespec_parsed)(LC_AST *n); + void (*on_decl_type_resolved)(LC_Decl *decl); + void (*on_proc_body_resolved)(LC_Decl *decl); + void (*on_expr_resolved)(LC_AST *expr, LC_Operand *op); + void (*on_stmt_resolved)(LC_AST *n); + void (*before_call_args_resolved)(LC_AST *n, LC_Type *type); + void (*on_file_load)(LC_AST *package, LoadedFile *file); + void (*on_message)(LC_Token *pos, char *str, int len); // pos and x can be null + void (*on_fatal_error)(void); + void *user_data; +}; + +extern LC_THREAD_LOCAL LC_Lang *L; +extern LC_Operand LC_OPNull; + +// +// Main @api +// + +LC_FUNCTION LC_Lang *LC_LangAlloc(void); // This allocates memory for LC_Lang which can be used to register callbacks and set configurables +LC_FUNCTION void LC_LangBegin(LC_Lang *l); // Prepare for compilation: init types, init builtins, set architecture variables stuff like that +LC_FUNCTION void LC_LangEnd(LC_Lang *lang); // Deallocate language memory + +LC_FUNCTION void LC_RegisterPackageDir(char *dir); // Add a package search directory +LC_FUNCTION LC_ASTRefList LC_ResolvePackageByName(LC_Intern name); // Fully resolve a package and all it's dependences +LC_FUNCTION LC_String LC_GenerateUnityBuild(LC_ASTRefList packages); // Generate the C program and return as a string + +// Smaller passes for AST modification +LC_FUNCTION void LC_ParsePackagesUsingRegistry(LC_Intern name); // These 3 functions are equivalent to LC_ResolvePackageByName, +LC_FUNCTION void LC_OrderAndResolveTopLevelDecls(LC_Intern name); // you can use them to hook into the compilation process - you can modify the AST +LC_FUNCTION void LC_ResolveAllProcBodies(void); // before resolving or use resolved top declarations to generate some code. + // The Parse and Order functions can be called multiple times to accommodate this. + +// Extended pass / optimization +LC_FUNCTION void LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls(void); // Extended pass that you can execute once you have resolved all packages + +// These three functions are used to implement LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls +LC_FUNCTION LC_Map LC_CountDeclRefs(LC_Arena *arena); +LC_FUNCTION void LC_RemoveUnreferencedGlobalDecls(LC_Map *map_of_visits); +LC_FUNCTION void LC_ErrorOnUnreferencedLocals(LC_Map *map_of_visits); + +// Notes +LC_FUNCTION void LC_DeclareNote(LC_Intern intern); +LC_FUNCTION bool LC_IsNoteDeclared(LC_Intern intern); +LC_FUNCTION LC_AST *LC_HasNote(LC_AST *ast, LC_Intern i); + +// Quick parse functions +LC_FUNCTION LC_AST *LC_ParseStmtf(const char *str, ...); +LC_FUNCTION LC_AST *LC_ParseExprf(const char *str, ...); +LC_FUNCTION LC_AST *LC_ParseDeclf(const char *str, ...); + +// AST Walking and copy +LC_FUNCTION LC_AST *LC_CopyAST(LC_Arena *arena, LC_AST *n); // Deep copy the AST +LC_FUNCTION LC_ASTArray LC_FlattenAST(LC_Arena *arena, LC_AST *n); // This walks the passed down tree and generates a flat array of pointers, very nice to use for traversing AST +LC_FUNCTION void LC_WalkAST(LC_ASTWalker *ctx, LC_AST *n); +LC_FUNCTION LC_ASTWalker LC_GetDefaultWalker(LC_Arena *arena, LC_ASTWalkProc *proc); + +LC_FUNCTION void LC_ReserveAST(LC_ASTArray *arr, int size); +LC_FUNCTION void LC_PushAST(LC_ASTArray *arr, LC_AST *ast); +LC_FUNCTION void LC_PopAST(LC_ASTArray *arr); +LC_FUNCTION LC_AST *LC_GetLastAST(LC_ASTArray *arr); + +// Interning API +LC_FUNCTION LC_Intern LC_ILit(char *str); +LC_FUNCTION void LC_InternTokens(LC_Lex *x); + +LC_FUNCTION LC_Intern LC_InternStrLen(char *str, int len); +LC_FUNCTION LC_Intern LC_GetUniqueIntern(const char *name_for_debug); +LC_FUNCTION char *LC_GetUniqueName(const char *name_for_debug); + +// +// Package functions +// +LC_FUNCTION LC_Operand LC_ImportPackage(LC_AST *import, LC_AST *dst, LC_AST *src); +LC_FUNCTION LC_Intern LC_MakePackageNameFromPath(LC_String path); +LC_FUNCTION bool LC_PackageNameValid(LC_Intern name); +LC_FUNCTION bool LC_PackageNameDuplicate(LC_Intern name); +LC_FUNCTION void LC_AddPackageToList(LC_AST *n); +LC_FUNCTION LC_AST *LC_RegisterPackage(LC_String path); +LC_FUNCTION void LC_AddFileToPackage(LC_AST *pkg, LC_AST *f); +LC_FUNCTION LC_AST *LC_FindImportInRefList(LC_ASTRefList *arr, LC_Intern path); +LC_FUNCTION void LC_AddASTToRefList(LC_ASTRefList *refs, LC_AST *ast); +LC_FUNCTION LC_ASTRefList LC_GetPackageImports(LC_AST *package); +LC_FUNCTION LC_AST *LC_GetPackageByName(LC_Intern name); +LC_FUNCTION LC_StringList LC_ListFilesInPackage(LC_Arena *arena, LC_String path); +LC_FUNCTION LoadedFile LC_ReadFileHook(LC_AST *package, LC_String path); +LC_FUNCTION void LC_ParsePackage(LC_AST *n); +LC_FUNCTION void LC_AddOrderedPackageToRefList(LC_AST *n); +LC_FUNCTION LC_AST *LC_OrderPackagesAndBasicResolve(LC_AST *pos, LC_Intern name); +LC_FUNCTION void LC_AddSingleFilePackage(LC_Intern name, LC_String path); + +// +// Lexing functions +// +LC_FUNCTION LC_Lex *LC_LexStream(char *file, char *str, int line); +LC_FUNCTION LC_String LC_GetTokenLine(LC_Token *token); + +LC_FUNCTION void LC_LexingError(LC_Token *pos, const char *str, ...); +LC_FUNCTION bool LC_IsAssign(LC_TokenKind kind); +LC_FUNCTION bool LC_IsHexDigit(char c); +LC_FUNCTION bool LC_IsBinDigit(char c); +LC_FUNCTION uint64_t LC_MapCharToNumber(char c); +LC_FUNCTION uint64_t LC_GetEscapeCode(char c); +LC_FUNCTION LC_String LC_GetEscapeString(char c); +LC_FUNCTION void LC_LexAdvance(LC_Lex *x); +LC_FUNCTION void LC_EatWhitespace(LC_Lex *x); +LC_FUNCTION void LC_EatIdent(LC_Lex *x); +LC_FUNCTION void LC_SetTokenLen(LC_Lex *x, LC_Token *t); +LC_FUNCTION void LC_EatUntilIncluding(LC_Lex *x, char c); +LC_FUNCTION LC_BigInt LC_LexBigInt(char *string, int len, uint64_t base); +LC_FUNCTION void LC_LexNestedComments(LC_Lex *x, LC_Token *t); +LC_FUNCTION void LC_LexStringLiteral(LC_Lex *x, LC_Token *t, LC_TokenKind kind); +LC_FUNCTION void LC_LexUnicodeLiteral(LC_Lex *x, LC_Token *t); +LC_FUNCTION void LC_LexIntOrFloat(LC_Lex *x, LC_Token *t); +LC_FUNCTION void LC_LexCase2(LC_Lex *x, LC_Token *t, LC_TokenKind tk0, char c, LC_TokenKind tk1); +LC_FUNCTION void LC_LexCase3(LC_Lex *x, LC_Token *t, LC_TokenKind tk, char c0, LC_TokenKind tk0, char c1, LC_TokenKind tk1); +LC_FUNCTION void LC_LexCase4(LC_Lex *x, LC_Token *t, LC_TokenKind tk, char c0, LC_TokenKind tk0, char c1, LC_TokenKind tk1, char c2, LC_TokenKind tk2); +LC_FUNCTION void LC_LexNext(LC_Lex *x, LC_Token *t); + +// +// LC_Map API +// +LC_FUNCTION void LC_MapReserve(LC_Map *map, int size); +LC_FUNCTION int LC_NextPow2(int v); +LC_FUNCTION LC_MapEntry *LC_GetMapEntryEx(LC_Map *map, uint64_t key); +LC_FUNCTION bool LC_InsertWithoutReplace(LC_Map *map, void *key, void *value); +LC_FUNCTION LC_MapEntry *LC_InsertMapEntry(LC_Map *map, uint64_t key, uint64_t value); +LC_FUNCTION LC_MapEntry *LC_GetMapEntry(LC_Map *map, uint64_t key); +LC_FUNCTION void LC_MapInsert(LC_Map *map, LC_String keystr, void *value); +LC_FUNCTION void *LC_MapGet(LC_Map *map, LC_String keystr); +LC_FUNCTION void LC_MapInsertU64(LC_Map *map, uint64_t key, void *value); +LC_FUNCTION void *LC_MapGetU64(LC_Map *map, uint64_t key); +LC_FUNCTION void *LC_MapGetP(LC_Map *map, void *key); +LC_FUNCTION void LC_MapInsertP(LC_Map *map, void *key, void *value); +LC_FUNCTION void LC_MapClear(LC_Map *map); + +// +// LC_AST Creation +// +LC_FUNCTION LC_AST *LC_CreateAST(LC_Token *pos, LC_ASTKind kind); +LC_FUNCTION LC_AST *LC_CreateUnary(LC_Token *pos, LC_TokenKind op, LC_AST *expr); +LC_FUNCTION LC_AST *LC_CreateBinary(LC_Token *pos, LC_AST *left, LC_AST *right, LC_TokenKind op); +LC_FUNCTION LC_AST *LC_CreateIndex(LC_Token *pos, LC_AST *left, LC_AST *index); + +LC_FUNCTION bool LC_ContainsCallExpr(LC_AST *ast); +LC_FUNCTION void LC_SetASTPosOnAll(LC_AST *n, LC_Token *pos); +LC_FUNCTION bool LC_ContainsCBuiltin(LC_AST *n); + +// +// LC_Type functions +// +LC_FUNCTION void LC_SetPointerSizeAndAlign(int size, int align); +LC_FUNCTION LC_Type *LC_CreateType(LC_TypeKind kind); +LC_FUNCTION LC_Type *LC_CreateTypedef(LC_Decl *decl, LC_Type *base); +LC_FUNCTION LC_Type *LC_CreatePointerType(LC_Type *type); +LC_FUNCTION LC_Type *LC_CreateArrayType(LC_Type *type, int size); +LC_FUNCTION LC_Type *LC_CreateProcType(LC_TypeMemberList args, LC_Type *ret, bool has_vargs, bool has_vargs_any_promotion); +LC_FUNCTION LC_Type *LC_CreateIncompleteType(LC_Decl *decl); +LC_FUNCTION LC_Type *LC_CreateUntypedIntEx(LC_Type *base, LC_Decl *decl); +LC_FUNCTION LC_Type *LC_CreateUntypedInt(LC_Type *base); +LC_FUNCTION LC_TypeMember *LC_AddTypeToList(LC_TypeMemberList *list, LC_Intern name, LC_Type *type, LC_AST *ast); +LC_FUNCTION int LC_GetLevelsOfIndirection(LC_Type *type); +LC_FUNCTION bool LC_BigIntFits(LC_BigInt i, LC_Type *type); +LC_FUNCTION LC_Type *LC_StripPointer(LC_Type *type); + +// +// Parsing functions +// +LC_FUNCTION LC_AST *LC_ParseFile(LC_AST *package, char *filename, char *content, int line); +LC_FUNCTION LC_AST *LC_ParseTokens(LC_AST *package, LC_Lex *x); + +LC_FUNCTION LC_Parser LC_MakeParser(LC_Lex *x); +LC_FUNCTION LC_Parser *LC_MakeParserQuick(char *str); +LC_FUNCTION LC_Token *LC_Next(void); +LC_FUNCTION LC_Token *LC_Get(void); +LC_FUNCTION LC_Token *LC_GetI(int i); +LC_FUNCTION LC_Token *LC_Is(LC_TokenKind kind); +LC_FUNCTION LC_Token *LC_IsKeyword(LC_Intern intern); +LC_FUNCTION LC_Token *LC_Match(LC_TokenKind kind); +LC_FUNCTION LC_Token *LC_MatchKeyword(LC_Intern intern); +LC_FUNCTION LC_BindingPower LC_MakeBP(int left, int right); +LC_FUNCTION LC_BindingPower LC_GetBindingPower(LC_Binding binding, LC_TokenKind kind); +LC_FUNCTION LC_AST *LC_ParseExprEx(int min_bp); +LC_FUNCTION LC_AST *LC_ParseCompo(LC_Token *pos, LC_AST *left); +LC_FUNCTION LC_AST *LC_ParseExpr(void); +LC_FUNCTION LC_AST *LC_ParseProcType(LC_Token *pos); +LC_FUNCTION LC_AST *LC_ParseType(void); +LC_FUNCTION LC_AST *LC_ParseForStmt(LC_Token *pos); +LC_FUNCTION LC_AST *LC_ParseSwitchStmt(LC_Token *pos); +LC_FUNCTION LC_AST *LC_ParseStmt(bool check_semicolon); +LC_FUNCTION LC_AST *LC_ParseStmtBlock(int flags); +LC_FUNCTION LC_AST *LC_ParseProcDecl(LC_Token *name); +LC_FUNCTION LC_AST *LC_ParseStruct(LC_ASTKind kind, LC_Token *ident); +LC_FUNCTION LC_AST *LC_ParseTypedef(LC_Token *ident); +LC_FUNCTION LC_AST *LC_CreateNote(LC_Token *pos, LC_Intern ident); +LC_FUNCTION LC_AST *LC_ParseNote(void); +LC_FUNCTION LC_AST *LC_ParseNotes(void); +LC_FUNCTION bool LC_ResolveBuildIf(LC_AST *build_if); +LC_FUNCTION LC_AST *LC_ParseImport(void); +LC_FUNCTION LC_AST *LC_ParseDecl(LC_AST *file); +LC_FUNCTION bool LC_EatUntilNextValidDecl(void); +LC_FUNCTION bool LC_ParseHashBuildOn(LC_AST *n); +LC_FUNCTION LC_AST *LC_ParseFileEx(LC_AST *package); + +// +// Resolution functions +// +LC_FUNCTION void LC_AddDecl(LC_DeclStack *scope, LC_Decl *decl); +LC_FUNCTION void LC_InitDeclStack(LC_DeclStack *stack, int size); +LC_FUNCTION LC_DeclStack *LC_CreateDeclStack(int size); +LC_FUNCTION LC_Decl *LC_FindDeclOnStack(LC_DeclStack *scp, LC_Intern name); + +LC_FUNCTION DeclScope *LC_CreateScope(int size); +LC_FUNCTION LC_Decl *LC_CreateDecl(LC_DeclKind kind, LC_Intern name, LC_AST *n); +LC_FUNCTION LC_Operand LC_AddDeclToScope(DeclScope *scp, LC_Decl *decl); +LC_FUNCTION LC_Decl *LC_FindDeclInScope(DeclScope *scope, LC_Intern name); +LC_FUNCTION LC_Operand LC_ThereIsNoDecl(DeclScope *scp, LC_Decl *decl, bool check_locals); +LC_FUNCTION void LC_MarkDeclError(LC_Decl *decl); +LC_FUNCTION LC_Decl *LC_GetLocalOrGlobalDecl(LC_Intern name); +LC_FUNCTION LC_Operand LC_PutGlobalDecl(LC_Decl *decl); +LC_FUNCTION LC_Operand LC_CreateLocalDecl(LC_DeclKind kind, LC_Intern name, LC_AST *ast); +LC_FUNCTION LC_Decl *LC_AddConstIntDecl(char *key, int64_t value); +LC_FUNCTION LC_Decl *LC_GetBuiltin(LC_Intern name); +LC_FUNCTION void LC_AddBuiltinConstInt(char *key, int64_t value); + +LC_FUNCTION void LC_RegisterDeclsFromFile(LC_AST *file); +LC_FUNCTION void LC_ResolveDeclsFromFile(LC_AST *file); +LC_FUNCTION void LC_PackageDecls(LC_AST *package); +LC_FUNCTION void LC_ResolveProcBodies(LC_AST *package); +LC_FUNCTION void LC_ResolveIncompleteTypes(LC_AST *package); +LC_FUNCTION LC_Operand LC_ResolveNote(LC_AST *n, bool is_decl); +LC_FUNCTION LC_Operand LC_ResolveProcBody(LC_Decl *decl); +LC_FUNCTION LC_ResolvedCompoItem *LC_AddResolvedCallItem(LC_ResolvedCompo *list, LC_TypeMember *t, LC_AST *comp, LC_AST *expr); +LC_FUNCTION LC_Operand LC_ResolveCompoCall(LC_AST *n, LC_Type *type); +LC_FUNCTION LC_Operand LC_ResolveCompoAggregate(LC_AST *n, LC_Type *type); +LC_FUNCTION LC_ResolvedCompoArrayItem *LC_AddResolvedCompoArrayItem(LC_ResolvedArrayCompo *arr, int index, LC_AST *comp); +LC_FUNCTION LC_Operand LC_ResolveCompoArray(LC_AST *n, LC_Type *type); +LC_FUNCTION LC_Operand LC_ResolveTypeOrExpr(LC_AST *n); +LC_FUNCTION LC_Operand LC_ExpectBuiltinWithOneArg(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveBuiltin(LC_AST *n); +LC_FUNCTION bool LC_TryTyping(LC_AST *n, LC_Operand op); +LC_FUNCTION bool LC_TryDefaultTyping(LC_AST *n, LC_Operand *o); +LC_FUNCTION LC_Operand LC_ResolveNameInScope(LC_AST *n, LC_Decl *parent_decl); +LC_FUNCTION LC_Operand LC_ResolveExpr(LC_AST *expr); +LC_FUNCTION LC_Operand LC_ResolveExprAndPushCompoContext(LC_AST *expr, LC_Type *type); +LC_FUNCTION LC_Operand LC_ResolveExprEx(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveStmtBlock(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveVarDecl(LC_Decl *decl); +LC_FUNCTION LC_Operand LC_MakeSureNoDeferBlock(LC_AST *n, char *str); +LC_FUNCTION LC_Operand LC_MakeSureInsideLoopBlock(LC_AST *n, char *str); +LC_FUNCTION LC_Operand LC_MatchLabeledBlock(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveStmt(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveConstDecl(LC_Decl *decl); +LC_FUNCTION LC_Operand LC_ResolveName(LC_AST *pos, LC_Intern intern); +LC_FUNCTION LC_Operand LC_ResolveConstInt(LC_AST *n, LC_Type *int_type, uint64_t *out_size); +LC_FUNCTION LC_Operand LC_ResolveType(LC_AST *n); +LC_FUNCTION LC_Operand LC_ResolveBinaryExpr(LC_AST *n, LC_Operand l, LC_Operand r); +LC_FUNCTION LC_Operand LC_ResolveTypeVargs(LC_AST *pos, LC_Operand v); +LC_FUNCTION LC_Operand LC_ResolveTypeCast(LC_AST *pos, LC_Operand t, LC_Operand v); +LC_FUNCTION LC_Operand LC_ResolveTypeVarDecl(LC_AST *pos, LC_Operand t, LC_Operand v); +LC_FUNCTION LC_Operand LC_ResolveTypeAggregate(LC_AST *pos, LC_Type *type); + +LC_FUNCTION LC_Operand LC_OPError(void); +LC_FUNCTION LC_Operand LC_OPConstType(LC_Type *type); +LC_FUNCTION LC_Operand LC_OPDecl(LC_Decl *decl); +LC_FUNCTION LC_Operand LC_OPType(LC_Type *type); +LC_FUNCTION LC_Operand LC_OPLValueAndType(LC_Type *type); +LC_FUNCTION LC_Operand LC_ConstCastFloat(LC_AST *pos, LC_Operand op); +LC_FUNCTION LC_Operand LC_ConstCastInt(LC_AST *pos, LC_Operand op); +LC_FUNCTION LC_Operand LC_OPInt(int64_t v); +LC_FUNCTION LC_Operand LC_OPIntT(LC_Type *type, int64_t v); +LC_FUNCTION LC_Operand LC_OPModDefaultUT(LC_Operand val); +LC_FUNCTION LC_Operand LC_OPModType(LC_Operand op, LC_Type *type); +LC_FUNCTION LC_Operand LC_OPModBool(LC_Operand op); +LC_FUNCTION LC_Operand LC_OPModBoolV(LC_Operand op, int v); +LC_FUNCTION LC_Operand LC_EvalBinary(LC_AST *pos, LC_Operand a, LC_TokenKind op, LC_Operand b); +LC_FUNCTION LC_Operand LC_EvalUnary(LC_AST *pos, LC_TokenKind op, LC_Operand a); +LC_FUNCTION LC_OPResult LC_IsBinaryExprValidForType(LC_TokenKind op, LC_Type *type); +LC_FUNCTION LC_OPResult LC_IsUnaryOpValidForType(LC_TokenKind op, LC_Type *type); +LC_FUNCTION LC_OPResult LC_IsAssignValidForType(LC_TokenKind op, LC_Type *type); + +// +// Error +// +LC_FUNCTION void LC_IgnoreMessage(LC_Token *pos, char *str, int len); +LC_FUNCTION void LC_SendErrorMessage(LC_Token *pos, LC_String s8); +LC_FUNCTION void LC_SendErrorMessagef(LC_Lex *x, LC_Token *pos, const char *str, ...); +LC_FUNCTION LC_AST *LC_ReportParseError(LC_Token *pos, const char *str, ...); +LC_FUNCTION LC_Operand LC_ReportASTError(LC_AST *n, const char *str, ...); +LC_FUNCTION LC_Operand LC_ReportASTErrorEx(LC_AST *n1, LC_AST *n2, const char *str, ...); +LC_FUNCTION void LC_HandleFatalError(void); + +#define LC_ASSERT(n, cond) \ + if (!(cond)) { \ + LC_ReportASTError(n, "internal compiler error: assert condition failed: %s, inside of %s", #cond, __FUNCTION__); \ + LC_HandleFatalError(); \ + } + +// +// Code generation and printing helpers +// +LC_FUNCTION LC_StringList *LC_BeginStringGen(LC_Arena *arena); +LC_FUNCTION LC_String LC_EndStringGen(LC_Arena *arena); + +// clang-format off +#define LC_Genf(...) LC_Addf(L->printer.arena, &L->printer.list, __VA_ARGS__) +#define LC_GenLinef(...) do { LC_Genf("\n"); LC_GenIndent(); LC_Genf(__VA_ARGS__); } while (0) +// clang-format on + +LC_FUNCTION void LC_GenIndent(void); +LC_FUNCTION void LC_GenLine(void); +LC_FUNCTION char *LC_Strf(const char *str, ...); +LC_FUNCTION char *LC_GenLCType(LC_Type *type); +LC_FUNCTION char *LC_GenLCTypeVal(LC_TypeAndVal v); +LC_FUNCTION char *LC_GenLCAggName(LC_Type *t); +LC_FUNCTION void LC_GenLCNode(LC_AST *n); + +// C code generation +LC_FUNCTION void LC_GenCHeader(LC_AST *package); +LC_FUNCTION void LC_GenCImpl(LC_AST *package); + +LC_FUNCTION void LC_GenCLineDirective(LC_AST *node); +LC_FUNCTION void LC_GenLastCLineDirective(void); +LC_FUNCTION void LC_GenCLineDirectiveNum(int num); + +LC_FUNCTION char *LC_GenCTypeParen(char *str, char c); +LC_FUNCTION char *LC_GenCType(LC_Type *type, char *str); +LC_FUNCTION LC_Intern LC_GetStringFromSingleArgNote(LC_AST *note); +LC_FUNCTION void LC_GenCCompound(LC_AST *n); +LC_FUNCTION void LC_GenCString(char *s, LC_Type *type); +LC_FUNCTION char *LC_GenCVal(LC_TypeAndVal v, LC_Type *type); +LC_FUNCTION void LC_GenCExpr(LC_AST *n); +LC_FUNCTION void LC_GenCNote(LC_AST *note); +LC_FUNCTION void LC_GenCVarExpr(LC_AST *n, bool is_declaration); +LC_FUNCTION void LC_GenCDefers(LC_AST *block); +LC_FUNCTION void LC_GenCDefersLoopBreak(LC_AST *n); +LC_FUNCTION void LC_GenCDefersReturn(LC_AST *n); +LC_FUNCTION void LC_GenCStmt2(LC_AST *n, int flags); +LC_FUNCTION void LC_GenCStmt(LC_AST *n); +LC_FUNCTION void LC_GenCExprParen(LC_AST *expr); +LC_FUNCTION void LC_GenCStmtBlock(LC_AST *n); +LC_FUNCTION void LC_GenCProcDecl(LC_Decl *decl); +LC_FUNCTION void LC_GenCAggForwardDecl(LC_Decl *decl); +LC_FUNCTION void LC_GenCTypeDecl(LC_Decl *decl); +LC_FUNCTION void LC_GenCVarFDecl(LC_Decl *decl); + +// +// Inline helpers +// +static inline bool LC_IsUTInt(LC_Type *x) { return x->kind == LC_TypeKind_UntypedInt; } +static inline bool LC_IsUTFloat(LC_Type *x) { return x->kind == LC_TypeKind_UntypedFloat; } +static inline bool LC_IsUTStr(LC_Type *x) { return x->kind == LC_TypeKind_UntypedString; } +static inline bool LC_IsUntyped(LC_Type *x) { return (x)->kind >= LC_TypeKind_UntypedInt && x->kind <= LC_TypeKind_UntypedString; } + +static inline bool LC_IsNum(LC_Type *x) { return x->kind >= LC_TypeKind_char && x->kind <= LC_TypeKind_double; } +static inline bool LC_IsInt(LC_Type *x) { return (x->kind >= LC_TypeKind_char && x->kind <= LC_TypeKind_ullong) || LC_IsUTInt(x); } +static inline bool LC_IsIntLike(LC_Type *x) { return LC_IsInt(x) || x->kind == LC_TypeKind_Pointer || x->kind == LC_TypeKind_Proc; } +static inline bool LC_IsFloat(LC_Type *x) { return ((x)->kind == LC_TypeKind_float || (x->kind == LC_TypeKind_double)) || LC_IsUTFloat(x); } +static inline bool LC_IsSmallerThenInt(LC_Type *x) { return x->kind < LC_TypeKind_int; } + +static inline bool LC_IsAggType(LC_Type *x) { return ((x)->kind == LC_TypeKind_Struct || (x)->kind == LC_TypeKind_Union); } +static inline bool LC_IsArray(LC_Type *x) { return (x)->kind == LC_TypeKind_Array; } +static inline bool LC_IsProc(LC_Type *x) { return (x)->kind == LC_TypeKind_Proc; } +static inline bool LC_IsVoidPtr(LC_Type *x) { return (x) == L->tpvoid; } +static inline bool LC_IsPtr(LC_Type *x) { return (x)->kind == LC_TypeKind_Pointer; } +static inline bool LC_IsPtrLike(LC_Type *x) { return (x)->kind == LC_TypeKind_Pointer || x->kind == LC_TypeKind_Proc; } +static inline bool LC_IsStr(LC_Type *x) { return x == L->tpchar || x == L->tstring; } + +static inline bool LC_IsDecl(LC_AST *x) { return (x->kind >= LC_ASTKind_FirstDecl && x->kind <= LC_ASTKind_LastDecl); } +static inline bool LC_IsStmt(LC_AST *x) { return (x->kind >= LC_ASTKind_FirstStmt && x->kind <= LC_ASTKind_LastStmt); } +static inline bool LC_IsExpr(LC_AST *x) { return (x->kind >= LC_ASTKind_FirstExpr && x->kind <= LC_ASTKind_LastExpr); } +static inline bool LC_IsType(LC_AST *x) { return (x->kind >= LC_ASTKind_FirstTypespec && x->kind <= LC_ASTKind_LastTypespec); } +static inline bool LC_IsAgg(LC_AST *x) { return (x->kind == LC_ASTKind_DeclStruct || x->kind == LC_ASTKind_DeclUnion); } + +// I tried removing this because I thought it's redundant +// but this reminded me that "Untyped bool" can appear from normal expressions: (a == b) +// This is required, maybe there is a way around it, not sure +static inline bool LC_IsUTConst(LC_Operand op) { return (op.flags & LC_OPF_UTConst) != 0; } +static inline bool LC_IsConst(LC_Operand op) { return (op.flags & LC_OPF_Const) != 0; } +static inline bool LC_IsLValue(LC_Operand op) { return (op.flags & LC_OPF_LValue) != 0; } +static inline bool LC_IsError(LC_Operand op) { return (op.flags & LC_OPF_Error) != 0; } + +static inline LC_Type *LC_GetBase(LC_Type *x) { return (x)->tbase; } + +// +// Stringifying functions +// +LC_FUNCTION const char *LC_OSToString(LC_OS os); +LC_FUNCTION const char *LC_GENToString(LC_GEN os); +LC_FUNCTION const char *LC_ARCHToString(LC_ARCH arch); +LC_FUNCTION const char *LC_ASTKindToString(LC_ASTKind kind); +LC_FUNCTION const char *LC_TypeKindToString(LC_TypeKind kind); +LC_FUNCTION const char *LC_DeclKindToString(LC_DeclKind decl_kind); +LC_FUNCTION const char *LC_TokenKindToString(LC_TokenKind token_kind); +LC_FUNCTION const char *LC_TokenKindToOperator(LC_TokenKind token_kind); + +// +// bigint functions +// +LC_FUNCTION LC_BigInt LC_Bigint_u64(uint64_t val); +LC_FUNCTION uint64_t *LC_Bigint_ptr(LC_BigInt *big_int); +LC_FUNCTION size_t LC_Bigint_bits_needed(LC_BigInt *big_int); +LC_FUNCTION void LC_Bigint_init_unsigned(LC_BigInt *big_int, uint64_t value); +LC_FUNCTION void LC_Bigint_init_signed(LC_BigInt *dest, int64_t value); +LC_FUNCTION void LC_Bigint_init_bigint(LC_BigInt *dest, LC_BigInt *src); +LC_FUNCTION void LC_Bigint_negate(LC_BigInt *dest, LC_BigInt *source); +LC_FUNCTION size_t LC_Bigint_clz(LC_BigInt *big_int, size_t bit_count); +LC_FUNCTION bool LC_Bigint_eql(LC_BigInt a, LC_BigInt b); +LC_FUNCTION bool LC_Bigint_fits_in_bits(LC_BigInt *big_int, size_t bit_count, bool is_signed); +LC_FUNCTION uint64_t LC_Bigint_as_unsigned(LC_BigInt *bigint); +LC_FUNCTION void LC_Bigint_add(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_add_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed); +LC_FUNCTION void LC_Bigint_sub(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_sub_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed); +LC_FUNCTION void LC_Bigint_mul(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_mul_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed); +LC_FUNCTION void LC_Bigint_unsigned_division(LC_BigInt *op1, LC_BigInt *op2, LC_BigInt *Quotient, LC_BigInt *Remainder); +LC_FUNCTION void LC_Bigint_div_trunc(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_div_floor(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_rem(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_mod(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_or(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_and(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_xor(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_shl(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_shl_int(LC_BigInt *dest, LC_BigInt *op1, uint64_t shift); +LC_FUNCTION void LC_Bigint_shl_trunc(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed); +LC_FUNCTION void LC_Bigint_shr(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION void LC_Bigint_not(LC_BigInt *dest, LC_BigInt *op, size_t bit_count, bool is_signed); +LC_FUNCTION void LC_Bigint_truncate(LC_BigInt *dst, LC_BigInt *op, size_t bit_count, bool is_signed); +LC_FUNCTION LC_CmpRes LC_Bigint_cmp(LC_BigInt *op1, LC_BigInt *op2); +LC_FUNCTION char *LC_Bigint_str(LC_BigInt *bigint, uint64_t base); +LC_FUNCTION int64_t LC_Bigint_as_signed(LC_BigInt *bigint); +LC_FUNCTION LC_CmpRes LC_Bigint_cmp_zero(LC_BigInt *op); +LC_FUNCTION double LC_Bigint_as_float(LC_BigInt *bigint); + +// +// Unicode API +// +struct LC_UTF32Result { + uint32_t out_str; + int advance; + int error; +}; + +struct LC_UTF8Result { + uint8_t out_str[4]; + int len; + int error; +}; + +struct LC_UTF16Result { + uint16_t out_str[2]; + int len; + int error; +}; + +LC_FUNCTION LC_UTF32Result LC_ConvertUTF16ToUTF32(uint16_t *c, int max_advance); +LC_FUNCTION LC_UTF8Result LC_ConvertUTF32ToUTF8(uint32_t codepoint); +LC_FUNCTION LC_UTF32Result LC_ConvertUTF8ToUTF32(char *c, int max_advance); +LC_FUNCTION LC_UTF16Result LC_ConvertUTF32ToUTF16(uint32_t codepoint); +LC_FUNCTION int64_t LC_CreateCharFromWidechar(char *buffer, int64_t buffer_size, wchar_t *in, int64_t inlen); +LC_FUNCTION int64_t LC_CreateWidecharFromChar(wchar_t *buffer, int64_t buffer_size, char *in, int64_t inlen); + +// +// Filesystem API +// +LC_FUNCTION bool LC_IsDir(LC_Arena *temp, LC_String path); +LC_FUNCTION LC_String LC_GetAbsolutePath(LC_Arena *arena, LC_String relative); +LC_FUNCTION bool LC_EnableTerminalColors(void); +LC_FUNCTION LC_String LC_ReadFile(LC_Arena *arena, LC_String path); + +LC_FUNCTION bool LC_IsValid(LC_FileIter it); +LC_FUNCTION void LC_Advance(LC_FileIter *it); +LC_FUNCTION LC_FileIter LC_IterateFiles(LC_Arena *scratch_arena, LC_String path); + +// +// Arena API +// +#define LC_PushSize(a, size) LC__PushSize(a, size) +#define LC_PushSizeNonZeroed(a, size) LC__PushSizeNonZeroed(a, size) + +#define LC_PushArrayNonZeroed(a, T, c) (T *)LC__PushSizeNonZeroed(a, sizeof(T) * (c)) +#define LC_PushStructNonZeroed(a, T) (T *)LC__PushSizeNonZeroed(a, sizeof(T)) +#define LC_PushStruct(a, T) (T *)LC__PushSize(a, sizeof(T)) +#define LC_PushArray(a, T, c) (T *)LC__PushSize(a, sizeof(T) * (c)) + +#define LC_Assertf(cond, ...) LC_ASSERT(NULL, cond) + +#ifndef LC_USE_CUSTOM_ARENA +LC_FUNCTION void LC_InitArenaEx(LC_Arena *a, size_t reserve); +LC_FUNCTION void LC_InitArena(LC_Arena *a); +LC_FUNCTION void LC_InitArenaFromBuffer(LC_Arena *arena, void *buffer, size_t size); +LC_FUNCTION LC_Arena *LC_BootstrapArena(void); +LC_FUNCTION LC_Arena LC_PushArena(LC_Arena *arena, size_t size); +LC_FUNCTION LC_Arena *LC_PushArenaP(LC_Arena *arena, size_t size); + +LC_FUNCTION void *LC__PushSizeNonZeroed(LC_Arena *a, size_t size); +LC_FUNCTION void *LC__PushSize(LC_Arena *arena, size_t size); +LC_FUNCTION LC_TempArena LC_BeginTemp(LC_Arena *arena); +LC_FUNCTION void LC_EndTemp(LC_TempArena checkpoint); + +LC_FUNCTION void LC_PopToPos(LC_Arena *arena, size_t pos); +LC_FUNCTION void LC_PopSize(LC_Arena *arena, size_t size); +LC_FUNCTION void LC_DeallocateArena(LC_Arena *arena); +LC_FUNCTION void LC_ResetArena(LC_Arena *arena); + +LC_FUNCTION LC_VMemory LC_VReserve(size_t size); +LC_FUNCTION bool LC_VCommit(LC_VMemory *m, size_t commit); +LC_FUNCTION void LC_VDeallocate(LC_VMemory *m); +LC_FUNCTION bool LC_VDecommitPos(LC_VMemory *m, size_t pos); +#endif // LC_USE_CUSTOM_ARENA + +LC_FUNCTION size_t LC_GetAlignOffset(size_t size, size_t align); +LC_FUNCTION size_t LC_AlignUp(size_t size, size_t align); +LC_FUNCTION size_t LC_AlignDown(size_t size, size_t align); + +#define LC_IS_POW2(x) (((x) & ((x)-1)) == 0) +#define LC_MIN(x, y) ((x) <= (y) ? (x) : (y)) +#define LC_MAX(x, y) ((x) >= (y) ? (x) : (y)) +#define LC_StrLenof(x) ((int64_t)((sizeof(x) / sizeof((x)[0])))) + +#define LC_CLAMP_TOP(x, max) ((x) >= (max) ? (max) : (x)) +#define LC_CLAMP_BOT(x, min) ((x) <= (min) ? (min) : (x)) +#define LC_CLAMP(x, min, max) ((x) >= (max) ? (max) : (x) <= (min) ? (min) \ + : (x)) +#define LC_KIB(x) ((x##ull) * 1024ull) +#define LC_MIB(x) (LC_KIB(x) * 1024ull) +#define LC_GIB(x) (LC_MIB(x) * 1024ull) +#define LC_TIB(x) (LC_GIB(x) * 1024ull) + +// +// String API +// + +typedef int LC_FindFlag; +enum { + LC_FindFlag_None = 0, + LC_FindFlag_IgnoreCase = 1, + LC_FindFlag_MatchFindLast = 2, +}; + +typedef int LC_SplitFlag; +enum { + LC_SplitFlag_None = 0, + LC_SplitFlag_IgnoreCase = 1, + LC_SplitFlag_SplitInclusive = 2, +}; + +static const bool LC_IgnoreCase = true; + +#if defined(__has_attribute) + #if __has_attribute(format) + #define LC__PrintfFormat(fmt, va) __attribute__((format(printf, fmt, va))) + #endif +#endif + +#ifndef LC__PrintfFormat + #define LC__PrintfFormat(fmt, va) +#endif + +#define LC_Lit(string) LC_MakeString((char *)string, sizeof(string) - 1) +#define LC_Expand(string) (int)(string).len, (string).str + +#define LC_FORMAT(allocator, str, result) \ + va_list args1; \ + va_start(args1, str); \ + LC_String result = LC_FormatV(allocator, str, args1); \ + va_end(args1) + +#ifdef __cplusplus + #define LC_IF_CPP(x) x +#else + #define LC_IF_CPP(x) +#endif + +LC_FUNCTION char LC_ToLowerCase(char a); +LC_FUNCTION char LC_ToUpperCase(char a); +LC_FUNCTION bool LC_IsWhitespace(char w); +LC_FUNCTION bool LC_IsAlphabetic(char a); +LC_FUNCTION bool LC_IsIdent(char a); +LC_FUNCTION bool LC_IsDigit(char a); +LC_FUNCTION bool LC_IsAlphanumeric(char a); + +LC_FUNCTION int64_t LC_StrLen(char *string); +LC_FUNCTION bool LC_AreEqual(LC_String a, LC_String b, unsigned ignore_case LC_IF_CPP(= false)); +LC_FUNCTION bool LC_EndsWith(LC_String a, LC_String end, unsigned ignore_case LC_IF_CPP(= false)); +LC_FUNCTION bool LC_StartsWith(LC_String a, LC_String start, unsigned ignore_case LC_IF_CPP(= false)); +LC_FUNCTION LC_String LC_MakeString(char *str, int64_t len); +LC_FUNCTION LC_String LC_CopyString(LC_Arena *allocator, LC_String string); +LC_FUNCTION LC_String LC_CopyChar(LC_Arena *allocator, char *s); +LC_FUNCTION LC_String LC_NormalizePath(LC_Arena *allocator, LC_String s); +LC_FUNCTION void LC_NormalizePathUnsafe(LC_String s); // make sure there is no way string is const etc. +LC_FUNCTION LC_String LC_Chop(LC_String string, int64_t len); +LC_FUNCTION LC_String LC_Skip(LC_String string, int64_t len); +LC_FUNCTION LC_String LC_GetPostfix(LC_String string, int64_t len); +LC_FUNCTION LC_String LC_GetPrefix(LC_String string, int64_t len); +LC_FUNCTION bool LC_Seek(LC_String string, LC_String find, LC_FindFlag flags LC_IF_CPP(= LC_FindFlag_None), int64_t *index_out LC_IF_CPP(= 0)); +LC_FUNCTION int64_t LC_Find(LC_String string, LC_String find, LC_FindFlag flags LC_IF_CPP(= LC_FindFlag_None)); +LC_FUNCTION LC_String LC_ChopLastSlash(LC_String s); +LC_FUNCTION LC_String LC_ChopLastPeriod(LC_String s); +LC_FUNCTION LC_String LC_SkipToLastSlash(LC_String s); +LC_FUNCTION LC_String LC_SkipToLastPeriod(LC_String s); +LC_FUNCTION LC_String LC_GetNameNoExt(LC_String s); +LC_FUNCTION LC_String LC_MakeFromChar(char *string); +LC_FUNCTION LC_String LC_MakeEmptyString(void); +LC_FUNCTION LC_StringList LC_MakeEmptyList(void); +LC_FUNCTION LC_String LC_FormatV(LC_Arena *allocator, const char *str, va_list args1); +LC_FUNCTION LC_String LC_Format(LC_Arena *allocator, const char *str, ...) LC__PrintfFormat(2, 3); + +LC_FUNCTION LC_StringList LC_Split(LC_Arena *allocator, LC_String string, LC_String find, LC_SplitFlag flags LC_IF_CPP(= LC_SplitFlag_None)); +LC_FUNCTION LC_String LC_MergeWithSeparator(LC_Arena *allocator, LC_StringList list, LC_String separator LC_IF_CPP(= LC_Lit(" "))); +LC_FUNCTION LC_String LC_MergeString(LC_Arena *allocator, LC_StringList list); + +LC_FUNCTION LC_StringNode *LC_CreateNode(LC_Arena *allocator, LC_String string); +LC_FUNCTION void LC_ReplaceNodeString(LC_StringList *list, LC_StringNode *node, LC_String new_string); +LC_FUNCTION void LC_AddExistingNode(LC_StringList *list, LC_StringNode *node); +LC_FUNCTION void LC_AddArray(LC_Arena *allocator, LC_StringList *list, char **array, int count); +LC_FUNCTION void LC_AddArrayWithPrefix(LC_Arena *allocator, LC_StringList *list, char *prefix, char **array, int count); +LC_FUNCTION LC_StringList LC_MakeList(LC_Arena *allocator, LC_String a); +LC_FUNCTION LC_StringList LC_CopyList(LC_Arena *allocator, LC_StringList a); +LC_FUNCTION LC_StringList LC_ConcatLists(LC_Arena *allocator, LC_StringList a, LC_StringList b); +LC_FUNCTION LC_StringNode *LC_AddNode(LC_Arena *allocator, LC_StringList *list, LC_String string); +LC_FUNCTION LC_StringNode *LC_Add(LC_Arena *allocator, LC_StringList *list, LC_String string); +LC_FUNCTION LC_String LC_Addf(LC_Arena *allocator, LC_StringList *list, const char *str, ...) LC__PrintfFormat(3, 4); + +LC_FUNCTION wchar_t *LC_ToWidechar(LC_Arena *allocator, LC_String string); + +// +// Linked list API +// +#define LC_SLLAddMod(f, l, n, next) \ + do { \ + (n)->next = 0; \ + if ((f) == 0) { \ + (f) = (l) = (n); \ + } else { \ + (l) = (l)->next = (n); \ + } \ + } while (0) +#define LC_AddSLL(f, l, n) LC_SLLAddMod(f, l, n, next) + +#define LC_SLLPopFirstMod(f, l, next) \ + do { \ + if ((f) == (l)) { \ + (f) = (l) = 0; \ + } else { \ + (f) = (f)->next; \ + } \ + } while (0) +#define LC_SLLPopFirst(f, l) LC_SLLPopFirstMod(f, l, next) + +#define LC_SLLStackAddMod(stack_base, new_stack_base, next) \ + do { \ + (new_stack_base)->next = (stack_base); \ + (stack_base) = (new_stack_base); \ + } while (0) + +#define LC_DLLAddMod(f, l, node, next, prev) \ + do { \ + if ((f) == 0) { \ + (f) = (l) = (node); \ + (node)->prev = 0; \ + (node)->next = 0; \ + } else { \ + (l)->next = (node); \ + (node)->prev = (l); \ + (node)->next = 0; \ + (l) = (node); \ + } \ + } while (0) +#define LC_DLLAdd(f, l, node) LC_DLLAddMod(f, l, node, next, prev) +#define LC_DLLAddFront(f, l, node) LC_DLLAddMod(l, f, node, prev, next) +#define LC_DLLRemoveMod(first, last, node, next, prev) \ + do { \ + if ((first) == (last)) { \ + (first) = (last) = 0; \ + } else if ((last) == (node)) { \ + (last) = (last)->prev; \ + (last)->next = 0; \ + } else if ((first) == (node)) { \ + (first) = (first)->next; \ + (first)->prev = 0; \ + } else { \ + (node)->prev->next = (node)->next; \ + (node)->next->prev = (node)->prev; \ + } \ + if (node) { \ + (node)->prev = 0; \ + (node)->next = 0; \ + } \ + } while (0) +#define LC_DLLRemove(first, last, node) LC_DLLRemoveMod(first, last, node, next, prev) + +#define LC_ASTFor(it, x) for (LC_AST *it = x; it; it = it->next) +#define LC_DeclFor(it, x) for (LC_Decl *it = x; it; it = it->next) +#define LC_TypeFor(it, x) for (LC_TypeMember *it = x; it; it = it->next) + +#if defined(__APPLE__) && defined(__MACH__) + #define LC_OPERATING_SYSTEM_MAC 1 + #define LC_OPERATING_SYSTEM_UNIX 1 +#elif defined(_WIN32) + #define LC_OPERATING_SYSTEM_WINDOWS 1 +#elif defined(__linux__) + #define LC_OPERATING_SYSTEM_UNIX 1 + #define LC_OPERATING_SYSTEM_LINUX 1 +#endif + +#ifndef LC_OPERATING_SYSTEM_MAC + #define LC_OPERATING_SYSTEM_MAC 0 +#endif + +#ifndef LC_OPERATING_SYSTEM_UNIX + #define LC_OPERATING_SYSTEM_UNIX 0 +#endif + +#ifndef LC_OPERATING_SYSTEM_WINDOWS + #define LC_OPERATING_SYSTEM_WINDOWS 0 +#endif + +#ifndef LC_OPERATING_SYSTEM_LINUX + #define LC_OPERATING_SYSTEM_LINUX 0 +#endif + +#endif +#ifdef LIB_COMPILER_IMPLEMENTATION + + +#if __clang__ + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wswitch" + #pragma clang diagnostic ignored "-Wwritable-strings" +#endif + +#ifndef LC_ParseFloat // @override + #include + #define LC_ParseFloat(str, len) strtod(str, NULL) +#endif + +#ifndef LC_Print // @override + #include + #define LC_Print(str, len) printf("%.*s", (int)len, str) +#endif + +#ifndef LC_Exit // @override + #include + #define LC_Exit(x) exit(x) +#endif + +#ifndef LC_MemoryZero // @override + #include + #define LC_MemoryZero(p, size) memset(p, 0, size) +#endif + +#ifndef LC_MemoryCopy // @override + #include + #define LC_MemoryCopy(dst, src, size) memcpy(dst, src, size); +#endif + +#ifndef LC_vsnprintf // @override + #include + #define LC_vsnprintf vsnprintf +#endif + +#ifdef _WIN32 + #ifndef NOMINMAX + #define NOMINMAX + #endif + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN + #endif + #include +#endif + +LC_THREAD_LOCAL LC_Lang *L; + +LC_FUNCTION LC_UTF32Result LC_ConvertUTF16ToUTF32(uint16_t *c, int max_advance) { + LC_UTF32Result result; + LC_MemoryZero(&result, sizeof(result)); + if (max_advance >= 1) { + result.advance = 1; + result.out_str = c[0]; + if (c[0] >= 0xD800 && c[0] <= 0xDBFF && c[1] >= 0xDC00 && c[1] <= 0xDFFF) { + if (max_advance >= 2) { + result.out_str = 0x10000; + result.out_str += (uint32_t)(c[0] & 0x03FF) << 10u | (c[1] & 0x03FF); + result.advance = 2; + } else + result.error = 2; + } + } else { + result.error = 1; + } + return result; +} + +LC_FUNCTION LC_UTF8Result LC_ConvertUTF32ToUTF8(uint32_t codepoint) { + LC_UTF8Result result; + LC_MemoryZero(&result, sizeof(result)); + + if (codepoint <= 0x7F) { + result.len = 1; + result.out_str[0] = (char)codepoint; + } else if (codepoint <= 0x7FF) { + result.len = 2; + result.out_str[0] = 0xc0 | (0x1f & (codepoint >> 6)); + result.out_str[1] = 0x80 | (0x3f & codepoint); + } else if (codepoint <= 0xFFFF) { // 16 bit word + result.len = 3; + result.out_str[0] = 0xe0 | (0xf & (codepoint >> 12)); // 4 bits + result.out_str[1] = 0x80 | (0x3f & (codepoint >> 6)); // 6 bits + result.out_str[2] = 0x80 | (0x3f & codepoint); // 6 bits + } else if (codepoint <= 0x10FFFF) { // 21 bit word + result.len = 4; + result.out_str[0] = 0xf0 | (0x7 & (codepoint >> 18)); // 3 bits + result.out_str[1] = 0x80 | (0x3f & (codepoint >> 12)); // 6 bits + result.out_str[2] = 0x80 | (0x3f & (codepoint >> 6)); // 6 bits + result.out_str[3] = 0x80 | (0x3f & codepoint); // 6 bits + } else { + result.error = 1; + } + + return result; +} + +LC_FUNCTION LC_UTF32Result LC_ConvertUTF8ToUTF32(char *c, int max_advance) { + LC_UTF32Result result; + LC_MemoryZero(&result, sizeof(result)); + + if ((c[0] & 0x80) == 0) { // Check if leftmost zero of first byte is unset + if (max_advance >= 1) { + result.out_str = c[0]; + result.advance = 1; + } else result.error = 1; + } + + else if ((c[0] & 0xe0) == 0xc0) { + if ((c[1] & 0xc0) == 0x80) { // Continuation byte required + if (max_advance >= 2) { + result.out_str = (uint32_t)(c[0] & 0x1f) << 6u | (c[1] & 0x3f); + result.advance = 2; + } else result.error = 2; + } else result.error = 2; + } + + else if ((c[0] & 0xf0) == 0xe0) { + if ((c[1] & 0xc0) == 0x80 && (c[2] & 0xc0) == 0x80) { // Two continuation bytes required + if (max_advance >= 3) { + result.out_str = (uint32_t)(c[0] & 0xf) << 12u | (uint32_t)(c[1] & 0x3f) << 6u | (c[2] & 0x3f); + result.advance = 3; + } else result.error = 3; + } else result.error = 3; + } + + else if ((c[0] & 0xf8) == 0xf0) { + if ((c[1] & 0xc0) == 0x80 && (c[2] & 0xc0) == 0x80 && (c[3] & 0xc0) == 0x80) { // Three continuation bytes required + if (max_advance >= 4) { + result.out_str = (uint32_t)(c[0] & 0xf) << 18u | (uint32_t)(c[1] & 0x3f) << 12u | (uint32_t)(c[2] & 0x3f) << 6u | (uint32_t)(c[3] & 0x3f); + result.advance = 4; + } else result.error = 4; + } else result.error = 4; + } else result.error = 4; + + return result; +} + +LC_FUNCTION LC_UTF16Result LC_ConvertUTF32ToUTF16(uint32_t codepoint) { + LC_UTF16Result result; + LC_MemoryZero(&result, sizeof(result)); + if (codepoint < 0x10000) { + result.out_str[0] = (uint16_t)codepoint; + result.out_str[1] = 0; + result.len = 1; + } else if (codepoint <= 0x10FFFF) { + uint32_t code = (codepoint - 0x10000); + result.out_str[0] = (uint16_t)(0xD800 | (code >> 10)); + result.out_str[1] = (uint16_t)(0xDC00 | (code & 0x3FF)); + result.len = 2; + } else { + result.error = 1; + } + + return result; +} + +#define LC__HANDLE_DECODE_ERROR(question_mark) \ + { \ + if (outlen < buffer_size - 1) buffer[outlen++] = (question_mark); \ + break; \ + } + +LC_FUNCTION int64_t LC_CreateCharFromWidechar(char *buffer, int64_t buffer_size, wchar_t *in, int64_t inlen) { + int64_t outlen = 0; + for (int64_t i = 0; i < inlen && in[i];) { + LC_UTF32Result decode = LC_ConvertUTF16ToUTF32((uint16_t *)(in + i), (int)(inlen - i)); + if (!decode.error) { + i += decode.advance; + LC_UTF8Result encode = LC_ConvertUTF32ToUTF8(decode.out_str); + if (!encode.error) { + for (int64_t j = 0; j < encode.len; j++) { + if (outlen < buffer_size - 1) { + buffer[outlen++] = encode.out_str[j]; + } + } + } else LC__HANDLE_DECODE_ERROR('?'); + } else LC__HANDLE_DECODE_ERROR('?'); + } + + buffer[outlen] = 0; + return outlen; +} + +LC_FUNCTION int64_t LC_CreateWidecharFromChar(wchar_t *buffer, int64_t buffer_size, char *in, int64_t inlen) { + int64_t outlen = 0; + for (int64_t i = 0; i < inlen;) { + LC_UTF32Result decode = LC_ConvertUTF8ToUTF32(in + i, (int)(inlen - i)); + if (!decode.error) { + i += decode.advance; + LC_UTF16Result encode = LC_ConvertUTF32ToUTF16(decode.out_str); + if (!encode.error) { + for (int64_t j = 0; j < encode.len; j++) { + if (outlen < buffer_size - 1) { + buffer[outlen++] = encode.out_str[j]; + } + } + } else LC__HANDLE_DECODE_ERROR(0x003f); + } else LC__HANDLE_DECODE_ERROR(0x003f); + } + + buffer[outlen] = 0; + return outlen; +} + +#undef LC__HANDLE_DECODE_ERROR +LC_FUNCTION int64_t LC__ClampTop(int64_t val, int64_t max) { + if (val > max) val = max; + return val; +} + +LC_FUNCTION char LC_ToLowerCase(char a) { + if (a >= 'A' && a <= 'Z') a += 32; + return a; +} + +LC_FUNCTION char LC_ToUpperCase(char a) { + if (a >= 'a' && a <= 'z') a -= 32; + return a; +} + +LC_FUNCTION bool LC_IsWhitespace(char w) { + bool result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r'; + return result; +} + +LC_FUNCTION bool LC_IsAlphabetic(char a) { + bool result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z'); + return result; +} + +LC_FUNCTION bool LC_IsIdent(char a) { + bool result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || a == '_'; + return result; +} + +LC_FUNCTION bool LC_IsDigit(char a) { + bool result = a >= '0' && a <= '9'; + return result; +} + +LC_FUNCTION bool LC_IsAlphanumeric(char a) { + bool result = LC_IsDigit(a) || LC_IsAlphabetic(a); + return result; +} + +LC_FUNCTION bool LC_AreEqual(LC_String a, LC_String b, unsigned ignore_case) { + if (a.len != b.len) return false; + for (int64_t i = 0; i < a.len; i++) { + char A = a.str[i]; + char B = b.str[i]; + if (ignore_case) { + A = LC_ToLowerCase(A); + B = LC_ToLowerCase(B); + } + if (A != B) + return false; + } + return true; +} + +LC_FUNCTION bool LC_EndsWith(LC_String a, LC_String end, unsigned ignore_case) { + LC_String a_end = LC_GetPostfix(a, end.len); + bool result = LC_AreEqual(end, a_end, ignore_case); + return result; +} + +LC_FUNCTION bool LC_StartsWith(LC_String a, LC_String start, unsigned ignore_case) { + LC_String a_start = LC_GetPrefix(a, start.len); + bool result = LC_AreEqual(start, a_start, ignore_case); + return result; +} + +LC_FUNCTION LC_String LC_MakeString(char *str, int64_t len) { + LC_String result; + result.str = (char *)str; + result.len = len; + return result; +} + +LC_FUNCTION LC_String LC_CopyString(LC_Arena *allocator, LC_String string) { + char *copy = (char *)LC_PushSize(allocator, sizeof(char) * (string.len + 1)); + LC_MemoryCopy(copy, string.str, string.len); + copy[string.len] = 0; + LC_String result = LC_MakeString(copy, string.len); + return result; +} + +LC_FUNCTION LC_String LC_CopyChar(LC_Arena *allocator, char *s) { + int64_t len = LC_StrLen(s); + char *copy = (char *)LC_PushSize(allocator, sizeof(char) * (len + 1)); + LC_MemoryCopy(copy, s, len); + copy[len] = 0; + LC_String result = LC_MakeString(copy, len); + return result; +} + +LC_FUNCTION LC_String LC_NormalizePath(LC_Arena *allocator, LC_String s) { + LC_String copy = LC_CopyString(allocator, s); + for (int64_t i = 0; i < copy.len; i++) { + if (copy.str[i] == '\\') + copy.str[i] = '/'; + } + return copy; +} + +LC_FUNCTION void LC_NormalizePathUnsafe(LC_String s) { + for (int64_t i = 0; i < s.len; i++) { + if (s.str[i] == '\\') + s.str[i] = '/'; + } +} + +LC_FUNCTION LC_String LC_Chop(LC_String string, int64_t len) { + len = LC__ClampTop(len, string.len); + LC_String result = LC_MakeString(string.str, string.len - len); + return result; +} + +LC_FUNCTION LC_String LC_Skip(LC_String string, int64_t len) { + len = LC__ClampTop(len, string.len); + int64_t remain = string.len - len; + LC_String result = LC_MakeString(string.str + len, remain); + return result; +} + +LC_FUNCTION LC_String LC_GetPostfix(LC_String string, int64_t len) { + len = LC__ClampTop(len, string.len); + int64_t remain_len = string.len - len; + LC_String result = LC_MakeString(string.str + remain_len, len); + return result; +} + +LC_FUNCTION LC_String LC_GetPrefix(LC_String string, int64_t len) { + len = LC__ClampTop(len, string.len); + LC_String result = LC_MakeString(string.str, len); + return result; +} + +LC_FUNCTION LC_String LC_GetNameNoExt(LC_String s) { + return LC_SkipToLastSlash(LC_ChopLastPeriod(s)); +} + +LC_FUNCTION LC_String LC_Slice(LC_String string, int64_t first_index, int64_t one_past_last_index) { + if (one_past_last_index < 0) one_past_last_index = string.len + one_past_last_index + 1; + if (first_index < 0) first_index = string.len + first_index; + LC_ASSERT(NULL, first_index < one_past_last_index && "LC_Slice, first_index is bigger then one_past_last_index"); + LC_ASSERT(NULL, string.len > 0 && "Slicing string of length 0! Might be an error!"); + LC_String result = string; + if (string.len > 0) { + if (one_past_last_index > first_index) { + first_index = LC__ClampTop(first_index, string.len - 1); + one_past_last_index = LC__ClampTop(one_past_last_index, string.len); + result.str += first_index; + result.len = one_past_last_index - first_index; + } else { + result.len = 0; + } + } + return result; +} + +LC_FUNCTION bool LC_Seek(LC_String string, LC_String find, LC_FindFlag flags, int64_t *index_out) { + bool ignore_case = flags & LC_FindFlag_IgnoreCase ? true : false; + bool result = false; + if (flags & LC_FindFlag_MatchFindLast) { + for (int64_t i = string.len; i != 0; i--) { + int64_t index = i - 1; + LC_String substring = LC_Slice(string, index, index + find.len); + if (LC_AreEqual(substring, find, ignore_case)) { + if (index_out) + *index_out = index; + result = true; + break; + } + } + } else { + for (int64_t i = 0; i < string.len; i++) { + LC_String substring = LC_Slice(string, i, i + find.len); + if (LC_AreEqual(substring, find, ignore_case)) { + if (index_out) + *index_out = i; + result = true; + break; + } + } + } + + return result; +} + +LC_FUNCTION int64_t LC_Find(LC_String string, LC_String find, LC_FindFlag flag) { + int64_t result = -1; + LC_Seek(string, find, flag, &result); + return result; +} + +LC_FUNCTION LC_StringList LC_Split(LC_Arena *allocator, LC_String string, LC_String find, LC_SplitFlag flags) { + LC_StringList result = LC_MakeEmptyList(); + int64_t index = 0; + + LC_FindFlag find_flag = flags & LC_SplitFlag_IgnoreCase ? LC_FindFlag_IgnoreCase : LC_FindFlag_None; + while (LC_Seek(string, find, find_flag, &index)) { + LC_String before_match = LC_MakeString(string.str, index); + LC_AddNode(allocator, &result, before_match); + if (flags & LC_SplitFlag_SplitInclusive) { + LC_String match = LC_MakeString(string.str + index, find.len); + LC_AddNode(allocator, &result, match); + } + string = LC_Skip(string, index + find.len); + } + if (string.len) LC_AddNode(allocator, &result, string); + return result; +} + +LC_FUNCTION LC_String LC_MergeWithSeparator(LC_Arena *allocator, LC_StringList list, LC_String separator) { + if (list.node_count == 0) return LC_MakeEmptyString(); + if (list.char_count == 0) return LC_MakeEmptyString(); + + int64_t base_size = (list.char_count + 1); + int64_t sep_size = (list.node_count - 1) * separator.len; + int64_t size = base_size + sep_size; + char *buff = (char *)LC_PushSize(allocator, sizeof(char) * (size + 1)); + LC_String string = LC_MakeString(buff, 0); + for (LC_StringNode *it = list.first; it; it = it->next) { + LC_ASSERT(NULL, string.len + it->string.len <= size); + LC_MemoryCopy(string.str + string.len, it->string.str, it->string.len); + string.len += it->string.len; + if (it != list.last) { + LC_MemoryCopy(string.str + string.len, separator.str, separator.len); + string.len += separator.len; + } + } + LC_ASSERT(NULL, string.len == size - 1); + string.str[size] = 0; + return string; +} + +LC_FUNCTION LC_String LC_MergeString(LC_Arena *allocator, LC_StringList list) { + return LC_MergeWithSeparator(allocator, list, LC_Lit("")); +} + +LC_FUNCTION LC_String LC_ChopLastSlash(LC_String s) { + LC_String result = s; + LC_Seek(s, LC_Lit("/"), LC_FindFlag_MatchFindLast, &result.len); + return result; +} + +LC_FUNCTION LC_String LC_ChopLastPeriod(LC_String s) { + LC_String result = s; + LC_Seek(s, LC_Lit("."), LC_FindFlag_MatchFindLast, &result.len); + return result; +} + +LC_FUNCTION LC_String LC_SkipToLastSlash(LC_String s) { + int64_t pos; + LC_String result = s; + if (LC_Seek(s, LC_Lit("/"), LC_FindFlag_MatchFindLast, &pos)) { + result = LC_Skip(result, pos + 1); + } + return result; +} + +LC_FUNCTION LC_String LC_SkipToLastPeriod(LC_String s) { + int64_t pos; + LC_String result = s; + if (LC_Seek(s, LC_Lit("."), LC_FindFlag_MatchFindLast, &pos)) { + result = LC_Skip(result, pos + 1); + } + return result; +} + +LC_FUNCTION int64_t LC_StrLen(char *string) { + int64_t len = 0; + while (*string++ != 0) + len++; + return len; +} + +LC_FUNCTION LC_String LC_MakeFromChar(char *string) { + LC_String result; + result.str = (char *)string; + result.len = LC_StrLen(string); + return result; +} + +LC_FUNCTION LC_String LC_MakeEmptyString(void) { + return LC_MakeString(0, 0); +} + +LC_FUNCTION LC_StringList LC_MakeEmptyList(void) { + LC_StringList result; + result.first = 0; + result.last = 0; + result.char_count = 0; + result.node_count = 0; + return result; +} + +LC_FUNCTION LC_String LC_FormatV(LC_Arena *allocator, const char *str, va_list args1) { + va_list args2; + va_copy(args2, args1); + int64_t len = LC_vsnprintf(0, 0, str, args2); + va_end(args2); + + char *result = (char *)LC_PushSize(allocator, sizeof(char) * (len + 1)); + LC_vsnprintf(result, (int)(len + 1), str, args1); + LC_String res = LC_MakeString(result, len); + return res; +} + +LC_FUNCTION LC_String LC_Format(LC_Arena *allocator, const char *str, ...) { + LC_FORMAT(allocator, str, result); + return result; +} + +LC_FUNCTION LC_StringNode *LC_CreateNode(LC_Arena *allocator, LC_String string) { + LC_StringNode *result = (LC_StringNode *)LC_PushSize(allocator, sizeof(LC_StringNode)); + result->string = string; + result->next = 0; + return result; +} + +LC_FUNCTION void LC_ReplaceNodeString(LC_StringList *list, LC_StringNode *node, LC_String new_string) { + list->char_count -= node->string.len; + list->char_count += new_string.len; + node->string = new_string; +} + +LC_FUNCTION void LC_AddExistingNode(LC_StringList *list, LC_StringNode *node) { + if (list->first) { + list->last->next = node; + list->last = list->last->next; + } else { + list->first = list->last = node; + } + list->node_count += 1; + list->char_count += node->string.len; +} + +LC_FUNCTION void LC_AddArray(LC_Arena *allocator, LC_StringList *list, char **array, int count) { + for (int i = 0; i < count; i += 1) { + LC_String s = LC_MakeFromChar(array[i]); + LC_AddNode(allocator, list, s); + } +} + +LC_FUNCTION void LC_AddArrayWithPrefix(LC_Arena *allocator, LC_StringList *list, char *prefix, char **array, int count) { + for (int i = 0; i < count; i += 1) { + LC_Addf(allocator, list, "%s%s", prefix, array[i]); + } +} + +LC_FUNCTION LC_StringList LC_MakeList(LC_Arena *allocator, LC_String a) { + LC_StringList result = LC_MakeEmptyList(); + LC_AddNode(allocator, &result, a); + return result; +} + +LC_FUNCTION LC_StringList LC_CopyList(LC_Arena *allocator, LC_StringList a) { + LC_StringList result = LC_MakeEmptyList(); + for (LC_StringNode *it = a.first; it; it = it->next) LC_AddNode(allocator, &result, it->string); + return result; +} + +LC_FUNCTION LC_StringList LC_ConcatLists(LC_Arena *allocator, LC_StringList a, LC_StringList b) { + LC_StringList result = LC_MakeEmptyList(); + for (LC_StringNode *it = a.first; it; it = it->next) LC_AddNode(allocator, &result, it->string); + for (LC_StringNode *it = b.first; it; it = it->next) LC_AddNode(allocator, &result, it->string); + return result; +} + +LC_FUNCTION LC_StringNode *LC_AddNode(LC_Arena *allocator, LC_StringList *list, LC_String string) { + LC_StringNode *node = LC_CreateNode(allocator, string); + LC_AddExistingNode(list, node); + return node; +} + +LC_FUNCTION LC_StringNode *LC_Add(LC_Arena *allocator, LC_StringList *list, LC_String string) { + LC_String copy = LC_CopyString(allocator, string); + LC_StringNode *node = LC_CreateNode(allocator, copy); + LC_AddExistingNode(list, node); + return node; +} + +LC_FUNCTION LC_String LC_Addf(LC_Arena *allocator, LC_StringList *list, const char *str, ...) { + LC_FORMAT(allocator, str, result); + LC_AddNode(allocator, list, result); + return result; +} + +LC_FUNCTION LC_String16 LC_ToWidecharEx(LC_Arena *allocator, LC_String string) { + LC_ASSERT(NULL, sizeof(wchar_t) == 2); + wchar_t *buffer = (wchar_t *)LC_PushSize(allocator, sizeof(wchar_t) * (string.len + 1)); + int64_t size = LC_CreateWidecharFromChar(buffer, string.len + 1, string.str, string.len); + LC_String16 result = {buffer, size}; + return result; +} + +LC_FUNCTION wchar_t *LC_ToWidechar(LC_Arena *allocator, LC_String string) { + LC_String16 result = LC_ToWidecharEx(allocator, string); + return result.str; +} + +LC_FUNCTION LC_String LC_FromWidecharEx(LC_Arena *allocator, wchar_t *wstring, int64_t wsize) { + LC_ASSERT(NULL, sizeof(wchar_t) == 2); + + int64_t buffer_size = (wsize + 1) * 2; + char *buffer = (char *)LC_PushSize(allocator, buffer_size); + int64_t size = LC_CreateCharFromWidechar(buffer, buffer_size, wstring, wsize); + LC_String result = LC_MakeString(buffer, size); + + LC_ASSERT(NULL, size < buffer_size); + return result; +} + +LC_FUNCTION int64_t LC_WideLength(wchar_t *string) { + int64_t len = 0; + while (*string++ != 0) + len++; + return len; +} + +LC_FUNCTION LC_String LC_FromWidechar(LC_Arena *allocator, wchar_t *wstring) { + int64_t size = LC_WideLength(wstring); + LC_String result = LC_FromWidecharEx(allocator, wstring, size); + return result; +} + +LC_FUNCTION const char *LC_OSToString(LC_OS os) { + switch (os) { + case LC_OS_WINDOWS: return "OS_WINDOWS"; + case LC_OS_LINUX: return "OS_LINUX"; + case LC_OS_MAC: return "OS_MAC"; + default: return "UNKNOWN_OPERATING_SYSTEM"; + } +} + +LC_FUNCTION const char *LC_GENToString(LC_GEN os) { + switch (os) { + case LC_GEN_C: return "GEN_C"; + default: return "UNKNOWN_GENERATOR"; + } +} + +LC_FUNCTION const char *LC_ARCHToString(LC_ARCH arch) { + switch (arch) { + case LC_ARCH_X86: return "ARCH_X86"; + case LC_ARCH_X64: return "ARCH_X64"; + default: return "UNKNOWN_ARCHITECTURE"; + } +} + +LC_FUNCTION const char *LC_ASTKindToString(LC_ASTKind kind) { + static const char *strs[] = { + "ast null", + "ast error", + "ast note", + "ast note list", + "ast file", + "ast package", + "ast ignore", + "typespec procdure argument", + "typespec aggregate member", + "expr call item", + "expr compound item", + "expr note", + "stmt switch case", + "stmt switch default", + "stmt else if", + "stmt else", + "import", + "global note", + "decl proc", + "decl struct", + "decl union", + "decl var", + "decl const", + "decl typedef", + "typespec ident", + "typespec field", + "typespec pointer", + "typespec array", + "typespec proc", + "stmt block", + "stmt note", + "stmt return", + "stmt break", + "stmt continue", + "stmt defer", + "stmt for", + "stmt if", + "stmt switch", + "stmt assign", + "stmt expr", + "stmt var", + "stmt const", + "expr ident", + "expr string", + "expr int", + "expr float", + "expr bool", + "expr type", + "expr binary", + "expr unary", + "expr builtin", + "expr call", + "expr compound", + "expr cast", + "expr field", + "expr index", + "expr pointerindex", + "expr getvalueofpointer", + "expr getpointerofvalue", + }; + if (kind < 0 || kind >= LC_ASTKind_Count) { + return ""; + } + return strs[kind]; +} + +LC_FUNCTION const char *LC_TypeKindToString(LC_TypeKind kind) { + static const char *strs[] = { + "LC_TypeKind_char", + "LC_TypeKind_uchar", + "LC_TypeKind_short", + "LC_TypeKind_ushort", + "LC_TypeKind_bool", + "LC_TypeKind_int", + "LC_TypeKind_uint", + "LC_TypeKind_long", + "LC_TypeKind_ulong", + "LC_TypeKind_llong", + "LC_TypeKind_ullong", + "LC_TypeKind_float", + "LC_TypeKind_double", + "LC_TypeKind_void", + "LC_TypeKind_Struct", + "LC_TypeKind_Union", + "LC_TypeKind_Pointer", + "LC_TypeKind_Array", + "LC_TypeKind_Proc", + "LC_TypeKind_UntypedInt", + "LC_TypeKind_UntypedFloat", + "LC_TypeKind_UntypedString", + "LC_TypeKind_Incomplete", + "LC_TypeKind_Completing", + "LC_TypeKind_Error", + }; + if (kind < 0 || kind >= T_TotalCount) { + return ""; + } + return strs[kind]; +} + +LC_FUNCTION const char *LC_DeclKindToString(LC_DeclKind decl_kind) { + static const char *strs[] = { + "declaration of error kind", + "type declaration", + "const declaration", + "variable declaration", + "procedure declaration", + "import declaration", + }; + if (decl_kind < 0 || decl_kind >= LC_DeclKind_Count) { + return ""; + } + return strs[decl_kind]; +} + +LC_FUNCTION const char *LC_TokenKindToString(LC_TokenKind token_kind) { + static const char *strs[] = { + "end of file", + "token error", + "comment", + "doc comment", + "file doc comment", + "package doc comment", + "note '@'", + "hash '#'", + "identifier", + "keyword", + "string literal", + "raw string literal", + "integer literal", + "float literal", + "unicode literal", + "open paren '('", + "close paren ')'", + "open brace '{'", + "close brace '}'", + "open bracket '['", + "close bracket ']'", + "comma ','", + "question mark '?'", + "semicolon ';'", + "period '.'", + "three dots '...'", + "colon ':'", + "multiply '*'", + "divide '/'", + "modulo '%'", + "left shift '<<'", + "right shift '>>'", + "add '+'", + "subtract '-'", + "equals '=='", + "lesser then '<'", + "greater then '>'", + "lesser then or equal '<='", + "greater then or equal '>='", + "not equal '!='", + "bit and '&'", + "bit or '|'", + "bit xor '^'", + "and '&&'", + "or '||'", + "addptr keyword", + "negation '~'", + "exclamation '!'", + "assignment '='", + "assignment '/='", + "assignment '*='", + "assignment '%='", + "assignment '-='", + "assignment '+='", + "assignment '&='", + "assignment '|='", + "assignment '^='", + "assignment '<<='", + "assignment '>>='", + }; + + if (token_kind < 0 || token_kind >= LC_TokenKind_Count) { + return ""; + } + return strs[token_kind]; +} + +LC_FUNCTION const char *LC_TokenKindToOperator(LC_TokenKind token_kind) { + static const char *strs[] = { + "end of file", + "token error", + "comment", + "doc comment", + "file doc comment", + "package doc comment", + "@", + "#", + "identifier", + "keyword", + "string literal", + "raw string literal", + "integer literal", + "float literal", + "unicode literal", + "(", + ")", + "{", + "}", + "[", + "]", + ",", + "?", + ";", + ".", + "...", + ":", + "*", + "/", + "%", + "<<", + ">>", + "+", + "-", + "==", + "<", + ">", + "<=", + ">=", + "!=", + "&", + "|", + "^", + "&&", + "||", + "+", + "~", + "!", + "=", + "/=", + "*=", + "%=", + "-=", + "+=", + "&=", + "|=", + "^=", + "<<=", + ">>=", + }; + if (token_kind < 0 || token_kind >= LC_TokenKind_Count) { + return ""; + } + return strs[token_kind]; +} + +#if __cplusplus + #define LC_Alignof(...) alignof(__VA_ARGS__) +#else + #define LC_Alignof(...) _Alignof(__VA_ARGS__) +#endif + +#define LC_WRAP_AROUND_POWER_OF_2(x, pow2) (((x) & ((pow2)-1llu))) + +#if defined(_MSC_VER) + #define LC_DebugBreak() (L->breakpoint_on_error && IsDebuggerPresent() && (__debugbreak(), 0)) +#else + #define LC_DebugBreak() (L->breakpoint_on_error && (__builtin_trap(), 0)) +#endif +#define LC_FatalError() (L->breakpoint_on_error ? LC_DebugBreak() : (LC_Exit(1), 0)) + +LC_FUNCTION void LC_IgnoreMessage(LC_Token *pos, char *str, int len) { +} + +LC_FUNCTION void LC_SendErrorMessage(LC_Token *pos, LC_String s8) { + if (L->on_message) { + L->on_message(pos, s8.str, (int)s8.len); + } else { + if (pos) { + LC_String line = LC_GetTokenLine(pos); + LC_String fmt = LC_Format(L->arena, "%s(%d,%d): error: %.*s\n%.*s", (char *)pos->lex->file, pos->line, pos->column, LC_Expand(s8), LC_Expand(line)); + LC_Print(fmt.str, fmt.len); + } else { + LC_Print(s8.str, s8.len); + } + } + LC_DebugBreak(); +} + +LC_FUNCTION void LC_SendErrorMessagef(LC_Lex *x, LC_Token *pos, const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + LC_SendErrorMessage(pos, s8); +} + +LC_FUNCTION void LC_HandleFatalError(void) { + if (L->on_fatal_error) { + L->on_fatal_error(); + return; + } + LC_FatalError(); +} + +LC_FUNCTION void LC_MapReserve(LC_Map *map, int size) { + LC_Map old_map = *map; + + LC_ASSERT(NULL, LC_IS_POW2(size)); + map->len = 0; + map->cap = size; + LC_ASSERT(NULL, map->arena); + + map->entries = LC_PushArray(map->arena, LC_MapEntry, map->cap); + + if (old_map.entries) { + for (int i = 0; i < old_map.cap; i += 1) { + LC_MapEntry *it = old_map.entries + i; + if (it->key) LC_InsertMapEntry(map, it->key, it->value); + } + } +} + +// FNV HASH (1a?) +LC_FUNCTION uint64_t LC_HashBytes(void *data, uint64_t size) { + uint8_t *data8 = (uint8_t *)data; + uint64_t hash = (uint64_t)14695981039346656037ULL; + for (uint64_t i = 0; i < size; i++) { + hash = hash ^ (uint64_t)(data8[i]); + hash = hash * (uint64_t)1099511628211ULL; + } + return hash; +} + +LC_FUNCTION uint64_t LC_HashMix(uint64_t x, uint64_t y) { + x ^= y; + x *= 0xff51afd7ed558ccd; + x ^= x >> 32; + return x; +} + +LC_FUNCTION int LC_NextPow2(int v) { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + v++; + return v; +} + +LC_FUNCTION LC_MapEntry *LC_GetMapEntryEx(LC_Map *map, uint64_t key) { + LC_ASSERT(NULL, key); + if (map->len * 2 >= map->cap) { + LC_MapReserve(map, map->cap * 2); + } + + uint64_t hash = LC_HashBytes(&key, sizeof(key)); + if (hash == 0) hash += 1; + uint64_t index = LC_WRAP_AROUND_POWER_OF_2(hash, map->cap); + uint64_t i = index; + for (;;) { + LC_MapEntry *it = map->entries + i; + if (it->key == key || it->key == 0) { + return it; + } + + i = LC_WRAP_AROUND_POWER_OF_2(i + 1, map->cap); + if (i == index) return NULL; + } + LC_ASSERT(NULL, !"invalid codepath"); +} + +LC_FUNCTION bool LC_InsertWithoutReplace(LC_Map *map, void *key, void *value) { + LC_MapEntry *entry = LC_GetMapEntryEx(map, (uint64_t)key); + if (entry->key != 0) return false; + + map->len += 1; + entry->key = (uint64_t)key; + entry->value = (uint64_t)value; + return true; +} + +LC_FUNCTION LC_MapEntry *LC_InsertMapEntry(LC_Map *map, uint64_t key, uint64_t value) { + LC_MapEntry *entry = LC_GetMapEntryEx(map, key); + if (entry->key == key) { + entry->value = value; + } + if (entry->key == 0) { + entry->key = key; + entry->value = value; + map->len += 1; + } + return entry; +} + +LC_FUNCTION LC_MapEntry *LC_GetMapEntry(LC_Map *map, uint64_t key) { + LC_MapEntry *entry = LC_GetMapEntryEx(map, key); + if (entry && entry->key == key) { + return entry; + } + return NULL; +} + +LC_FUNCTION void LC_MapInsert(LC_Map *map, LC_String keystr, void *value) { + uint64_t key = LC_HashBytes(keystr.str, keystr.len); + LC_InsertMapEntry(map, key, (uint64_t)value); +} + +LC_FUNCTION void *LC_MapGet(LC_Map *map, LC_String keystr) { + uint64_t key = LC_HashBytes(keystr.str, keystr.len); + LC_MapEntry *r = LC_GetMapEntry(map, key); + return r ? (void *)r->value : 0; +} + +LC_FUNCTION void LC_MapInsertU64(LC_Map *map, uint64_t key, void *value) { + LC_InsertMapEntry(map, key, (uint64_t)value); +} + +LC_FUNCTION void *LC_MapGetU64(LC_Map *map, uint64_t key) { + LC_MapEntry *r = LC_GetMapEntry(map, key); + return r ? (void *)r->value : 0; +} + +LC_FUNCTION void *LC_MapGetP(LC_Map *map, void *key) { + return LC_MapGetU64(map, (uint64_t)key); +} + +LC_FUNCTION void LC_MapInsertP(LC_Map *map, void *key, void *value) { + LC_InsertMapEntry(map, (uint64_t)key, (uint64_t)value); +} + +LC_FUNCTION void LC_MapClear(LC_Map *map) { + if (map->len != 0) LC_MemoryZero(map->entries, map->cap * sizeof(LC_MapEntry)); + map->len = 0; +} + +LC_FUNCTION size_t LC_GetAlignOffset(size_t size, size_t align) { + size_t mask = align - 1; + size_t val = size & mask; + if (val) { + val = align - val; + } + return val; +} + +LC_FUNCTION size_t LC_AlignUp(size_t size, size_t align) { + size_t result = size + LC_GetAlignOffset(size, align); + return result; +} + +LC_FUNCTION size_t LC_AlignDown(size_t size, size_t align) { + size += 1; // Make sure when align is 8 doesn't get rounded down to 0 + size_t result = size - (align - LC_GetAlignOffset(size, align)); + return result; +} + +typedef struct { + int len; + char str[]; +} INTERN_Entry; + +LC_FUNCTION LC_Intern LC_InternStrLen(char *str, int len) { + LC_String key = LC_MakeString(str, len); + INTERN_Entry *entry = (INTERN_Entry *)LC_MapGet(&L->interns, key); + if (entry == NULL) { + LC_ASSERT(NULL, sizeof(INTERN_Entry) == sizeof(int)); + entry = (INTERN_Entry *)LC_PushSize(L->arena, sizeof(int) + sizeof(char) * (len + 1)); + entry->len = len; + LC_MemoryCopy(entry->str, str, len); + entry->str[len] = 0; + LC_MapInsert(&L->interns, key, entry); + } + + return (uintptr_t)entry->str; +} + +LC_FUNCTION LC_Intern LC_ILit(char *str) { + return LC_InternStrLen(str, (int)LC_StrLen(str)); +} + +LC_FUNCTION LC_Intern LC_GetUniqueIntern(const char *name_for_debug) { + LC_String name = LC_Format(L->arena, "U%u_%s", ++L->unique_counter, name_for_debug); + LC_Intern result = LC_InternStrLen(name.str, (int)name.len); + return result; +} + +LC_FUNCTION char *LC_GetUniqueName(const char *name_for_debug) { + LC_String name = LC_Format(L->arena, "U%u_%s", ++L->unique_counter, name_for_debug); + return name.str; +} + +LC_FUNCTION void LC_DeclareNote(LC_Intern intern) { + LC_MapInsertU64(&L->declared_notes, intern, (void *)intern); +} + +LC_FUNCTION bool LC_IsNoteDeclared(LC_Intern intern) { + void *p = LC_MapGetU64(&L->declared_notes, intern); + bool result = p != NULL; + return result; +} +LC_FUNCTION void LC_LexingError(LC_Token *pos, const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + LC_SendErrorMessage(pos, s8); + L->errors += 1; + pos->kind = LC_TokenKind_Error; +} + +#define LC_IF(cond, ...) \ + do { \ + if (cond) { \ + LC_LexingError(t, __VA_ARGS__); \ + return; \ + } \ + } while (0) + +LC_FUNCTION bool LC_IsAssign(LC_TokenKind kind) { + bool result = kind >= LC_TokenKind_Assign && kind <= LC_TokenKind_RightShiftAssign; + return result; +} + +LC_FUNCTION bool LC_IsHexDigit(char c) { + bool result = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); + return result; +} + +LC_FUNCTION bool LC_IsBinDigit(char c) { + bool result = (c >= '0' && c <= '1'); + return result; +} + +LC_FUNCTION uint64_t LC_MapCharToNumber(char c) { + // clang-format off + switch (c) { + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; + case 'a': case 'A': return 10; + case 'b': case 'B': return 11; + case 'c': case 'C': return 12; + case 'd': case 'D': return 13; + case 'e': case 'E': return 14; + case 'f': case 'F': return 15; + default: return 255; + } + // clang-format on +} + +LC_FUNCTION uint64_t LC_GetEscapeCode(char c) { + switch (c) { + case 'a': return '\a'; + case 'b': return '\b'; + case 'e': return 0x1B; + case 'f': return '\f'; + case 'n': return '\n'; + case 'r': return '\r'; + case 't': return '\t'; + case 'v': return '\v'; + case '\\': return '\\'; + case '\'': return '\''; + case '\"': return '\"'; + case '0': return '\0'; + default: return UINT64_MAX; + } +} + +LC_FUNCTION LC_String LC_GetEscapeString(char c) { + switch (c) { + case '\a': return LC_Lit("\\a"); + case '\b': return LC_Lit("\\b"); + case 0x1B: return LC_Lit("\\x1B"); + case '\f': return LC_Lit("\\f"); + case '\n': return LC_Lit("\\n"); + case '\r': return LC_Lit("\\r"); + case '\t': return LC_Lit("\\t"); + case '\v': return LC_Lit("\\v"); + case '\\': return LC_Lit("\\\\"); + case '\'': return LC_Lit("\\'"); + case '\"': return LC_Lit("\\\""); + case '\0': return LC_Lit("\\0"); + default: return LC_Lit(""); + } +} + +LC_FUNCTION void LC_LexAdvance(LC_Lex *x) { + if (x->at[0] == 0) { + return; + } else if (x->at[0] == '\n') { + x->line += 1; + x->column = 0; + } + x->column += 1; + x->at += 1; +} + +LC_FUNCTION void LC_EatWhitespace(LC_Lex *x) { + while (LC_IsWhitespace(x->at[0])) LC_LexAdvance(x); +} + +LC_FUNCTION void LC_EatIdent(LC_Lex *x) { + while (x->at[0] == '_' || LC_IsAlphanumeric(x->at[0])) LC_LexAdvance(x); +} + +LC_FUNCTION void LC_SetTokenLen(LC_Lex *x, LC_Token *t) { + t->len = (int)(x->at - t->str); + LC_ASSERT(NULL, t->len < 2000000000); +} + +LC_FUNCTION void LC_EatUntilIncluding(LC_Lex *x, char c) { + while (x->at[0] != 0 && x->at[0] != c) LC_LexAdvance(x); + LC_LexAdvance(x); +} + +// @todo: add temporary allocation + copy at end to perm +LC_FUNCTION LC_BigInt LC_LexBigInt(char *string, int len, uint64_t base) { + LC_ASSERT(NULL, base >= 2 && base <= 16); + LC_BigInt m = LC_Bigint_u64(1); + LC_BigInt base_mul = LC_Bigint_u64(base); + LC_BigInt result = LC_Bigint_u64(0); + + LC_BigInt tmp = {0}; + for (int i = len - 1; i >= 0; --i) { + uint64_t u = LC_MapCharToNumber(string[i]); + LC_ASSERT(NULL, u < base); + LC_BigInt val = LC_Bigint_u64(u); + LC_Bigint_mul(&tmp, &val, &m); + LC_BigInt new_val = tmp; + LC_Bigint_add(&tmp, &result, &new_val); + result = tmp; + LC_Bigint_mul(&tmp, &m, &base_mul); + m = tmp; + } + + return result; +} + +LC_FUNCTION void LC_LexNestedComments(LC_Lex *x, LC_Token *t) { + t->kind = LC_TokenKind_Comment; + LC_LexAdvance(x); + + if (x->at[0] == '*') { + LC_LexAdvance(x); + t->kind = LC_TokenKind_DocComment; + + if (x->at[0] == ' ' && x->at[1] == 'f' && x->at[2] == 'i' && x->at[3] == 'l' && x->at[4] == 'e') { + t->kind = LC_TokenKind_FileDocComment; + } + + if (x->at[0] == ' ' && x->at[1] == 'p' && x->at[2] == 'a' && x->at[3] == 'c' && x->at[4] == 'k' && x->at[5] == 'a' && x->at[6] == 'g' && x->at[7] == 'e') { + t->kind = LC_TokenKind_PackageDocComment; + } + } + + int counter = 0; + for (;;) { + if (x->at[0] == '*' && x->at[1] == '/') { + if (counter <= 0) break; + counter -= 1; + } else if (x->at[0] == '/' && x->at[1] == '*') { + counter += 1; + LC_LexAdvance(x); + } + LC_IF(x->at[0] == 0, "Unclosed block comment"); + LC_LexAdvance(x); + } + t->str += 2; + LC_SetTokenLen(x, t); + LC_LexAdvance(x); + LC_LexAdvance(x); +} + +LC_FUNCTION void LC_LexStringLiteral(LC_Lex *x, LC_Token *t, LC_TokenKind kind) { + t->kind = kind; + if (kind == LC_TokenKind_RawString) { + LC_EatUntilIncluding(x, '`'); + } else if (kind == LC_TokenKind_String) { + for (;;) { + LC_IF(x->at[0] == '\n', "got a new line while parsing a '\"' string literal"); + LC_IF(x->at[0] == 0, "reached end of file during string lexing"); + if (x->at[0] == '"') break; + if (x->at[0] == '\\' && x->at[1] == '"') LC_LexAdvance(x); + LC_LexAdvance(x); + } + LC_LexAdvance(x); + } else { + LC_IF(1, "internal compiler error: unhandled case in %s", __FUNCTION__); + } + + LC_SetTokenLen(x, t); + t->len -= 2; + t->str += 1; +} + +LC_FUNCTION void LC_LexUnicodeLiteral(LC_Lex *x, LC_Token *t) { + t->kind = LC_TokenKind_Unicode; + LC_UTF32Result decode = LC_ConvertUTF8ToUTF32(x->at, 4); + LC_IF(decode.error, "invalid utf8 sequence"); + + uint8_t c[8] = {0}; + for (int i = 0; i < decode.advance; i += 1) { + c[i] = x->at[0]; + LC_LexAdvance(x); + } + uint64_t result = *(uint64_t *)&c[0]; + + if (result == '\\') { + LC_ASSERT(NULL, decode.advance == 1); + result = LC_GetEscapeCode(x->at[0]); + LC_IF(result == UINT64_MAX, "invalid escape code"); + LC_LexAdvance(x); + } + LC_IF(x->at[0] != '\'', "unclosed unicode literal"); + + LC_Bigint_init_signed(&t->i, result); + LC_LexAdvance(x); + LC_SetTokenLen(x, t); + t->str += 1; + t->len -= 2; + + LC_IF(t->len == 0, "empty unicode literal"); +} + +LC_FUNCTION void LC_LexIntOrFloat(LC_Lex *x, LC_Token *t) { + t->kind = LC_TokenKind_Int; + for (;;) { + if (x->at[0] == '.') { + LC_IF(t->kind == LC_TokenKind_Float, "failed to parse a floating point number, invalid format, found multiple '.'"); + if (t->kind == LC_TokenKind_Int) t->kind = LC_TokenKind_Float; + } else if (!LC_IsDigit(x->at[0])) break; + LC_LexAdvance(x); + } + + LC_SetTokenLen(x, t); + if (t->kind == LC_TokenKind_Int) { + t->i = LC_LexBigInt(t->str, t->len, 10); + } else if (t->kind == LC_TokenKind_Float) { + t->f64 = LC_ParseFloat(t->str, t->len); + } else { + LC_IF(1, "internal compiler error: unhandled case in %s", __FUNCTION__); + } +} + +LC_FUNCTION void LC_LexCase2(LC_Lex *x, LC_Token *t, LC_TokenKind tk0, char c, LC_TokenKind tk1) { + t->kind = tk0; + if (x->at[0] == c) { + LC_LexAdvance(x); + t->kind = tk1; + } +} + +LC_FUNCTION void LC_LexCase3(LC_Lex *x, LC_Token *t, LC_TokenKind tk, char c0, LC_TokenKind tk0, char c1, LC_TokenKind tk1) { + t->kind = tk; + if (x->at[0] == c0) { + t->kind = tk0; + LC_LexAdvance(x); + } else if (x->at[0] == c1) { + t->kind = tk1; + LC_LexAdvance(x); + } +} + +LC_FUNCTION void LC_LexCase4(LC_Lex *x, LC_Token *t, LC_TokenKind tk, char c0, LC_TokenKind tk0, char c1, LC_TokenKind tk1, char c2, LC_TokenKind tk2) { + t->kind = tk; + if (x->at[0] == c0) { + t->kind = tk0; + LC_LexAdvance(x); + } else if (x->at[0] == c1) { + LC_LexAdvance(x); + LC_LexCase2(x, t, tk1, c2, tk2); + } +} + +LC_FUNCTION void LC_LexNext(LC_Lex *x, LC_Token *t) { + LC_EatWhitespace(x); + LC_MemoryZero(t, sizeof(LC_Token)); + t->str = x->at; + t->line = x->line + 1; + t->column = x->column; + t->lex = x; + char *c = x->at; + LC_LexAdvance(x); + + switch (c[0]) { + case 0: t->kind = LC_TokenKind_EOF; break; + case '(': t->kind = LC_TokenKind_OpenParen; break; + case ')': t->kind = LC_TokenKind_CloseParen; break; + case '{': t->kind = LC_TokenKind_OpenBrace; break; + case '}': t->kind = LC_TokenKind_CloseBrace; break; + case '[': t->kind = LC_TokenKind_OpenBracket; break; + case ']': t->kind = LC_TokenKind_CloseBracket; break; + case ',': t->kind = LC_TokenKind_Comma; break; + case ':': t->kind = LC_TokenKind_Colon; break; + case ';': t->kind = LC_TokenKind_Semicolon; break; + case '~': t->kind = LC_TokenKind_Neg; break; + case '#': t->kind = LC_TokenKind_Hash; break; + case '@': t->kind = LC_TokenKind_Note; break; + case '\'': LC_LexUnicodeLiteral(x, t); break; + case '"': LC_LexStringLiteral(x, t, LC_TokenKind_String); break; + case '`': LC_LexStringLiteral(x, t, LC_TokenKind_RawString); break; + case '=': LC_LexCase2(x, t, LC_TokenKind_Assign, '=', LC_TokenKind_Equals); break; + case '!': LC_LexCase2(x, t, LC_TokenKind_Not, '=', LC_TokenKind_NotEquals); break; + case '*': LC_LexCase2(x, t, LC_TokenKind_Mul, '=', LC_TokenKind_MulAssign); break; + case '%': LC_LexCase2(x, t, LC_TokenKind_Mod, '=', LC_TokenKind_ModAssign); break; + case '+': LC_LexCase2(x, t, LC_TokenKind_Add, '=', LC_TokenKind_AddAssign); break; + case '-': LC_LexCase2(x, t, LC_TokenKind_Sub, '=', LC_TokenKind_SubAssign); break; + case '^': LC_LexCase2(x, t, LC_TokenKind_BitXor, '=', LC_TokenKind_BitXorAssign); break; + case '&': LC_LexCase3(x, t, LC_TokenKind_BitAnd, '=', LC_TokenKind_BitAndAssign, '&', LC_TokenKind_And); break; + case '|': LC_LexCase3(x, t, LC_TokenKind_BitOr, '=', LC_TokenKind_BitOrAssign, '|', LC_TokenKind_Or); break; + case '>': LC_LexCase4(x, t, LC_TokenKind_GreaterThen, '=', LC_TokenKind_GreaterThenEq, '>', LC_TokenKind_RightShift, '=', LC_TokenKind_RightShiftAssign); break; + case '<': LC_LexCase4(x, t, LC_TokenKind_LesserThen, '=', LC_TokenKind_LesserThenEq, '<', LC_TokenKind_LeftShift, '=', LC_TokenKind_LeftShiftAssign); break; + case '.': { + t->kind = LC_TokenKind_Dot; + if (x->at[0] == '.' && x->at[1] == '.') { + t->kind = LC_TokenKind_ThreeDots; + LC_LexAdvance(x); + LC_LexAdvance(x); + } + } break; + + case '0': { + if (x->at[0] == 'x') { + t->kind = LC_TokenKind_Int; + LC_LexAdvance(x); + while (LC_IsHexDigit(x->at[0])) LC_LexAdvance(x); + LC_SetTokenLen(x, t); + LC_IF(t->len < 3, "invalid hex number"); + t->i = LC_LexBigInt(t->str + 2, t->len - 2, 16); + break; + } + if (x->at[0] == 'b') { + t->kind = LC_TokenKind_Int; + LC_LexAdvance(x); + while (LC_IsBinDigit(x->at[0])) LC_LexAdvance(x); + LC_SetTokenLen(x, t); + LC_IF(t->len < 3, "invalid binary number"); + t->i = LC_LexBigInt(t->str + 2, t->len - 2, 2); + break; + } + } // @fallthrough + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + LC_LexIntOrFloat(x, t); + } break; + + case 'A': + case 'a': + case 'B': + case 'b': + case 'C': + case 'c': + case 'D': + case 'd': + case 'E': + case 'e': + case 'F': + case 'f': + case 'G': + case 'g': + case 'H': + case 'h': + case 'I': + case 'i': + case 'J': + case 'j': + case 'K': + case 'k': + case 'L': + case 'l': + case 'M': + case 'm': + case 'N': + case 'n': + case 'O': + case 'o': + case 'P': + case 'p': + case 'Q': + case 'q': + case 'R': + case 'r': + case 'S': + case 's': + case 'T': + case 't': + case 'U': + case 'u': + case 'V': + case 'v': + case 'W': + case 'w': + case 'X': + case 'x': + case 'Y': + case 'y': + case 'Z': + case 'z': + case '_': { + t->kind = LC_TokenKind_Ident; + LC_EatIdent(x); + } break; + + case '/': { + t->kind = LC_TokenKind_Div; + if (x->at[0] == '=') { + t->kind = LC_TokenKind_DivAssign; + LC_LexAdvance(x); + } else if (x->at[0] == '/') { + t->kind = LC_TokenKind_Comment; + LC_LexAdvance(x); + while (x->at[0] != '\n' && x->at[0] != 0) LC_LexAdvance(x); + LC_SetTokenLen(x, t); + } else if (x->at[0] == '*') { + LC_LexNestedComments(x, t); + } + } break; + + default: LC_IF(1, "invalid character"); + } + if (t->len == 0 && t->kind != LC_TokenKind_String && t->kind != LC_TokenKind_RawString) LC_SetTokenLen(x, t); + if (t->kind == LC_TokenKind_Comment) LC_LexNext(x, t); +} + +LC_FUNCTION LC_Lex *LC_LexStream(char *file, char *str, int line) { + LC_Lex *x = LC_PushStruct(L->lex_arena, LC_Lex); + x->begin = str; + x->at = str; + x->file = LC_ILit(file); + x->line = line; + + for (;;) { + LC_Token *t = LC_PushStruct(L->lex_arena, LC_Token); + if (!x->tokens) x->tokens = t; + x->token_count += 1; + + LC_LexNext(x, t); + if (t->kind == LC_TokenKind_EOF) break; + } + + return x; +} + +LC_FUNCTION LC_String LC_GetTokenLine(LC_Token *token) { + LC_Lex *x = token->lex; + LC_String content = LC_MakeFromChar(x->begin); + LC_StringList lines = LC_Split(L->arena, content, LC_Lit("\n"), 0); + + LC_String l[3] = {LC_MakeEmptyString()}; + + int line = 1; + for (LC_StringNode *it = lines.first; it; it = it->next) { + LC_String sline = it->string; + if (token->line - 1 == line) { + l[0] = LC_Format(L->arena, "> %.*s\n", LC_Expand(sline)); + } + if (token->line + 1 == line) { + l[2] = LC_Format(L->arena, "> %.*s\n", LC_Expand(sline)); + break; + } + if (token->line == line) { + int begin = (int)(token->str - sline.str); + LC_String left = LC_GetPrefix(sline, begin); + LC_String past_left = LC_Skip(sline, begin); + LC_String mid = LC_GetPrefix(past_left, token->len); + LC_String right = LC_Skip(past_left, token->len); + + char *green = "\033[32m"; + char *reset = "\033[0m"; + if (!L->use_colored_terminal_output) { + green = ">>>>"; + reset = "<<<<"; + } + l[1] = LC_Format(L->arena, "> %.*s%s%.*s%s%.*s\n", LC_Expand(left), green, LC_Expand(mid), reset, LC_Expand(right)); + } + line += 1; + } + + LC_String result = LC_Format(L->arena, "%.*s%.*s%.*s", LC_Expand(l[0]), LC_Expand(l[1]), LC_Expand(l[2])); + return result; +} + +LC_FUNCTION void LC_InternTokens(LC_Lex *x) { + // @todo: add scratch, we can dump the LC_PushArray strings + for (int i = 0; i < x->token_count; i += 1) { + LC_Token *t = x->tokens + i; + if (t->kind == LC_TokenKind_String) { + int string_len = 0; + char *string = LC_PushArray(L->arena, char, t->len); + for (int i = 0; i < t->len; i += 1) { + char c0 = t->str[i]; + char c1 = t->str[i + 1]; + if (i + 1 >= t->len) c1 = 0; + + if (c0 == '\\') { + uint64_t code = LC_GetEscapeCode(c1); + if (code == UINT64_MAX) { + LC_LexingError(t, "invalid escape code in string '%c%c'", c0, c1); + break; + } + + c0 = (char)code; + i += 1; + } + + string[string_len++] = c0; + } + t->ident = LC_InternStrLen(string, string_len); + } + if (t->kind == LC_TokenKind_Note || t->kind == LC_TokenKind_Ident || t->kind == LC_TokenKind_RawString) { + t->ident = LC_InternStrLen(t->str, t->len); + } + if (t->kind == LC_TokenKind_Ident) { + bool is_keyword = t->ident >= L->first_keyword && t->ident <= L->last_keyword; + if (is_keyword) { + t->kind = LC_TokenKind_Keyword; + if (L->kaddptr == t->ident) t->kind = LC_TokenKind_AddPtr; + } + } + } +} + +#undef LC_IF + +/* +The bigint code was written by Christoffer Lerno, he is the programmer +behind C3. He allowed me to use this code without any restrictions. Great guy! +You can check out C3 compiler: https://github.com/c3lang/c3c +He also writes very helpful blogs about compilers: https://c3.handmade.network/blog +*/ + +#ifndef malloc_arena + #define malloc_arena(size) LC_PushSize(L->arena, size) +#endif +#define ALLOC_DIGITS(_digits) ((_digits) ? (uint64_t *)malloc_arena(sizeof(uint64_t) * (_digits)) : NULL) + +LC_FUNCTION uint32_t LC_u32_min(uint32_t a, uint32_t b) { + return a < b ? a : b; +} + +LC_FUNCTION size_t LC_size_max(size_t a, size_t b) { + return a > b ? a : b; +} + +LC_FUNCTION unsigned LC_unsigned_max(unsigned a, unsigned b) { + return a > b ? a : b; +} + +LC_FUNCTION uint64_t *LC_Bigint_ptr(LC_BigInt *big_int) { + return big_int->digit_count == 1 ? &big_int->digit : big_int->digits; +} + +LC_FUNCTION LC_BigInt LC_Bigint_u64(uint64_t val) { + LC_BigInt result = {0}; + LC_Bigint_init_unsigned(&result, val); + return result; +} + +LC_FUNCTION void LC_normalize(LC_BigInt *big_int) { + uint64_t *digits = LC_Bigint_ptr(big_int); + unsigned last_non_zero = UINT32_MAX; + for (unsigned i = 0; i < big_int->digit_count; i++) { + if (digits[i] != 0) { + last_non_zero = i; + } + } + if (last_non_zero == UINT32_MAX) { + big_int->is_negative = false; + big_int->digit_count = 0; + return; + } + big_int->digit_count = last_non_zero + 1; + if (!last_non_zero) { + big_int->digit = digits[0]; + } +} + +LC_FUNCTION char LC_digit_to_char(uint8_t digit, bool upper) { + if (digit <= 9) { + return (char)(digit + '0'); + } + if (digit <= 35) { + return (char)(digit + (upper ? 'A' : 'a') - 10); + } + LC_ASSERT(NULL, !"Can't reach"); + return 0; +} + +LC_FUNCTION bool LC_bit_at_index(LC_BigInt *big_int, size_t index) { + size_t digit_index = index / 64; + if (digit_index >= big_int->digit_count) { + return false; + } + size_t digit_bit_index = index % 64; + uint64_t *digits = LC_Bigint_ptr(big_int); + uint64_t digit = digits[digit_index]; + return ((digit >> digit_bit_index) & 0x1U) == 0x1U; +} + +LC_FUNCTION size_t LC_Bigint_bits_needed(LC_BigInt *big_int) { + size_t full_bits = big_int->digit_count * 64; + size_t leading_zero_count = LC_Bigint_clz(big_int, full_bits); + size_t bits_needed = full_bits - leading_zero_count; + return bits_needed + big_int->is_negative; +} + +LC_FUNCTION void LC_Bigint_init_unsigned(LC_BigInt *big_int, uint64_t value) { + if (value == 0) { + big_int->digit_count = 0; + big_int->is_negative = false; + return; + } + big_int->digit_count = 1; + big_int->digit = value; + big_int->is_negative = false; +} + +LC_FUNCTION void LC_Bigint_init_signed(LC_BigInt *dest, int64_t value) { + if (value >= 0) { + LC_Bigint_init_unsigned(dest, (uint64_t)value); + return; + } + dest->is_negative = true; + dest->digit_count = 1; + dest->digit = ((uint64_t)(-(value + 1))) + 1; +} + +LC_FUNCTION void LC_Bigint_init_bigint(LC_BigInt *dest, LC_BigInt *src) { + if (src->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + if (src->digit_count == 1) { + dest->digit_count = 1; + dest->digit = src->digit; + dest->is_negative = src->is_negative; + return; + } + dest->is_negative = src->is_negative; + dest->digit_count = src->digit_count; + dest->digits = ALLOC_DIGITS(dest->digit_count); + LC_MemoryCopy(dest->digits, src->digits, sizeof(uint64_t) * dest->digit_count); +} + +LC_FUNCTION void LC_Bigint_negate(LC_BigInt *dest, LC_BigInt *source) { + LC_Bigint_init_bigint(dest, source); + dest->is_negative = !dest->is_negative; + LC_normalize(dest); +} + +LC_FUNCTION void LC_to_twos_complement(LC_BigInt *dest, LC_BigInt *source, size_t bit_count) { + if (bit_count == 0 || source->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + if (source->is_negative) { + LC_BigInt negated = {0}; + LC_Bigint_negate(&negated, source); + + LC_BigInt inverted = {0}; + LC_Bigint_not(&inverted, &negated, bit_count, false); + + LC_BigInt one = {0}; + LC_Bigint_init_unsigned(&one, 1); + + LC_Bigint_add(dest, &inverted, &one); + return; + } + + dest->is_negative = false; + uint64_t *source_digits = LC_Bigint_ptr(source); + if (source->digit_count == 1) { + dest->digit = source_digits[0]; + if (bit_count < 64) { + dest->digit &= (1ULL << bit_count) - 1; + } + dest->digit_count = 1; + LC_normalize(dest); + return; + } + unsigned digits_to_copy = (unsigned int)(bit_count / 64); + unsigned leftover_bits = (unsigned int)(bit_count % 64); + dest->digit_count = digits_to_copy + ((leftover_bits == 0) ? 0 : 1); + if (dest->digit_count == 1 && leftover_bits == 0) { + dest->digit = source_digits[0]; + if (dest->digit == 0) dest->digit_count = 0; + return; + } + dest->digits = (uint64_t *)malloc_arena(dest->digit_count * sizeof(uint64_t)); + for (size_t i = 0; i < digits_to_copy; i += 1) { + uint64_t digit = (i < source->digit_count) ? source_digits[i] : 0; + dest->digits[i] = digit; + } + if (leftover_bits != 0) { + uint64_t digit = (digits_to_copy < source->digit_count) ? source_digits[digits_to_copy] : 0; + dest->digits[digits_to_copy] = digit & ((1ULL << leftover_bits) - 1); + } + LC_normalize(dest); +} + +LC_FUNCTION size_t LC_Bigint_clz(LC_BigInt *big_int, size_t bit_count) { + if (big_int->is_negative || bit_count == 0) { + return 0; + } + if (big_int->digit_count == 0) { + return bit_count; + } + size_t count = 0; + for (size_t i = bit_count - 1;;) { + if (LC_bit_at_index(big_int, i)) { + return count; + } + count++; + if (i == 0) break; + i--; + } + return count; +} + +LC_FUNCTION bool LC_Bigint_eql(LC_BigInt a, LC_BigInt b) { + return LC_Bigint_cmp(&a, &b) == LC_CmpRes_EQ; +} + +LC_FUNCTION void LC_from_twos_complement(LC_BigInt *dest, LC_BigInt *src, size_t bit_count, bool is_signed) { + LC_ASSERT(NULL, !src->is_negative); + + if (bit_count == 0 || src->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + if (is_signed && LC_bit_at_index(src, bit_count - 1)) { + LC_BigInt negative_one = {0}; + LC_Bigint_init_signed(&negative_one, -1); + + LC_BigInt minus_one = {0}; + LC_Bigint_add(&minus_one, src, &negative_one); + + LC_BigInt inverted = {0}; + LC_Bigint_not(&inverted, &minus_one, bit_count, false); + + LC_Bigint_negate(dest, &inverted); + return; + } + + LC_Bigint_init_bigint(dest, src); +} + +void LC_Bigint_init_data(LC_BigInt *dest, uint64_t *digits, unsigned int digit_count, bool is_negative) { + if (digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + if (digit_count == 1) { + dest->digit_count = 1; + dest->digit = digits[0]; + dest->is_negative = is_negative; + LC_normalize(dest); + return; + } + + dest->digit_count = digit_count; + dest->is_negative = is_negative; + dest->digits = ALLOC_DIGITS(digit_count); + LC_MemoryCopy(dest->digits, digits, sizeof(uint64_t) * digit_count); + + LC_normalize(dest); +} + +LC_FUNCTION bool LC_Bigint_fits_in_bits(LC_BigInt *big_int, size_t bit_count, bool is_signed) { + LC_ASSERT(NULL, big_int->digit_count != 1 || big_int->digit != 0); + if (bit_count == 0) { + return LC_Bigint_cmp_zero(big_int) == LC_CmpRes_EQ; + } + if (big_int->digit_count == 0) { + return true; + } + + if (!is_signed) { + size_t full_bits = big_int->digit_count * 64; + size_t leading_zero_count = LC_Bigint_clz(big_int, full_bits); + return bit_count >= full_bits - leading_zero_count; + } + + LC_BigInt one = {0}; + LC_Bigint_init_unsigned(&one, 1); + + LC_BigInt shl_amt = {0}; + LC_Bigint_init_unsigned(&shl_amt, bit_count - 1); + + LC_BigInt max_value_plus_one = {0}; + LC_Bigint_shl(&max_value_plus_one, &one, &shl_amt); + + LC_BigInt max_value = {0}; + LC_Bigint_sub(&max_value, &max_value_plus_one, &one); + + LC_BigInt min_value = {0}; + LC_Bigint_negate(&min_value, &max_value_plus_one); + + LC_CmpRes min_cmp = LC_Bigint_cmp(big_int, &min_value); + LC_CmpRes max_cmp = LC_Bigint_cmp(big_int, &max_value); + + return (min_cmp == LC_CmpRes_GT || min_cmp == LC_CmpRes_EQ) && (max_cmp == LC_CmpRes_LT || max_cmp == LC_CmpRes_EQ); +} + +LC_FUNCTION uint64_t LC_Bigint_as_unsigned(LC_BigInt *bigint) { + LC_ASSERT(NULL, !bigint->is_negative); + if (bigint->digit_count == 0) { + return 0; + } + if (bigint->digit_count != 1) { + LC_ASSERT(NULL, !"Bigint exceeds u64"); + } + return bigint->digit; +} + +#if defined(_MSC_VER) + +LC_FUNCTION bool LC_add_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + *result = op1 + op2; + return *result < op1 || *result < op2; +} + +LC_FUNCTION bool LC_sub_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + *result = op1 - op2; + return *result > op1; +} + +LC_FUNCTION bool LC_mul_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + *result = op1 * op2; + + if (op1 == 0 || op2 == 0) return false; + if (op1 > UINT64_MAX / op2) return true; + if (op2 > UINT64_MAX / op1) return true; + return false; +} + +#else + +LC_FUNCTION bool LC_add_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + return __builtin_uaddll_overflow((unsigned long long)op1, (unsigned long long)op2, + (unsigned long long *)result); +} + +LC_FUNCTION bool LC_sub_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + return __builtin_usubll_overflow((unsigned long long)op1, (unsigned long long)op2, + (unsigned long long *)result); +} + +LC_FUNCTION bool LC_mul_u64_overflow(uint64_t op1, uint64_t op2, uint64_t *result) { + return __builtin_umulll_overflow((unsigned long long)op1, (unsigned long long)op2, + (unsigned long long *)result); +} + +#endif + +LC_FUNCTION void LC_Bigint_add(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->digit_count == 0) { + LC_Bigint_init_bigint(dest, op2); + return; + } + if (op2->digit_count == 0) { + LC_Bigint_init_bigint(dest, op1); + return; + } + if (op1->is_negative == op2->is_negative) { + dest->is_negative = op1->is_negative; + + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + uint64_t overflow = LC_add_u64_overflow(op1_digits[0], op2_digits[0], &dest->digit); + if (overflow == 0 && op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit_count = 1; + LC_normalize(dest); + return; + } + unsigned i = 1; + uint64_t first_digit = dest->digit; + dest->digits = ALLOC_DIGITS(LC_unsigned_max(op1->digit_count, op2->digit_count) + 1); + dest->digits[0] = first_digit; + + for (;;) { + bool found_digit = false; + uint64_t x = (uint64_t)overflow; + overflow = 0; + + if (i < op1->digit_count) { + found_digit = true; + uint64_t digit = op1_digits[i]; + overflow += LC_add_u64_overflow(x, digit, &x); + } + + if (i < op2->digit_count) { + found_digit = true; + uint64_t digit = op2_digits[i]; + overflow += LC_add_u64_overflow(x, digit, &x); + } + + dest->digits[i] = x; + i += 1; + + if (!found_digit) { + dest->digit_count = i; + LC_normalize(dest); + return; + } + } + } + LC_BigInt *op_pos; + LC_BigInt *op_neg; + if (op1->is_negative) { + op_neg = op1; + op_pos = op2; + } else { + op_pos = op1; + op_neg = op2; + } + + LC_BigInt op_neg_abs = {0}; + LC_Bigint_negate(&op_neg_abs, op_neg); + LC_BigInt *bigger_op; + LC_BigInt *smaller_op; + switch (LC_Bigint_cmp(op_pos, &op_neg_abs)) { + case LC_CmpRes_EQ: + LC_Bigint_init_unsigned(dest, 0); + return; + case LC_CmpRes_LT: + bigger_op = &op_neg_abs; + smaller_op = op_pos; + dest->is_negative = true; + break; + case LC_CmpRes_GT: + bigger_op = op_pos; + smaller_op = &op_neg_abs; + dest->is_negative = false; + break; + default: + LC_ASSERT(NULL, !"UNREACHABLE"); + } + uint64_t *bigger_op_digits = LC_Bigint_ptr(bigger_op); + uint64_t *smaller_op_digits = LC_Bigint_ptr(smaller_op); + uint64_t overflow = (uint64_t)LC_sub_u64_overflow(bigger_op_digits[0], smaller_op_digits[0], &dest->digit); + if (overflow == 0 && bigger_op->digit_count == 1 && smaller_op->digit_count == 1) { + dest->digit_count = 1; + LC_normalize(dest); + return; + } + uint64_t first_digit = dest->digit; + dest->digits = ALLOC_DIGITS(bigger_op->digit_count); + dest->digits[0] = first_digit; + unsigned i = 1; + + for (;;) { + bool found_digit = false; + uint64_t x = bigger_op_digits[i]; + uint64_t prev_overflow = overflow; + overflow = 0; + + if (i < smaller_op->digit_count) { + found_digit = true; + uint64_t digit = smaller_op_digits[i]; + overflow += LC_sub_u64_overflow(x, digit, &x); + } + if (LC_sub_u64_overflow(x, prev_overflow, &x)) { + found_digit = true; + overflow += 1; + } + dest->digits[i] = x; + i += 1; + + if (!found_digit || i >= bigger_op->digit_count) { + break; + } + } + LC_ASSERT(NULL, overflow == 0); + dest->digit_count = i; + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_add_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed) { + LC_BigInt unwrapped = {0}; + LC_Bigint_add(&unwrapped, op1, op2); + LC_Bigint_truncate(dest, &unwrapped, bit_count, is_signed); +} + +LC_FUNCTION void LC_Bigint_sub(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + LC_BigInt op2_negated = {0}; + LC_Bigint_negate(&op2_negated, op2); + LC_Bigint_add(dest, op1, &op2_negated); + return; +} + +LC_FUNCTION void LC_Bigint_sub_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed) { + LC_BigInt op2_negated = {0}; + LC_Bigint_negate(&op2_negated, op2); + LC_Bigint_add_wrap(dest, op1, &op2_negated, bit_count, is_signed); + return; +} + +LC_FUNCTION void mul_overflow(uint64_t op1, uint64_t op2, uint64_t *lo, uint64_t *hi) { + uint64_t u1 = (op1 & 0xffffffff); + uint64_t v1 = (op2 & 0xffffffff); + uint64_t t = (u1 * v1); + uint64_t w3 = (t & 0xffffffff); + uint64_t k = (t >> 32); + + op1 >>= 32; + t = (op1 * v1) + k; + k = (t & 0xffffffff); + uint64_t w1 = (t >> 32); + + op2 >>= 32; + t = (u1 * op2) + k; + k = (t >> 32); + + *hi = (op1 * op2) + w1 + k; + *lo = (t << 32) + w3; +} + +LC_FUNCTION void LC_mul_scalar(LC_BigInt *dest, LC_BigInt *op, uint64_t scalar) { + LC_Bigint_init_unsigned(dest, 0); + + LC_BigInt bi_64; + LC_Bigint_init_unsigned(&bi_64, 64); + + uint64_t *op_digits = LC_Bigint_ptr(op); + size_t i = op->digit_count - 1; + + while (1) { + LC_BigInt shifted; + LC_Bigint_shl(&shifted, dest, &bi_64); + + uint64_t result_scalar; + uint64_t carry_scalar; + mul_overflow(scalar, op_digits[i], &result_scalar, &carry_scalar); + + LC_BigInt result; + LC_Bigint_init_unsigned(&result, result_scalar); + + LC_BigInt carry; + LC_Bigint_init_unsigned(&carry, carry_scalar); + + LC_BigInt carry_shifted; + LC_Bigint_shl(&carry_shifted, &carry, &bi_64); + + LC_BigInt tmp; + LC_Bigint_add(&tmp, &shifted, &carry_shifted); + + LC_Bigint_add(dest, &tmp, &result); + + if (i == 0) { + break; + } + i -= 1; + } +} + +LC_FUNCTION void LC_Bigint_mul(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->digit_count == 0 || op2->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + + uint64_t carry; + mul_overflow(op1_digits[0], op2_digits[0], &dest->digit, &carry); + if (carry == 0 && op1->digit_count == 1 && op2->digit_count == 1) { + dest->is_negative = (op1->is_negative != op2->is_negative); + dest->digit_count = 1; + LC_normalize(dest); + return; + } + + LC_Bigint_init_unsigned(dest, 0); + + LC_BigInt bi_64; + LC_Bigint_init_unsigned(&bi_64, 64); + + size_t i = op2->digit_count - 1; + for (;;) { + LC_BigInt shifted; + LC_Bigint_shl(&shifted, dest, &bi_64); + + LC_BigInt scalar_result; + LC_mul_scalar(&scalar_result, op1, op2_digits[i]); + + LC_Bigint_add(dest, &scalar_result, &shifted); + + if (i == 0) { + break; + } + i -= 1; + } + + dest->is_negative = (op1->is_negative != op2->is_negative); + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_mul_wrap(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed) { + LC_BigInt unwrapped = {0}; + LC_Bigint_mul(&unwrapped, op1, op2); + LC_Bigint_truncate(dest, &unwrapped, bit_count, is_signed); +} + +LC_FUNCTION unsigned LC_count_leading_zeros(uint32_t val) { + if (val == 0) return 32; + +#if _MSC_VER + unsigned long Index; + _BitScanReverse(&Index, val); + return Index ^ 31; +#else + return __builtin_clz(val); +#endif +} + +// Make a 64-bit integer from a high / low pair of 32-bit integers. +LC_FUNCTION uint64_t LC_make_64(uint32_t hi, uint32_t lo) { + return (((uint64_t)hi) << 32) | ((uint64_t)lo); +} + +// Return the high 32 bits of a 64 bit value. +LC_FUNCTION uint32_t LC_hi_32(uint64_t value) { + return (uint32_t)(value >> 32); +} + +// Return the low 32 bits of a 64 bit value. +LC_FUNCTION uint32_t LC_lo_32(uint64_t val) { + return (uint32_t)val; +} + +// Implementation of Knuth's Algorithm D (Division of nonnegative integers) +// from "Art of Computer Programming, Volume 2", section 4.3.1, p. 272. The +// variables here have the same names as in the algorithm. Comments explain +// the algorithm and any deviation from it. +LC_FUNCTION void LC_knuth_div(uint32_t *u, uint32_t *v, uint32_t *q, uint32_t *r, unsigned m, unsigned n) { + LC_ASSERT(NULL, u && "Must provide dividend"); + LC_ASSERT(NULL, v && "Must provide divisor"); + LC_ASSERT(NULL, q && "Must provide quotient"); + LC_ASSERT(NULL, u != v && u != q && v != q && "Must use different memory"); + LC_ASSERT(NULL, n > 1 && "n must be > 1"); + + // b denotes the base of the number system. In our case b is 2^32. + uint64_t b = ((uint64_t)1) << 32; + + // D1. [Normalize.] Set d = b / (v[n-1] + 1) and multiply all the digits of + // u and v by d. Note that we have taken Knuth's advice here to use a power + // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of + // 2 allows us to shift instead of multiply and it is easy to determine the + // shift amount from the leading zeros. We are basically normalizing the u + // and v so that its high bits are shifted to the top of v's range without + // overflow. Note that this can require an extra word in u so that u must + // be of length m+n+1. + unsigned shift = LC_count_leading_zeros(v[n - 1]); + uint32_t v_carry = 0; + uint32_t u_carry = 0; + if (shift) { + for (unsigned i = 0; i < m + n; ++i) { + uint32_t u_tmp = u[i] >> (32 - shift); + u[i] = (u[i] << shift) | u_carry; + u_carry = u_tmp; + } + for (unsigned i = 0; i < n; ++i) { + uint32_t v_tmp = v[i] >> (32 - shift); + v[i] = (v[i] << shift) | v_carry; + v_carry = v_tmp; + } + } + u[m + n] = u_carry; + + // D2. [Initialize j.] Set j to m. This is the loop counter over the places. + int j = (int)m; + do { + // D3. [Calculate q'.]. + // Set qp = (u[j+n]*b + u[j+n-1]) / v[n-1]. (qp=qprime=q') + // Set rp = (u[j+n]*b + u[j+n-1]) % v[n-1]. (rp=rprime=r') + // Now test if qp == b or qp*v[n-2] > b*rp + u[j+n-2]; if so, decrease + // qp by 1, increase rp by v[n-1], and repeat this test if rp < b. The test + // on v[n-2] determines at high speed most of the cases in which the trial + // value qp is one too large, and it eliminates all cases where qp is two + // too large. + uint64_t dividend = LC_make_64(u[j + n], u[j + n - 1]); + uint64_t qp = dividend / v[n - 1]; + uint64_t rp = dividend % v[n - 1]; + if (qp == b || qp * v[n - 2] > b * rp + u[j + n - 2]) { + qp--; + rp += v[n - 1]; + if (rp < b && (qp == b || qp * v[n - 2] > b * rp + u[j + n - 2])) { + qp--; + } + } + + // D4. [Multiply and subtract.] Replace (u[j+n]u[j+n-1]...u[j]) with + // (u[j+n]u[j+n-1]..u[j]) - qp * (v[n-1]...v[1]v[0]). This computation + // consists of a simple multiplication by a one-place number, combined with + // a subtraction. + // The digits (u[j+n]...u[j]) should be kept positive; if the result of + // this step is actually negative, (u[j+n]...u[j]) should be left as the + // true value plus b**(n+1), namely as the b's complement of + // the true value, and a "borrow" to the left should be remembered. + int64_t borrow = 0; + for (unsigned i = 0; i < n; ++i) { + uint64_t p = ((uint64_t)qp) * ((uint64_t)(v[i])); + int64_t subres = ((int64_t)(u[j + i])) - borrow - LC_lo_32(p); + u[j + i] = LC_lo_32((uint64_t)subres); + borrow = LC_hi_32(p) - LC_hi_32((uint64_t)subres); + } + bool is_neg = u[j + n] < borrow; + u[j + n] -= LC_lo_32((uint64_t)borrow); + + // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was + // negative, go to step D6; otherwise go on to step D7. + q[j] = LC_lo_32(qp); + if (is_neg) { + // D6. [Add back]. The probability that this step is necessary is very + // small, on the order of only 2/b. Make sure that test data accounts for + // this possibility. Decrease q[j] by 1 + q[j]--; + // and add (0v[n-1]...v[1]v[0]) to (u[j+n]u[j+n-1]...u[j+1]u[j]). + // A carry will occur to the left of u[j+n], and it should be ignored + // since it cancels with the borrow that occurred in D4. + bool carry = false; + for (unsigned i = 0; i < n; i++) { + uint32_t limit = LC_u32_min(u[j + i], v[i]); + u[j + i] += v[i] + carry; + carry = u[j + i] < limit || (carry && u[j + i] == limit); + } + u[j + n] += carry; + } + + // D7. [Loop on j.] Decrease j by one. Now if j >= 0, go back to D3. + } while (--j >= 0); + + // D8. [Unnormalize]. Now q[...] is the desired quotient, and the desired + // remainder may be obtained by dividing u[...] by d. If r is non-null we + // compute the remainder (urem uses this). + if (r) { + // The value d is expressed by the "shift" value above since we avoided + // multiplication by d by using a shift left. So, all we have to do is + // shift right here. + if (shift) { + uint32_t carry = 0; + for (int i = (int)n - 1; i >= 0; i--) { + r[i] = (u[i] >> shift) | carry; + carry = u[i] << (32 - shift); + } + } else { + for (int i = (int)n - 1; i >= 0; i--) { + r[i] = u[i]; + } + } + } +} + +LC_FUNCTION void LC_Bigint_unsigned_division(LC_BigInt *op1, LC_BigInt *op2, LC_BigInt *Quotient, LC_BigInt *Remainder) { + LC_CmpRes cmp = LC_Bigint_cmp(op1, op2); + if (cmp == LC_CmpRes_LT) { + if (!Quotient) { + LC_Bigint_init_unsigned(Quotient, 0); + } + if (!Remainder) { + LC_Bigint_init_bigint(Remainder, op1); + } + return; + } + if (cmp == LC_CmpRes_EQ) { + if (!Quotient) { + LC_Bigint_init_unsigned(Quotient, 1); + } + if (!Remainder) { + LC_Bigint_init_unsigned(Remainder, 0); + } + return; + } + + uint64_t *lhs = LC_Bigint_ptr(op1); + uint64_t *rhs = LC_Bigint_ptr(op2); + unsigned lhsWords = op1->digit_count; + unsigned rhsWords = op2->digit_count; + + // First, compose the values into an array of 32-bit words instead of + // 64-bit words. This is a necessity of both the "short division" algorithm + // and the Knuth "classical algorithm" which requires there to be native + // operations for +, -, and * on an m bit value with an m*2 bit result. We + // can't use 64-bit operands here because we don't have native results of + // 128-bits. Furthermore, casting the 64-bit values to 32-bit values won't + // work on large-endian machines. + unsigned n = rhsWords * 2; + unsigned m = (lhsWords * 2) - n; + + // Allocate space for the temporary values we need either on the stack, if + // it will fit, or on the heap if it won't. + uint32_t space[128]; + uint32_t *U = NULL; + uint32_t *V = NULL; + uint32_t *Q = NULL; + uint32_t *R = NULL; + if ((Remainder ? 4 : 3) * n + 2 * m + 1 <= 128) { + U = &space[0]; + V = &space[m + n + 1]; + Q = &space[(m + n + 1) + n]; + if (Remainder) { + R = &space[(m + n + 1) + n + (m + n)]; + } + } else { + U = (uint32_t *)malloc_arena(sizeof(uint32_t) * (m + n + 1)); + V = (uint32_t *)malloc_arena(sizeof(uint32_t) * n); + Q = (uint32_t *)malloc_arena(sizeof(uint32_t) * (m + n)); + if (Remainder) { + R = (uint32_t *)malloc_arena(sizeof(uint32_t) * n); + } + } + + // Initialize the dividend + LC_MemoryZero(U, (m + n + 1) * sizeof(uint32_t)); + for (unsigned i = 0; i < lhsWords; ++i) { + uint64_t tmp = lhs[i]; + U[i * 2] = LC_lo_32(tmp); + U[i * 2 + 1] = LC_hi_32(tmp); + } + U[m + n] = 0; // this extra word is for "spill" in the Knuth algorithm. + + // Initialize the divisor + LC_MemoryZero(V, (n) * sizeof(uint32_t)); + for (unsigned i = 0; i < rhsWords; ++i) { + uint64_t tmp = rhs[i]; + V[i * 2] = LC_lo_32(tmp); + V[i * 2 + 1] = LC_hi_32(tmp); + } + + // initialize the quotient and remainder + LC_MemoryZero(Q, (m + n) * sizeof(uint32_t)); + if (Remainder) LC_MemoryZero(R, n * sizeof(uint32_t)); + + // Now, adjust m and n for the Knuth division. n is the number of words in + // the divisor. m is the number of words by which the dividend exceeds the + // divisor (i.e. m+n is the length of the dividend). These sizes must not + // contain any zero words or the Knuth algorithm fails. + for (unsigned i = n; i > 0 && V[i - 1] == 0; i--) { + n--; + m++; + } + for (unsigned i = m + n; i > 0 && U[i - 1] == 0; i--) { + m--; + } + + // If we're left with only a single word for the divisor, Knuth doesn't work + // so we implement the short division algorithm here. This is much simpler + // and faster because we are certain that we can divide a 64-bit quantity + // by a 32-bit quantity at hardware speed and short division is simply a + // series of such operations. This is just like doing short division but we + // are using base 2^32 instead of base 10. + LC_ASSERT(NULL, n != 0 && "Divide by zero?"); + if (n == 1) { + uint32_t divisor = V[0]; + uint32_t rem = 0; + for (int i = (int)m; i >= 0; i--) { + uint64_t partial_dividend = LC_make_64(rem, U[i]); + if (partial_dividend == 0) { + Q[i] = 0; + rem = 0; + } else if (partial_dividend < divisor) { + Q[i] = 0; + rem = LC_lo_32(partial_dividend); + } else if (partial_dividend == divisor) { + Q[i] = 1; + rem = 0; + } else { + Q[i] = LC_lo_32(partial_dividend / divisor); + rem = LC_lo_32(partial_dividend - (Q[i] * divisor)); + } + } + if (R) { + R[0] = rem; + } + } else { + // Now we're ready to invoke the Knuth classical divide algorithm. In this + // case n > 1. + LC_knuth_div(U, V, Q, R, m, n); + } + + // If the caller wants the quotient + if (Quotient) { + Quotient->is_negative = false; + Quotient->digit_count = lhsWords; + if (lhsWords == 1) { + Quotient->digit = LC_make_64(Q[1], Q[0]); + } else { + Quotient->digits = ALLOC_DIGITS(lhsWords); + for (size_t i = 0; i < lhsWords; i += 1) { + Quotient->digits[i] = LC_make_64(Q[i * 2 + 1], Q[i * 2]); + } + } + } + + // If the caller wants the remainder + if (Remainder) { + Remainder->is_negative = false; + Remainder->digit_count = rhsWords; + if (rhsWords == 1) { + Remainder->digit = LC_make_64(R[1], R[0]); + } else { + Remainder->digits = ALLOC_DIGITS(rhsWords); + for (size_t i = 0; i < rhsWords; i += 1) { + Remainder->digits[i] = LC_make_64(R[i * 2 + 1], R[i * 2]); + } + } + } +} + +LC_FUNCTION void LC_Bigint_div_trunc(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + LC_ASSERT(NULL, op2->digit_count != 0); // division by zero + if (op1->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + if (op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit = op1_digits[0] / op2_digits[0]; + dest->digit_count = 1; + dest->is_negative = op1->is_negative != op2->is_negative; + LC_normalize(dest); + return; + } + if (op2->digit_count == 1 && op2_digits[0] == 1) { + // X / 1 == X + LC_Bigint_init_bigint(dest, op1); + dest->is_negative = op1->is_negative != op2->is_negative; + LC_normalize(dest); + return; + } + + LC_BigInt *op1_positive; + LC_BigInt op1_positive_data; + if (op1->is_negative) { + LC_Bigint_negate(&op1_positive_data, op1); + op1_positive = &op1_positive_data; + } else { + op1_positive = op1; + } + + LC_BigInt *op2_positive; + LC_BigInt op2_positive_data; + if (op2->is_negative) { + LC_Bigint_negate(&op2_positive_data, op2); + op2_positive = &op2_positive_data; + } else { + op2_positive = op2; + } + + LC_Bigint_unsigned_division(op1_positive, op2_positive, dest, NULL); + dest->is_negative = op1->is_negative != op2->is_negative; + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_div_floor(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->is_negative != op2->is_negative) { + LC_Bigint_div_trunc(dest, op1, op2); + LC_BigInt mult_again = {0}; + LC_Bigint_mul(&mult_again, dest, op2); + mult_again.is_negative = op1->is_negative; + if (LC_Bigint_cmp(&mult_again, op1) != LC_CmpRes_EQ) { + LC_BigInt tmp = {0}; + LC_Bigint_init_bigint(&tmp, dest); + LC_BigInt neg_one = {0}; + LC_Bigint_init_signed(&neg_one, -1); + LC_Bigint_add(dest, &tmp, &neg_one); + } + LC_normalize(dest); + } else { + LC_Bigint_div_trunc(dest, op1, op2); + } +} + +LC_FUNCTION void LC_Bigint_rem(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + LC_ASSERT(NULL, op2->digit_count != 0); // division by zero + if (op1->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + + if (op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit = op1_digits[0] % op2_digits[0]; + dest->digit_count = 1; + dest->is_negative = op1->is_negative; + LC_normalize(dest); + return; + } + if (op2->digit_count == 2 && op2_digits[0] == 0 && op2_digits[1] == 1) { + // special case this divisor + LC_Bigint_init_unsigned(dest, op1_digits[0]); + dest->is_negative = op1->is_negative; + LC_normalize(dest); + return; + } + + if (op2->digit_count == 1 && op2_digits[0] == 1) { + // X % 1 == 0 + LC_Bigint_init_unsigned(dest, 0); + return; + } + + LC_BigInt *op1_positive; + LC_BigInt op1_positive_data; + if (op1->is_negative) { + LC_Bigint_negate(&op1_positive_data, op1); + op1_positive = &op1_positive_data; + } else { + op1_positive = op1; + } + + LC_BigInt *op2_positive; + LC_BigInt op2_positive_data; + if (op2->is_negative) { + LC_Bigint_negate(&op2_positive_data, op2); + op2_positive = &op2_positive_data; + } else { + op2_positive = op2; + } + + LC_Bigint_unsigned_division(op1_positive, op2_positive, NULL, dest); + dest->is_negative = op1->is_negative; + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_mod(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->is_negative) { + LC_BigInt first_rem; + LC_Bigint_rem(&first_rem, op1, op2); + first_rem.is_negative = !op2->is_negative; + LC_BigInt op2_minus_rem; + LC_Bigint_add(&op2_minus_rem, op2, &first_rem); + LC_Bigint_rem(dest, &op2_minus_rem, op2); + dest->is_negative = false; + } else { + LC_Bigint_rem(dest, op1, op2); + dest->is_negative = false; + } +} + +LC_FUNCTION void LC_Bigint_or(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->digit_count == 0) { + LC_Bigint_init_bigint(dest, op2); + return; + } + if (op2->digit_count == 0) { + LC_Bigint_init_bigint(dest, op1); + return; + } + if (op1->is_negative || op2->is_negative) { + size_t big_bit_count = LC_size_max(LC_Bigint_bits_needed(op1), LC_Bigint_bits_needed(op2)); + + LC_BigInt twos_comp_op1 = {0}; + LC_to_twos_complement(&twos_comp_op1, op1, big_bit_count); + + LC_BigInt twos_comp_op2 = {0}; + LC_to_twos_complement(&twos_comp_op2, op2, big_bit_count); + + LC_BigInt twos_comp_dest = {0}; + LC_Bigint_or(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2); + + LC_from_twos_complement(dest, &twos_comp_dest, big_bit_count, true); + } else { + dest->is_negative = false; + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + if (op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit_count = 1; + dest->digit = op1_digits[0] | op2_digits[0]; + LC_normalize(dest); + return; + } + dest->digit_count = LC_unsigned_max(op1->digit_count, op2->digit_count); + dest->digits = ALLOC_DIGITS(dest->digit_count); + for (size_t i = 0; i < dest->digit_count; i += 1) { + uint64_t digit = 0; + if (i < op1->digit_count) { + digit |= op1_digits[i]; + } + if (i < op2->digit_count) { + digit |= op2_digits[i]; + } + dest->digits[i] = digit; + } + LC_normalize(dest); + } +} + +LC_FUNCTION void LC_Bigint_and(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->digit_count == 0 || op2->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + if (op1->is_negative || op2->is_negative) { + size_t big_bit_count = LC_size_max(LC_Bigint_bits_needed(op1), LC_Bigint_bits_needed(op2)); + + LC_BigInt twos_comp_op1 = {0}; + LC_to_twos_complement(&twos_comp_op1, op1, big_bit_count); + + LC_BigInt twos_comp_op2 = {0}; + LC_to_twos_complement(&twos_comp_op2, op2, big_bit_count); + + LC_BigInt twos_comp_dest = {0}; + LC_Bigint_and(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2); + + LC_from_twos_complement(dest, &twos_comp_dest, big_bit_count, true); + } else { + dest->is_negative = false; + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + if (op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit_count = 1; + dest->digit = op1_digits[0] & op2_digits[0]; + LC_normalize(dest); + return; + } + + dest->digit_count = LC_unsigned_max(op1->digit_count, op2->digit_count); + dest->digits = ALLOC_DIGITS(dest->digit_count); + + size_t i = 0; + for (; i < op1->digit_count && i < op2->digit_count; i += 1) { + dest->digits[i] = op1_digits[i] & op2_digits[i]; + } + for (; i < dest->digit_count; i += 1) { + dest->digits[i] = 0; + } + LC_normalize(dest); + } +} + +LC_FUNCTION void LC_Bigint_xor(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + if (op1->digit_count == 0) { + LC_Bigint_init_bigint(dest, op2); + return; + } + if (op2->digit_count == 0) { + LC_Bigint_init_bigint(dest, op1); + return; + } + if (op1->is_negative || op2->is_negative) { + size_t big_bit_count = LC_size_max(LC_Bigint_bits_needed(op1), LC_Bigint_bits_needed(op2)); + + LC_BigInt twos_comp_op1 = {0}; + LC_to_twos_complement(&twos_comp_op1, op1, big_bit_count); + + LC_BigInt twos_comp_op2 = {0}; + LC_to_twos_complement(&twos_comp_op2, op2, big_bit_count); + + LC_BigInt twos_comp_dest = {0}; + LC_Bigint_xor(&twos_comp_dest, &twos_comp_op1, &twos_comp_op2); + + LC_from_twos_complement(dest, &twos_comp_dest, big_bit_count, true); + } else { + dest->is_negative = false; + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + + LC_ASSERT(NULL, op1->digit_count > 0 && op2->digit_count > 0); + if (op1->digit_count == 1 && op2->digit_count == 1) { + dest->digit_count = 1; + dest->digit = op1_digits[0] ^ op2_digits[0]; + LC_normalize(dest); + return; + } + dest->digit_count = LC_unsigned_max(op1->digit_count, op2->digit_count); + dest->digits = ALLOC_DIGITS(dest->digit_count); + size_t i = 0; + for (; i < op1->digit_count && i < op2->digit_count; i += 1) { + dest->digits[i] = op1_digits[i] ^ op2_digits[i]; + } + for (; i < dest->digit_count; i += 1) { + if (i < op1->digit_count) { + dest->digits[i] = op1_digits[i]; + } else if (i < op2->digit_count) { + dest->digits[i] = op2_digits[i]; + } else { + LC_ASSERT(NULL, !"Unreachable"); + } + } + LC_normalize(dest); + } +} + +LC_FUNCTION void LC_Bigint_shl(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + LC_ASSERT(NULL, !op2->is_negative); + + if (op2->digit_count == 0) { + return; + } + if (op2->digit_count != 1) { + LC_ASSERT(NULL, !"Unsupported: shift left by amount greater than 64 bit integer"); + } + LC_Bigint_shl_int(dest, op1, LC_Bigint_as_unsigned(op2)); +} + +LC_FUNCTION void LC_Bigint_shl_int(LC_BigInt *dest, LC_BigInt *op1, uint64_t shift) { + if (shift == 0) { + LC_Bigint_init_bigint(dest, op1); + return; + } + + if (op1->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + uint64_t *op1_digits = LC_Bigint_ptr(op1); + + if (op1->digit_count == 1 && shift < 64) { + dest->digit = op1_digits[0] << shift; + if (dest->digit > op1_digits[0]) { + dest->digit_count = 1; + dest->is_negative = op1->is_negative; + return; + } + } + + uint64_t digit_shift_count = shift / 64; + uint64_t leftover_shift_count = shift % 64; + + dest->digits = ALLOC_DIGITS(op1->digit_count + digit_shift_count + 1); + dest->digit_count = (unsigned)digit_shift_count; + uint64_t carry = 0; + for (size_t i = 0; i < op1->digit_count; i += 1) { + uint64_t digit = op1_digits[i]; + dest->digits[dest->digit_count] = carry | (digit << leftover_shift_count); + dest->digit_count++; + if (leftover_shift_count > 0) { + carry = digit >> (64 - leftover_shift_count); + } else { + carry = 0; + } + } + dest->digits[dest->digit_count] = carry; + dest->digit_count += 1; + dest->is_negative = op1->is_negative; + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_shl_trunc(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2, size_t bit_count, bool is_signed) { + LC_BigInt unwrapped = {0}; + LC_Bigint_shl(&unwrapped, op1, op2); + LC_Bigint_truncate(dest, &unwrapped, bit_count, is_signed); +} + +LC_FUNCTION void LC_Bigint_shr(LC_BigInt *dest, LC_BigInt *op1, LC_BigInt *op2) { + LC_ASSERT(NULL, !op2->is_negative); + + if (op1->digit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + if (op2->digit_count == 0) { + LC_Bigint_init_bigint(dest, op1); + return; + } + + if (op2->digit_count != 1) { + LC_ASSERT(NULL, !"Unsupported: shift right by amount greater than 64 bit integer"); + } + + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t shift_amt = LC_Bigint_as_unsigned(op2); + + if (op1->digit_count == 1) { + dest->digit = shift_amt < 64 ? op1_digits[0] >> shift_amt : 0; + dest->digit_count = 1; + dest->is_negative = op1->is_negative; + LC_normalize(dest); + return; + } + + uint64_t digit_shift_count = shift_amt / 64; + uint64_t leftover_shift_count = shift_amt % 64; + + if (digit_shift_count >= op1->digit_count) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + dest->digit_count = (unsigned)(op1->digit_count - digit_shift_count); + uint64_t *digits; + if (dest->digit_count == 1) { + digits = &dest->digit; + } else { + digits = ALLOC_DIGITS(dest->digit_count); + dest->digits = digits; + } + + uint64_t carry = 0; + for (size_t op_digit_index = op1->digit_count - 1;;) { + uint64_t digit = op1_digits[op_digit_index]; + size_t dest_digit_index = op_digit_index - digit_shift_count; + digits[dest_digit_index] = carry | (digit >> leftover_shift_count); + carry = digit << (64 - leftover_shift_count); + + if (dest_digit_index == 0) break; + op_digit_index -= 1; + } + dest->is_negative = op1->is_negative; + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_not(LC_BigInt *dest, LC_BigInt *op, size_t bit_count, bool is_signed) { + if (bit_count == 0) { + LC_Bigint_init_unsigned(dest, 0); + return; + } + + if (is_signed) { + LC_BigInt twos_comp = {0}; + LC_to_twos_complement(&twos_comp, op, bit_count); + + LC_BigInt inverted = {0}; + LC_Bigint_not(&inverted, &twos_comp, bit_count, false); + + LC_from_twos_complement(dest, &inverted, bit_count, true); + return; + } + + LC_ASSERT(NULL, !op->is_negative); + + dest->is_negative = false; + uint64_t *op_digits = LC_Bigint_ptr(op); + if (bit_count <= 64) { + dest->digit_count = 1; + if (op->digit_count == 0) { + if (bit_count == 64) { + dest->digit = UINT64_MAX; + } else { + dest->digit = (1ULL << bit_count) - 1; + } + } else if (op->digit_count == 1) { + dest->digit = ~op_digits[0]; + if (bit_count != 64) { + uint64_t + mask = (1ULL << bit_count) - 1; + dest->digit &= mask; + } + } + LC_normalize(dest); + return; + } + dest->digit_count = (unsigned int)((bit_count + 63) / 64); + LC_ASSERT(NULL, dest->digit_count >= op->digit_count); + dest->digits = ALLOC_DIGITS(dest->digit_count); + size_t i = 0; + for (; i < op->digit_count; i += 1) { + dest->digits[i] = ~op_digits[i]; + } + for (; i < dest->digit_count; i += 1) { + dest->digits[i] = 0xffffffffffffffffULL; + } + size_t digit_index = dest->digit_count - 1; + size_t digit_bit_index = bit_count % 64; + if (digit_bit_index != 0) { + uint64_t + mask = (1ULL << digit_bit_index) - 1; + dest->digits[digit_index] &= mask; + } + LC_normalize(dest); +} + +LC_FUNCTION void LC_Bigint_truncate(LC_BigInt *dst, LC_BigInt *op, size_t bit_count, bool is_signed) { + LC_BigInt twos_comp; + LC_to_twos_complement(&twos_comp, op, bit_count); + LC_from_twos_complement(dst, &twos_comp, bit_count, is_signed); +} + +LC_FUNCTION LC_CmpRes LC_Bigint_cmp(LC_BigInt *op1, LC_BigInt *op2) { + if (op1->is_negative && !op2->is_negative) return LC_CmpRes_LT; + if (!op1->is_negative && op2->is_negative) return LC_CmpRes_GT; + if (op1->digit_count > op2->digit_count) return op1->is_negative ? LC_CmpRes_LT : LC_CmpRes_GT; + if (op2->digit_count > op1->digit_count) return op1->is_negative ? LC_CmpRes_GT : LC_CmpRes_LT; + if (op1->digit_count == 0) return LC_CmpRes_EQ; + + uint64_t *op1_digits = LC_Bigint_ptr(op1); + uint64_t *op2_digits = LC_Bigint_ptr(op2); + for (unsigned i = op1->digit_count - 1;; i--) { + uint64_t op1_digit = op1_digits[i]; + uint64_t op2_digit = op2_digits[i]; + + if (op1_digit > op2_digit) { + return op1->is_negative ? LC_CmpRes_LT : LC_CmpRes_GT; + } + if (op1_digit < op2_digit) { + return op1->is_negative ? LC_CmpRes_GT : LC_CmpRes_LT; + } + if (i == 0) { + return LC_CmpRes_EQ; + } + } +} + +LC_FUNCTION char *LC_Bigint_str(LC_BigInt *bigint, uint64_t base) { + LC_StringList out = {0}; + if (bigint->digit_count == 0) { + return "0"; + } + if (bigint->is_negative) { + LC_Addf(L->arena, &out, "-"); + } + if (bigint->digit_count == 1 && base == 10) { + LC_Addf(L->arena, &out, "%llu", (unsigned long long)bigint->digit); + } else { + size_t len = bigint->digit_count * 64; + char *start = (char *)malloc_arena(len); + char *buf = start; + + LC_BigInt digit_bi = {0}; + LC_BigInt a1 = {0}; + LC_BigInt a2 = {0}; + LC_BigInt base_bi = {0}; + LC_BigInt *a = &a1; + LC_BigInt *other_a = &a2; + + LC_Bigint_init_bigint(a, bigint); + LC_Bigint_init_unsigned(&base_bi, base); + + for (;;) { + LC_Bigint_rem(&digit_bi, a, &base_bi); + uint8_t digit = (uint8_t)LC_Bigint_as_unsigned(&digit_bi); + *(buf++) = LC_digit_to_char(digit, false); + LC_Bigint_div_trunc(other_a, a, &base_bi); + { + LC_BigInt *tmp = a; + a = other_a; + other_a = tmp; + } + if (LC_Bigint_cmp_zero(a) == LC_CmpRes_EQ) { + break; + } + } + + // reverse + + for (char *ptr = buf - 1; ptr >= start; ptr--) { + LC_Addf(L->arena, &out, "%c", *ptr); + } + } + LC_String s = LC_MergeString(L->arena, out); + return s.str; +} + +LC_FUNCTION int64_t LC_Bigint_as_signed(LC_BigInt *bigint) { + if (bigint->digit_count == 0) return 0; + if (bigint->digit_count != 1) { + LC_ASSERT(NULL, !"LC_BigInt larger than i64"); + } + + if (bigint->is_negative) { + // TODO this code path is untested + if (bigint->digit <= 9223372036854775808ULL) { + return (-((int64_t)(bigint->digit - 1))) - 1; + } + LC_ASSERT(NULL, !"LC_BigInt does not fit in i64"); + } + return (int64_t)bigint->digit; +} + +LC_FUNCTION LC_CmpRes LC_Bigint_cmp_zero(LC_BigInt *op) { + if (op->digit_count == 0) { + return LC_CmpRes_EQ; + } + return op->is_negative ? LC_CmpRes_LT : LC_CmpRes_GT; +} + +LC_FUNCTION double LC_Bigint_as_float(LC_BigInt *bigint) { + if (LC_Bigint_fits_in_bits(bigint, 64, bigint->is_negative)) { + return bigint->is_negative ? (double)LC_Bigint_as_signed(bigint) : (double)LC_Bigint_as_unsigned(bigint); + } + LC_BigInt div; + uint64_t mult = 0x100000000000ULL; + double mul = 1; + LC_Bigint_init_unsigned(&div, mult); + LC_BigInt current; + LC_Bigint_init_bigint(¤t, bigint); + double f = 0; + do { + LC_BigInt temp; + LC_Bigint_mod(&temp, ¤t, &div); + f += LC_Bigint_as_signed(&temp) * mul; + mul *= mult; + LC_Bigint_div_trunc(&temp, ¤t, &div); + current = temp; + } while (current.digit_count > 0); + return f; +} +LC_Operand LC_OPNull; + +LC_FUNCTION LC_Operand LC_OPError(void) { + LC_Operand result = {LC_OPF_Error}; + return result; +} + +LC_FUNCTION LC_Operand LC_OPConstType(LC_Type *type) { + LC_Operand result = {LC_OPF_UTConst | LC_OPF_Const}; + result.type = type; + return result; +} + +LC_FUNCTION LC_Operand LC_OPDecl(LC_Decl *decl) { + LC_Operand result = {0}; + result.decl = decl; + return result; +} + +LC_FUNCTION LC_Operand LC_OPType(LC_Type *type) { + LC_Operand result = {0}; + result.type = type; + return result; +} + +LC_FUNCTION LC_Operand LC_OPLValueAndType(LC_Type *type) { + LC_Operand result = LC_OPType(type); + result.flags = LC_OPF_LValue; + return result; +} + +LC_FUNCTION LC_Operand LC_ReportASTError(LC_AST *n, const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + LC_SendErrorMessage(n ? n->pos : NULL, s8); + L->errors += 1; + return LC_OPError(); +} + +LC_FUNCTION LC_Operand LC_ReportASTErrorEx(LC_AST *n1, LC_AST *n2, const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + LC_SendErrorMessage(n1->pos, s8); + LC_SendErrorMessage(n2->pos, s8); + L->errors += 1; + return LC_OPError(); +} + +LC_FUNCTION LC_Operand LC_ConstCastFloat(LC_AST *pos, LC_Operand op) { + LC_ASSERT(pos, LC_IsUTConst(op)); + LC_ASSERT(pos, LC_IsUntyped(op.type)); + if (LC_IsUTInt(op.type)) op.val.d = LC_Bigint_as_float(&op.val.i); + if (LC_IsUTStr(op.type)) return LC_ReportASTError(pos, "Trying to convert '%s' to float", LC_GenLCType(op.type)); + op.type = L->tuntypedfloat; + return op; +} + +LC_FUNCTION LC_Operand LC_ConstCastInt(LC_AST *pos, LC_Operand op) { + LC_ASSERT(pos, LC_IsUTConst(op)); + LC_ASSERT(pos, LC_IsUntyped(op.type)); + if (LC_IsUTFloat(op.type)) { + double v = op.val.d; // add rounding? + LC_Bigint_init_signed(&op.val.i, (int64_t)v); + } + if (LC_IsUTStr(op.type)) return LC_ReportASTError(pos, "Trying to convert %s to int", LC_GenLCType(op.type)); + op.type = L->tuntypedint; + return op; +} + +LC_FUNCTION LC_Operand LC_OPInt(int64_t v) { + LC_Operand op = {0}; + op.type = L->tuntypedint; + op.flags |= LC_OPF_UTConst | LC_OPF_Const; + LC_Bigint_init_signed(&op.v.i, v); + return op; +} + +LC_FUNCTION LC_Operand LC_OPIntT(LC_Type *type, int64_t v) { + LC_ASSERT(NULL, LC_IsInt(type)); + LC_Operand op = LC_OPInt(v); + op.type = type; + return op; +} + +LC_FUNCTION LC_Operand LC_OPModDefaultUT(LC_Operand val) { + if (LC_IsUntyped(val.type)) { + val.type = val.type->tbase; + } + return val; +} + +LC_FUNCTION LC_Operand LC_OPModType(LC_Operand op, LC_Type *type) { + if (LC_IsUTConst(op)) { + if (LC_IsUTInt(op.type) && LC_IsFloat(type)) { + op = LC_ConstCastFloat(NULL, op); + } + } + op.type = type; + return op; +} + +LC_FUNCTION LC_Operand LC_OPModBool(LC_Operand op) { + op.type = L->tuntypedbool; + return op; +} + +LC_FUNCTION LC_Operand LC_OPModBoolV(LC_Operand op, int v) { + op.type = L->tuntypedbool; + LC_Bigint_init_signed(&op.v.i, v); + return op; +} + +LC_FUNCTION LC_Operand LC_EvalBinary(LC_AST *pos, LC_Operand a, LC_TokenKind op, LC_Operand b) { + LC_ASSERT(pos, LC_IsUTConst(a)); + LC_ASSERT(pos, LC_IsUTConst(b)); + LC_ASSERT(pos, LC_IsUntyped(a.type)); + LC_ASSERT(pos, LC_IsUntyped(b.type)); + LC_ASSERT(pos, a.type->kind == b.type->kind); + + LC_Operand c = LC_OPConstType(a.type); + if (LC_IsUTStr(a.type)) { + return LC_ReportASTError(pos, "invalid operand %s for binary expr of type untyped string", LC_TokenKindToString(op)); + } + if (LC_IsUTFloat(a.type)) { + switch (op) { + case LC_TokenKind_Add: c.v.d = a.v.d + b.v.d; break; + case LC_TokenKind_Sub: c.v.d = a.v.d - b.v.d; break; + case LC_TokenKind_Mul: c.v.d = a.v.d * b.v.d; break; + case LC_TokenKind_Div: { + if (b.v.d == 0.0) return LC_ReportASTError(pos, "division by 0"); + c.v.d = a.v.d / b.v.d; + } break; + case LC_TokenKind_LesserThenEq: c = LC_OPModBoolV(c, a.v.d <= b.v.d); break; + case LC_TokenKind_GreaterThenEq: c = LC_OPModBoolV(c, a.v.d >= b.v.d); break; + case LC_TokenKind_GreaterThen: c = LC_OPModBoolV(c, a.v.d > b.v.d); break; + case LC_TokenKind_LesserThen: c = LC_OPModBoolV(c, a.v.d < b.v.d); break; + case LC_TokenKind_Equals: c = LC_OPModBoolV(c, a.v.d == b.v.d); break; + case LC_TokenKind_NotEquals: c = LC_OPModBoolV(c, a.v.d != b.v.d); break; + default: return LC_ReportASTError(pos, "invalid operand %s for binary expr of type untyped float", LC_TokenKindToString(op)); + } + } + if (LC_IsUTInt(a.type)) { + switch (op) { + case LC_TokenKind_BitXor: LC_Bigint_xor(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_BitAnd: LC_Bigint_and(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_BitOr: LC_Bigint_or(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_Add: LC_Bigint_add(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_Sub: LC_Bigint_sub(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_Mul: LC_Bigint_mul(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_Div: { + if (b.v.i.digit_count == 0) return LC_ReportASTError(pos, "division by zero in constant expression"); + LC_Bigint_div_floor(&c.v.i, &a.v.i, &b.v.i); + } break; + case LC_TokenKind_Mod: { + if (b.v.i.digit_count == 0) return LC_ReportASTError(pos, "modulo by zero in constant expression"); + LC_Bigint_mod(&c.v.i, &a.v.i, &b.v.i); + } break; + case LC_TokenKind_LeftShift: LC_Bigint_shl(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_RightShift: LC_Bigint_shr(&c.v.i, &a.v.i, &b.v.i); break; + case LC_TokenKind_And: { + int left = LC_Bigint_cmp_zero(&a.v.i) != LC_CmpRes_EQ; + int right = LC_Bigint_cmp_zero(&b.v.i) != LC_CmpRes_EQ; + c = LC_OPModBoolV(c, left && right); + } break; + case LC_TokenKind_Or: { + int left = LC_Bigint_cmp_zero(&a.v.i) != LC_CmpRes_EQ; + int right = LC_Bigint_cmp_zero(&b.v.i) != LC_CmpRes_EQ; + c = LC_OPModBoolV(c, left || right); + } break; + default: { + LC_CmpRes cmp = LC_Bigint_cmp(&a.v.i, &b.v.i); + switch (op) { + case LC_TokenKind_LesserThenEq: c = LC_OPModBoolV(c, (cmp == LC_CmpRes_LT) || (cmp == LC_CmpRes_EQ)); break; + case LC_TokenKind_GreaterThenEq: c = LC_OPModBoolV(c, (cmp == LC_CmpRes_GT) || (cmp == LC_CmpRes_EQ)); break; + case LC_TokenKind_GreaterThen: c = LC_OPModBoolV(c, cmp == LC_CmpRes_GT); break; + case LC_TokenKind_LesserThen: c = LC_OPModBoolV(c, cmp == LC_CmpRes_LT); break; + case LC_TokenKind_Equals: c = LC_OPModBoolV(c, cmp == LC_CmpRes_EQ); break; + case LC_TokenKind_NotEquals: c = LC_OPModBoolV(c, cmp != LC_CmpRes_EQ); break; + default: return LC_ReportASTError(pos, "invalid operand %s for binary expr of type untyped int", LC_TokenKindToString(op)); + } + } + } + } + + return c; +} + +LC_FUNCTION LC_Operand LC_EvalUnary(LC_AST *pos, LC_TokenKind op, LC_Operand a) { + LC_ASSERT(pos, LC_IsUTConst(a)); + LC_ASSERT(pos, LC_IsUntyped(a.type)); + LC_Operand c = a; + + if (LC_IsUTStr(a.type)) { + return LC_ReportASTError(pos, "invalid operand %s for unary expr of type untyped string", LC_TokenKindToString(op)); + } + if (LC_IsUTFloat(a.type)) { + switch (op) { + case LC_TokenKind_Sub: c.v.d = -a.v.d; break; + case LC_TokenKind_Add: c.v.d = +a.v.d; break; + default: return LC_ReportASTError(pos, "invalid operand %s for unary expr of type untyped float", LC_TokenKindToString(op)); + } + } + if (LC_IsUTInt(a.type)) { + switch (op) { + case LC_TokenKind_Not: c = LC_OPModBoolV(c, LC_Bigint_cmp_zero(&a.v.i) == LC_CmpRes_EQ); break; + case LC_TokenKind_Sub: LC_Bigint_negate(&c.v.i, &a.v.i); break; + case LC_TokenKind_Add: c = a; break; + case LC_TokenKind_Neg: LC_Bigint_not(&c.v.i, &a.v.i, a.type->tbase->size * 8, !a.type->tbase->is_unsigned); break; + default: return LC_ReportASTError(pos, "invalid operand %s for unary expr of type untyped int", LC_TokenKindToString(op)); + } + } + + return c; +} + +LC_FUNCTION bool LC_BigIntFits(LC_BigInt i, LC_Type *type) { + LC_ASSERT(NULL, LC_IsInt(type)); + if (!LC_Bigint_fits_in_bits(&i, type->size * 8, !type->is_unsigned)) { + return false; + } + return true; +} + +LC_FUNCTION LC_OPResult LC_IsBinaryExprValidForType(LC_TokenKind op, LC_Type *type) { + if (LC_IsFloat(type)) { + switch (op) { + case LC_TokenKind_Add: return LC_OPResult_Ok; break; + case LC_TokenKind_Sub: return LC_OPResult_Ok; break; + case LC_TokenKind_Mul: return LC_OPResult_Ok; break; + case LC_TokenKind_Div: return LC_OPResult_Ok; break; + case LC_TokenKind_LesserThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThen: return LC_OPResult_Bool; break; + case LC_TokenKind_LesserThen: return LC_OPResult_Bool; break; + case LC_TokenKind_Equals: return LC_OPResult_Bool; break; + case LC_TokenKind_NotEquals: return LC_OPResult_Bool; break; + default: return LC_OPResult_Error; + } + } + if (LC_IsInt(type)) { + switch (op) { + case LC_TokenKind_BitXor: return LC_OPResult_Ok; break; + case LC_TokenKind_BitAnd: return LC_OPResult_Ok; break; + case LC_TokenKind_BitOr: return LC_OPResult_Ok; break; + case LC_TokenKind_Add: return LC_OPResult_Ok; break; + case LC_TokenKind_Sub: return LC_OPResult_Ok; break; + case LC_TokenKind_Mul: return LC_OPResult_Ok; break; + case LC_TokenKind_Div: return LC_OPResult_Ok; break; + case LC_TokenKind_Mod: return LC_OPResult_Ok; break; + case LC_TokenKind_LeftShift: return LC_OPResult_Ok; break; + case LC_TokenKind_RightShift: return LC_OPResult_Ok; break; + case LC_TokenKind_And: return LC_OPResult_Bool; break; + case LC_TokenKind_Or: return LC_OPResult_Bool; break; + case LC_TokenKind_LesserThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThen: return LC_OPResult_Bool; break; + case LC_TokenKind_LesserThen: return LC_OPResult_Bool; break; + case LC_TokenKind_Equals: return LC_OPResult_Bool; break; + case LC_TokenKind_NotEquals: return LC_OPResult_Bool; break; + default: return LC_OPResult_Error; + } + } + if (LC_IsPtrLike(type)) { + switch (op) { + case LC_TokenKind_And: return LC_OPResult_Bool; break; + case LC_TokenKind_Or: return LC_OPResult_Bool; break; + case LC_TokenKind_LesserThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThenEq: return LC_OPResult_Bool; break; + case LC_TokenKind_GreaterThen: return LC_OPResult_Bool; break; + case LC_TokenKind_LesserThen: return LC_OPResult_Bool; break; + case LC_TokenKind_Equals: return LC_OPResult_Bool; break; + case LC_TokenKind_NotEquals: return LC_OPResult_Bool; break; + default: return LC_OPResult_Error; + } + } + + return LC_OPResult_Error; +} + +LC_FUNCTION LC_OPResult LC_IsUnaryOpValidForType(LC_TokenKind op, LC_Type *type) { + if (LC_IsFloat(type)) { + if (op == LC_TokenKind_Sub) return LC_OPResult_Ok; + if (op == LC_TokenKind_Add) return LC_OPResult_Ok; + } + if (LC_IsInt(type)) { + if (op == LC_TokenKind_Not) return LC_OPResult_Bool; + if (op == LC_TokenKind_Sub) return LC_OPResult_Ok; + if (op == LC_TokenKind_Add) return LC_OPResult_Ok; + if (op == LC_TokenKind_Neg) return LC_OPResult_Ok; + } + if (LC_IsPtrLike(type)) { + if (op == LC_TokenKind_Not) return LC_OPResult_Bool; + } + return LC_OPResult_Error; +} + +LC_FUNCTION LC_OPResult LC_IsAssignValidForType(LC_TokenKind op, LC_Type *type) { + if (op == LC_TokenKind_Assign) return LC_OPResult_Ok; + if (LC_IsInt(type)) { + switch (op) { + case LC_TokenKind_DivAssign: return LC_OPResult_Ok; + case LC_TokenKind_MulAssign: return LC_OPResult_Ok; + case LC_TokenKind_ModAssign: return LC_OPResult_Ok; + case LC_TokenKind_SubAssign: return LC_OPResult_Ok; + case LC_TokenKind_AddAssign: return LC_OPResult_Ok; + case LC_TokenKind_BitAndAssign: return LC_OPResult_Ok; + case LC_TokenKind_BitOrAssign: return LC_OPResult_Ok; + case LC_TokenKind_BitXorAssign: return LC_OPResult_Ok; + case LC_TokenKind_LeftShiftAssign: return LC_OPResult_Ok; + case LC_TokenKind_RightShiftAssign: return LC_OPResult_Ok; + default: return LC_OPResult_Error; + } + } + if (LC_IsFloat(type)) { + switch (op) { + case LC_TokenKind_DivAssign: return LC_OPResult_Ok; + case LC_TokenKind_MulAssign: return LC_OPResult_Ok; + case LC_TokenKind_SubAssign: return LC_OPResult_Ok; + case LC_TokenKind_AddAssign: return LC_OPResult_Ok; + default: return LC_OPResult_Error; + } + } + return LC_OPResult_Error; +} + +LC_FUNCTION int LC_GetLevelsOfIndirection(LC_Type *type) { + if (type->kind == LC_TypeKind_Pointer) return LC_GetLevelsOfIndirection(type->tbase) + 1; + if (type->kind == LC_TypeKind_Array) return LC_GetLevelsOfIndirection(type->tbase) + 1; + return 0; +} + +LC_FUNCTION LC_AST *LC_CreateAST(LC_Token *pos, LC_ASTKind kind) { + LC_AST *n = LC_PushStruct(L->ast_arena, LC_AST); + n->id = ++L->ast_count; + n->kind = kind; + n->pos = pos; + if (L->parser == &L->quick_parser) n->pos = &L->BuiltinToken; + return n; +} + +LC_FUNCTION LC_AST *LC_CreateUnary(LC_Token *pos, LC_TokenKind op, LC_AST *expr) { + LC_AST *r = LC_CreateAST(pos, LC_ASTKind_ExprUnary); + r->eunary.op = op; + r->eunary.expr = expr; + return r; +} + +LC_FUNCTION LC_AST *LC_CreateBinary(LC_Token *pos, LC_AST *left, LC_AST *right, LC_TokenKind op) { + LC_AST *r = LC_CreateAST(pos, LC_ASTKind_ExprBinary); + r->ebinary.op = op; + r->ebinary.left = left; + r->ebinary.right = right; + return r; +} + +LC_FUNCTION LC_AST *LC_CreateIndex(LC_Token *pos, LC_AST *left, LC_AST *index) { + LC_AST *r = LC_CreateAST(pos, LC_ASTKind_ExprIndex); + r->eindex.index = index; + r->eindex.base = left; + return r; +} + +LC_FUNCTION void LC_SetPointerSizeAndAlign(int size, int align) { + L->pointer_align = align; + L->pointer_size = size; + if (L->tpvoid) { + L->tpvoid->size = size; + L->tpvoid->align = align; + } + if (L->tpchar) { + L->tpchar->size = size; + L->tpchar->align = align; + } +} + +LC_FUNCTION LC_Type *LC_CreateType(LC_TypeKind kind) { + LC_Type *r = LC_PushStruct(L->type_arena, LC_Type); + L->type_count += 1; + r->kind = kind; + r->id = ++L->typeids; + if (r->kind == LC_TypeKind_Proc || r->kind == LC_TypeKind_Pointer) { + r->size = L->pointer_size; + r->align = L->pointer_align; + r->is_unsigned = true; + } + return r; +} + +LC_FUNCTION LC_Type *LC_CreateTypedef(LC_Decl *decl, LC_Type *base) { + LC_Type *n = LC_CreateType(base->kind); + *n = *base; + decl->typedef_renamed_type_decl = base->decl; + n->decl = decl; + return n; +} + +LC_FUNCTION LC_Type *LC_CreatePointerType(LC_Type *type) { + uint64_t key = (uint64_t)type; + LC_Type *entry = (LC_Type *)LC_MapGetU64(&L->type_map, key); + if (entry) { + return entry; + } + LC_Type *n = LC_CreateType(LC_TypeKind_Pointer); + n->tbase = type; + LC_MapInsertU64(&L->type_map, key, n); + return n; +} + +LC_FUNCTION LC_Type *LC_CreateArrayType(LC_Type *type, int size) { + uint64_t size_key = LC_HashBytes(&size, sizeof(size)); + uint64_t type_key = LC_HashBytes(type, sizeof(*type)); + uint64_t key = LC_HashMix(size_key, type_key); + LC_Type *entry = (LC_Type *)LC_MapGetU64(&L->type_map, key); + if (entry) { + return entry; + } + LC_Type *n = LC_CreateType(LC_TypeKind_Array); + n->tbase = type; + n->tarray.size = size; + n->size = type->size * size; + n->align = type->align; + LC_MapInsertU64(&L->type_map, key, n); + return n; +} + +LC_FUNCTION LC_Type *LC_CreateProcType(LC_TypeMemberList args, LC_Type *ret, bool has_vargs, bool has_vargs_any_promotion) { + LC_ASSERT(NULL, ret); + uint64_t key = LC_HashBytes(ret, sizeof(*ret)); + key = LC_HashMix(key, LC_HashBytes(&has_vargs, sizeof(has_vargs))); + key = LC_HashMix(key, LC_HashBytes(&has_vargs_any_promotion, sizeof(has_vargs_any_promotion))); + int procarg_count = 0; + LC_TypeFor(it, args.first) { + key = LC_HashMix(LC_HashBytes(it->type, sizeof(it->type[0])), key); + key = LC_HashMix(LC_HashBytes((char *)it->name, LC_StrLen((char *)it->name)), key); + if (it->default_value_expr) { + key = LC_HashMix(LC_HashBytes(&it->default_value_expr, sizeof(LC_AST *)), key); + } + procarg_count += 1; + } + LC_Type *n = (LC_Type *)LC_MapGetU64(&L->type_map, key); + if (n) return n; + + n = LC_CreateType(LC_TypeKind_Proc); + n->tproc.args = args; + n->tproc.vargs = has_vargs; + n->tproc.vargs_any_promotion = has_vargs_any_promotion; + n->tproc.ret = ret; + LC_MapInsertU64(&L->type_map, key, n); + return n; +} + +LC_FUNCTION LC_Type *LC_CreateIncompleteType(LC_Decl *decl) { + LC_Type *n = LC_CreateType(LC_TypeKind_Incomplete); + n->decl = decl; + return n; +} + +LC_FUNCTION LC_Type *LC_CreateUntypedIntEx(LC_Type *base, LC_Decl *decl) { + uint64_t hash_base = LC_HashBytes(base, sizeof(*base)); + uint64_t untyped_int = LC_TypeKind_UntypedInt; + uint64_t key = LC_HashMix(hash_base, untyped_int); + LC_Type *n = (LC_Type *)LC_MapGetU64(&L->type_map, key); + if (n) return n; + + n = LC_CreateType(LC_TypeKind_UntypedInt); + n->tbase = base; + n->decl = decl; + return n; +} + +LC_FUNCTION LC_Type *LC_CreateUntypedInt(LC_Type *base) { + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Type, LC_ILit("UntypedInt"), &L->NullAST); + LC_Type *n = LC_CreateUntypedIntEx(base, decl); + return n; +} + +LC_FUNCTION LC_TypeMember *LC_AddTypeToList(LC_TypeMemberList *list, LC_Intern name, LC_Type *type, LC_AST *ast) { + LC_TypeFor(it, list->first) { + if (name == it->name) { + return NULL; + } + } + + LC_TypeMember *r = LC_PushStruct(L->arena, LC_TypeMember); + r->name = name; + r->type = type; + r->ast = ast; + LC_DLLAdd(list->first, list->last, r); + list->count += 1; + return r; +} + +LC_FUNCTION LC_Type *LC_StripPointer(LC_Type *type) { + if (type->kind == LC_TypeKind_Pointer) { + return type->tbase; + } + return type; +} + +LC_FUNCTION void LC_ReserveAST(LC_ASTArray *stack, int size) { + if (size > stack->cap) { + LC_AST **new_stack = LC_PushArray(stack->arena, LC_AST *, size); + + LC_MemoryCopy(new_stack, stack->data, stack->len * sizeof(LC_AST *)); + stack->data = new_stack; + stack->cap = size; + } +} + +LC_FUNCTION void LC_PushAST(LC_ASTArray *stack, LC_AST *ast) { + LC_ASSERT(NULL, stack->len <= stack->cap); + LC_ASSERT(NULL, stack->arena); + if (stack->len == stack->cap) { + int new_cap = stack->cap < 16 ? 16 : stack->cap * 2; + LC_AST **new_stack = LC_PushArray(stack->arena, LC_AST *, new_cap); + + LC_MemoryCopy(new_stack, stack->data, stack->len * sizeof(LC_AST *)); + stack->data = new_stack; + stack->cap = new_cap; + } + stack->data[stack->len++] = ast; +} + +LC_FUNCTION void LC_PopAST(LC_ASTArray *stack) { + LC_ASSERT(NULL, stack->arena); + LC_ASSERT(NULL, stack->len > 0); + stack->len -= 1; +} + +LC_FUNCTION LC_AST *LC_GetLastAST(LC_ASTArray *arr) { + LC_ASSERT(NULL, arr->len > 0); + LC_AST *result = arr->data[arr->len - 1]; + return result; +} + +LC_FUNCTION void LC_WalkAST(LC_ASTWalker *ctx, LC_AST *n) { + if (!ctx->depth_first) { + ctx->proc(ctx, n); + } + + if (ctx->dont_recurse) { + ctx->dont_recurse = false; + return; + } + + LC_PushAST(&ctx->stack, n); + switch (n->kind) { + case LC_ASTKind_TypespecIdent: + case LC_ASTKind_ExprIdent: + case LC_ASTKind_ExprString: + case LC_ASTKind_ExprInt: + case LC_ASTKind_ExprFloat: + case LC_ASTKind_GlobImport: + case LC_ASTKind_ExprBool: + case LC_ASTKind_StmtBreak: + case LC_ASTKind_StmtContinue: break; + + case LC_ASTKind_Package: { + LC_ASTFor(it, n->apackage.ffile) LC_WalkAST(ctx, it); + + ctx->inside_discarded += 1; + if (ctx->visit_discarded) LC_ASTFor(it, n->apackage.fdiscarded) LC_WalkAST(ctx, it); + ctx->inside_discarded -= 1; + } break; + + case LC_ASTKind_File: { + LC_ASTFor(it, n->afile.fimport) LC_WalkAST(ctx, it); + LC_ASTFor(it, n->afile.fdecl) { + if (ctx->visit_notes == false && it->kind == LC_ASTKind_DeclNote) continue; + LC_WalkAST(ctx, it); + } + + ctx->inside_discarded += 1; + if (ctx->visit_discarded) LC_ASTFor(it, n->afile.fdiscarded) LC_WalkAST(ctx, it); + ctx->inside_discarded -= 1; + } break; + + case LC_ASTKind_DeclProc: { + LC_WalkAST(ctx, n->dproc.type); + if (n->dproc.body) LC_WalkAST(ctx, n->dproc.body); + } break; + case LC_ASTKind_NoteList: { + if (ctx->visit_notes) LC_ASTFor(it, n->anote_list.first) LC_WalkAST(ctx, it); + } break; + case LC_ASTKind_TypespecProcArg: { + LC_WalkAST(ctx, n->tproc_arg.type); + if (n->tproc_arg.expr) LC_WalkAST(ctx, n->tproc_arg.expr); + } break; + case LC_ASTKind_TypespecAggMem: { + LC_WalkAST(ctx, n->tproc_arg.type); + } break; + + case LC_ASTKind_ExprNote: { + ctx->inside_note += 1; + if (ctx->visit_notes) LC_WalkAST(ctx, n->enote.expr); + ctx->inside_note -= 1; + } break; + + case LC_ASTKind_StmtSwitch: { + LC_WalkAST(ctx, n->sswitch.expr); + LC_ASTFor(it, n->sswitch.first) LC_WalkAST(ctx, it); + } break; + + case LC_ASTKind_StmtSwitchCase: { + LC_ASTFor(it, n->scase.first) LC_WalkAST(ctx, it); + LC_WalkAST(ctx, n->scase.body); + } break; + case LC_ASTKind_StmtSwitchDefault: { + LC_ASTFor(it, n->scase.first) LC_WalkAST(ctx, it); + LC_WalkAST(ctx, n->scase.body); + } break; + + case LC_ASTKind_StmtIf: { + LC_WalkAST(ctx, n->sif.expr); + LC_WalkAST(ctx, n->sif.body); + LC_ASTFor(it, n->sif.first) LC_WalkAST(ctx, it); + } break; + case LC_ASTKind_StmtElse: + case LC_ASTKind_StmtElseIf: { + if (n->sif.expr) LC_WalkAST(ctx, n->sif.expr); + LC_WalkAST(ctx, n->sif.body); + } break; + + case LC_ASTKind_DeclNote: { + ctx->inside_note += 1; + if (ctx->visit_notes) LC_WalkAST(ctx, n->dnote.expr); + ctx->inside_note -= 1; + } break; + case LC_ASTKind_DeclUnion: + case LC_ASTKind_DeclStruct: { + LC_ASTFor(it, n->dagg.first) LC_WalkAST(ctx, it); + } break; + + case LC_ASTKind_DeclVar: { + if (n->dvar.type) LC_WalkAST(ctx, n->dvar.type); + if (n->dvar.expr) LC_WalkAST(ctx, n->dvar.expr); + } break; + case LC_ASTKind_DeclConst: { + if (n->dconst.expr) LC_WalkAST(ctx, n->dconst.expr); + } break; + case LC_ASTKind_DeclTypedef: { + LC_WalkAST(ctx, n->dtypedef.type); + } break; + case LC_ASTKind_TypespecField: { + LC_WalkAST(ctx, n->efield.left); + } break; + + case LC_ASTKind_TypespecPointer: { + LC_WalkAST(ctx, n->tpointer.base); + } break; + case LC_ASTKind_TypespecArray: { + LC_WalkAST(ctx, n->tarray.base); + if (n->tarray.index) LC_WalkAST(ctx, n->tarray.index); + } break; + case LC_ASTKind_TypespecProc: { + LC_ASTFor(it, n->tproc.first) LC_WalkAST(ctx, it); + if (n->tproc.ret) LC_WalkAST(ctx, n->tproc.ret); + } break; + case LC_ASTKind_StmtBlock: { + LC_ASTFor(it, n->sblock.first) LC_WalkAST(ctx, it); + // hmm should we inline defers or maybe remove them from + // the stmt list? + // LC_ASTFor(it, n->sblock.first_defer) LC_WalkAST(ctx, it); + } break; + + case LC_ASTKind_StmtNote: { + ctx->inside_note += 1; + if (ctx->visit_notes) LC_WalkAST(ctx, n->snote.expr); + ctx->inside_note -= 1; + } break; + case LC_ASTKind_StmtReturn: { + if (n->sreturn.expr) LC_WalkAST(ctx, n->sreturn.expr); + } break; + + case LC_ASTKind_StmtDefer: { + LC_WalkAST(ctx, n->sdefer.body); + } break; + case LC_ASTKind_StmtFor: { + if (n->sfor.init) LC_WalkAST(ctx, n->sfor.init); + if (n->sfor.cond) LC_WalkAST(ctx, n->sfor.cond); + if (n->sfor.inc) LC_WalkAST(ctx, n->sfor.inc); + LC_WalkAST(ctx, n->sfor.body); + } break; + + case LC_ASTKind_StmtAssign: { + LC_WalkAST(ctx, n->sassign.left); + LC_WalkAST(ctx, n->sassign.right); + } break; + case LC_ASTKind_StmtExpr: { + LC_WalkAST(ctx, n->sexpr.expr); + } break; + case LC_ASTKind_StmtVar: { + if (n->svar.type) LC_WalkAST(ctx, n->svar.type); + if (n->svar.expr) LC_WalkAST(ctx, n->svar.expr); + } break; + case LC_ASTKind_StmtConst: { + LC_WalkAST(ctx, n->sconst.expr); + } break; + + case LC_ASTKind_ExprType: { + LC_WalkAST(ctx, n->etype.type); + } break; + case LC_ASTKind_ExprAddPtr: + case LC_ASTKind_ExprBinary: { + LC_WalkAST(ctx, n->ebinary.left); + LC_WalkAST(ctx, n->ebinary.right); + } break; + case LC_ASTKind_ExprGetPointerOfValue: + case LC_ASTKind_ExprGetValueOfPointer: + case LC_ASTKind_ExprUnary: { + LC_WalkAST(ctx, n->eunary.expr); + } break; + case LC_ASTKind_ExprCompoundItem: + case LC_ASTKind_ExprCallItem: { + if (n->ecompo_item.index) LC_WalkAST(ctx, n->ecompo_item.index); + LC_WalkAST(ctx, n->ecompo_item.expr); + } break; + case LC_ASTKind_Note: { + ctx->inside_note += 1; + if (n->ecompo.name) LC_WalkAST(ctx, n->ecompo.name); + LC_ASTFor(it, n->ecompo.first) LC_WalkAST(ctx, it); + ctx->inside_note -= 1; + } break; + case LC_ASTKind_ExprBuiltin: { + ctx->inside_builtin += 1; + if (n->ecompo.name) LC_WalkAST(ctx, n->ecompo.name); + LC_ASTFor(it, n->ecompo.first) LC_WalkAST(ctx, it); + ctx->inside_builtin -= 1; + } break; + case LC_ASTKind_ExprCall: + case LC_ASTKind_ExprCompound: { + if (n->ecompo.name) LC_WalkAST(ctx, n->ecompo.name); + LC_ASTFor(it, n->ecompo.first) LC_WalkAST(ctx, it); + } break; + case LC_ASTKind_ExprCast: { + LC_WalkAST(ctx, n->ecast.type); + LC_WalkAST(ctx, n->ecast.expr); + } break; + case LC_ASTKind_ExprField: { + LC_WalkAST(ctx, n->efield.left); + } break; + case LC_ASTKind_ExprIndex: { + LC_WalkAST(ctx, n->eindex.index); + LC_WalkAST(ctx, n->eindex.base); + } break; + + case LC_ASTKind_Ignore: + case LC_ASTKind_Error: + default: LC_ReportASTError(n, "internal compiler error: got invalid ast kind during ast walk: %s", LC_ASTKindToString(n->kind)); + } + + if (ctx->visit_notes && n->notes) { + LC_WalkAST(ctx, n->notes); + } + LC_PopAST(&ctx->stack); + + if (ctx->depth_first) { + ctx->proc(ctx, n); + } +} + +LC_FUNCTION LC_ASTWalker LC_GetDefaultWalker(LC_Arena *arena, LC_ASTWalkProc *proc) { + LC_ASTWalker result = {0}; + result.stack.arena = arena; + result.proc = proc; + result.depth_first = true; + return result; +} + +LC_FUNCTION void WalkAndFlattenAST(LC_ASTWalker *ctx, LC_AST *n) { + LC_ASTArray *array = (LC_ASTArray *)ctx->user_data; + LC_PushAST(array, n); +} + +LC_FUNCTION LC_ASTArray LC_FlattenAST(LC_Arena *arena, LC_AST *n) { + LC_ASTArray array = {arena}; + LC_ASTWalker walker = LC_GetDefaultWalker(arena, WalkAndFlattenAST); + walker.user_data = (void *)&array; + LC_WalkAST(&walker, n); + return array; +} + +LC_FUNCTION void WalkToFindSizeofLike(LC_ASTWalker *w, LC_AST *n) { + if (n->kind == LC_ASTKind_ExprBuiltin) { + LC_ASSERT(n, n->ecompo.name->kind == LC_ASTKind_ExprIdent); + if (n->ecompo.name->eident.name == L->isizeof || n->ecompo.name->eident.name == L->ialignof || n->ecompo.name->eident.name == L->ioffsetof) { + ((bool *)w->user_data)[0] = true; + } + } +} + +LC_FUNCTION bool LC_ContainsCBuiltin(LC_AST *n) { + LC_TempArena checkpoint = LC_BeginTemp(L->arena); + bool found = false; + { + LC_ASTWalker walker = LC_GetDefaultWalker(L->arena, WalkToFindSizeofLike); + walker.depth_first = false; + walker.user_data = (void *)&found; + LC_WalkAST(&walker, n); + } + LC_EndTemp(checkpoint); + return found; +} + +LC_FUNCTION void SetASTPosOnAll_Walk(LC_ASTWalker *ctx, LC_AST *n) { + n->pos = (LC_Token *)ctx->user_data; +} + +LC_FUNCTION void LC_SetASTPosOnAll(LC_AST *n, LC_Token *pos) { + LC_TempArena check = LC_BeginTemp(L->arena); + LC_ASTWalker walker = LC_GetDefaultWalker(L->arena, SetASTPosOnAll_Walk); + walker.user_data = (void *)pos; + LC_WalkAST(&walker, n); + LC_EndTemp(check); +} +LC_FUNCTION LC_AST *LC_CopyAST(LC_Arena *arena, LC_AST *n) { + if (n == NULL) return NULL; + + LC_AST *result = LC_PushStruct(arena, LC_AST); + result->kind = n->kind; + result->id = ++L->ast_count; + result->notes = LC_CopyAST(arena, n->notes); + result->pos = n->pos; + + switch (n->kind) { + case LC_ASTKind_File: { + result->afile.x = n->afile.x; + + LC_ASTFor(it, n->afile.fimport) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->afile.fimport, result->afile.limport, it_copy); + } + LC_ASTFor(it, n->afile.fdecl) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->afile.fdecl, result->afile.ldecl, it_copy); + } + LC_ASTFor(it, n->afile.fdiscarded) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->afile.fdiscarded, result->afile.ldiscarded, it_copy); + } + + result->afile.build_if = n->afile.build_if; + } break; + + case LC_ASTKind_DeclProc: { + result->dbase.name = n->dbase.name; + result->dproc.body = LC_CopyAST(arena, n->dproc.body); + result->dproc.type = LC_CopyAST(arena, n->dproc.type); + } break; + + case LC_ASTKind_NoteList: { + LC_ASTFor(it, n->anote_list.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->anote_list.first, result->anote_list.last, it_copy); + } + } break; + + case LC_ASTKind_TypespecAggMem: + case LC_ASTKind_TypespecProcArg: { + result->tproc_arg.name = n->tproc_arg.name; + result->tproc_arg.type = LC_CopyAST(arena, n->tproc_arg.type); + result->tproc_arg.expr = LC_CopyAST(arena, n->tproc_arg.expr); + } break; + + case LC_ASTKind_ExprNote: { + result->enote.expr = LC_CopyAST(arena, n->enote.expr); + } break; + + case LC_ASTKind_StmtSwitch: { + LC_ASTFor(it, n->sswitch.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->sswitch.first, result->sswitch.last, it_copy); + } + result->sswitch.total_switch_case_count = n->sswitch.total_switch_case_count; + result->sswitch.expr = LC_CopyAST(arena, n->sswitch.expr); + } break; + + case LC_ASTKind_StmtSwitchCase: { + LC_ASTFor(it, n->scase.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->scase.first, result->scase.last, it_copy); + } + result->scase.body = LC_CopyAST(arena, n->scase.body); + } break; + + case LC_ASTKind_StmtSwitchDefault: { + LC_ASTFor(it, n->scase.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->scase.first, result->scase.last, it_copy); + } + result->scase.body = LC_CopyAST(arena, n->scase.body); + } break; + + case LC_ASTKind_StmtIf: { + LC_ASTFor(it, n->sif.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->sswitch.first, result->sswitch.last, it_copy); + } + result->sif.expr = LC_CopyAST(arena, n->sif.expr); + result->sif.body = LC_CopyAST(arena, n->sif.body); + } break; + + case LC_ASTKind_StmtElse: + case LC_ASTKind_StmtElseIf: { + result->sif.expr = LC_CopyAST(arena, n->sif.expr); + result->sif.body = LC_CopyAST(arena, n->sif.body); + } break; + + case LC_ASTKind_GlobImport: { + result->gimport.name = n->gimport.name; + result->gimport.path = n->gimport.path; + } break; + + case LC_ASTKind_DeclNote: { + result->dnote.expr = LC_CopyAST(arena, n->dnote.expr); + } break; + + case LC_ASTKind_DeclUnion: + case LC_ASTKind_DeclStruct: { + result->dbase.name = n->dbase.name; + LC_ASTFor(it, n->dagg.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->dagg.first, result->dagg.last, it_copy); + } + } break; + + case LC_ASTKind_DeclVar: { + result->dbase.name = n->dbase.name; + result->dvar.type = LC_CopyAST(arena, n->dvar.type); + result->dvar.expr = LC_CopyAST(arena, n->dvar.expr); + } break; + + case LC_ASTKind_DeclConst: { + result->dbase.name = n->dbase.name; + result->dconst.expr = LC_CopyAST(arena, n->dconst.expr); + } break; + + case LC_ASTKind_DeclTypedef: { + result->dbase.name = n->dbase.name; + result->dtypedef.type = LC_CopyAST(arena, n->dtypedef.type); + } break; + + case LC_ASTKind_ExprField: + case LC_ASTKind_TypespecField: { + result->efield.left = LC_CopyAST(arena, n->efield.left); + result->efield.right = n->efield.right; + } break; + + case LC_ASTKind_TypespecIdent: { + result->eident.name = n->eident.name; + } break; + + case LC_ASTKind_TypespecPointer: { + result->tpointer.base = LC_CopyAST(arena, n->tpointer.base); + } break; + + case LC_ASTKind_TypespecArray: { + result->tarray.base = LC_CopyAST(arena, n->tarray.base); + result->tarray.index = LC_CopyAST(arena, n->tarray.index); + } break; + + case LC_ASTKind_TypespecProc: { + LC_ASTFor(it, n->tproc.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->tproc.first, result->tproc.last, it_copy); + } + result->tproc.ret = LC_CopyAST(arena, n->tproc.ret); + result->tproc.vargs = n->tproc.vargs; + } break; + + case LC_ASTKind_StmtBlock: { + LC_ASTFor(it, n->sblock.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->sblock.first, result->sblock.last, it_copy); + + if (it_copy->kind == LC_ASTKind_StmtDefer) { + LC_SLLStackAddMod(result->sblock.first_defer, it_copy, sdefer.next); + } + } + if (n->sblock.first_defer) { + LC_ASSERT(result, result->sblock.first_defer); + } + result->sblock.kind = n->sblock.kind; + result->sblock.name = n->sblock.name; + } break; + + case LC_ASTKind_StmtNote: { + result->snote.expr = LC_CopyAST(arena, n->snote.expr); + } break; + + case LC_ASTKind_StmtReturn: { + result->sreturn.expr = LC_CopyAST(arena, n->sreturn.expr); + } break; + + case LC_ASTKind_StmtBreak: { + result->sbreak.name = n->sbreak.name; + } break; + + case LC_ASTKind_StmtContinue: { + result->scontinue.name = n->scontinue.name; + } break; + + case LC_ASTKind_StmtDefer: { + result->sdefer.body = LC_CopyAST(arena, n->sdefer.body); + } break; + + case LC_ASTKind_StmtFor: { + result->sfor.init = LC_CopyAST(arena, n->sfor.init); + result->sfor.cond = LC_CopyAST(arena, n->sfor.cond); + result->sfor.inc = LC_CopyAST(arena, n->sfor.inc); + result->sfor.body = LC_CopyAST(arena, n->sfor.body); + } break; + + case LC_ASTKind_StmtAssign: { + result->sassign.op = n->sassign.op; + result->sassign.left = LC_CopyAST(arena, n->sassign.left); + result->sassign.right = LC_CopyAST(arena, n->sassign.right); + } break; + + case LC_ASTKind_StmtExpr: { + result->sexpr.expr = LC_CopyAST(arena, n->sexpr.expr); + } break; + + case LC_ASTKind_StmtVar: { + result->svar.type = LC_CopyAST(arena, n->svar.type); + result->svar.expr = LC_CopyAST(arena, n->svar.expr); + result->svar.name = n->svar.name; + } break; + + case LC_ASTKind_StmtConst: { + result->sconst.expr = LC_CopyAST(arena, n->sconst.expr); + result->sconst.name = n->sconst.name; + } break; + + case LC_ASTKind_ExprIdent: { + result->eident.name = n->eident.name; + } break; + + case LC_ASTKind_ExprBool: + case LC_ASTKind_ExprFloat: + case LC_ASTKind_ExprInt: + case LC_ASTKind_ExprString: { + result->eatom = n->eatom; + } break; + + case LC_ASTKind_ExprType: { + result->etype.type = LC_CopyAST(arena, n->etype.type); + } break; + + case LC_ASTKind_ExprAddPtr: + case LC_ASTKind_ExprBinary: { + result->ebinary.op = n->ebinary.op; + result->ebinary.left = LC_CopyAST(arena, n->ebinary.left); + result->ebinary.right = LC_CopyAST(arena, n->ebinary.right); + } break; + + case LC_ASTKind_ExprGetPointerOfValue: + case LC_ASTKind_ExprGetValueOfPointer: + case LC_ASTKind_ExprUnary: { + result->eunary.op = n->eunary.op; + result->eunary.expr = LC_CopyAST(arena, n->eunary.expr); + } break; + + case LC_ASTKind_ExprCompoundItem: + case LC_ASTKind_ExprCallItem: { + result->ecompo_item.name = n->ecompo_item.name; + result->ecompo_item.index = LC_CopyAST(arena, n->ecompo_item.index); + result->ecompo_item.expr = LC_CopyAST(arena, n->ecompo_item.expr); + } break; + + case LC_ASTKind_ExprBuiltin: + case LC_ASTKind_Note: + case LC_ASTKind_ExprCall: + case LC_ASTKind_ExprCompound: { + LC_ASTFor(it, n->ecompo.first) { + LC_AST *it_copy = LC_CopyAST(arena, it); + LC_DLLAdd(result->ecompo.first, result->ecompo.last, it_copy); + } + + result->ecompo.size = n->ecompo.size; + result->ecompo.name = LC_CopyAST(arena, n->ecompo.name); + } break; + + case LC_ASTKind_ExprCast: { + result->ecast.type = LC_CopyAST(arena, n->ecast.type); + result->ecast.expr = LC_CopyAST(arena, n->ecast.expr); + } break; + + case LC_ASTKind_ExprIndex: { + result->eindex.index = LC_CopyAST(arena, n->eindex.index); + result->eindex.base = LC_CopyAST(arena, n->eindex.base); + } break; + + default: LC_ReportASTError(n, "internal compiler error: failed to LC_CopyAST, got invalid ast kind: %s", LC_ASTKindToString(n->kind)); + } + + return result; +} + +// clang-format off +#define LC_PUSH_COMP_ARRAY_SIZE(SIZE) int PREV_SIZE = L->resolver.compo_context_array_size; L->resolver.compo_context_array_size = SIZE; +#define LC_POP_COMP_ARRAY_SIZE() L->resolver.compo_context_array_size = PREV_SIZE +#define LC_PUSH_SCOPE(SCOPE) DeclScope *PREV_SCOPE = L->resolver.active_scope; L->resolver.active_scope = SCOPE +#define LC_POP_SCOPE() L->resolver.active_scope = PREV_SCOPE +#define LC_PUSH_LOCAL_SCOPE() int LOCAL_LEN = L->resolver.locals.len +#define LC_POP_LOCAL_SCOPE() L->resolver.locals.len = LOCAL_LEN +#define LC_PUSH_PACKAGE(PKG) LC_AST *PREV_PKG = L->resolver.package; L->resolver.package = PKG; LC_PUSH_SCOPE(PKG->apackage.scope) +#define LC_POP_PACKAGE() L->resolver.package = PREV_PKG; LC_POP_SCOPE() +#define LC_PROP_ERROR(OP, n, ...) OP = __VA_ARGS__; if (LC_IsError(OP)) { n->kind = LC_ASTKind_Error; return OP; } +#define LC_DECL_PROP_ERROR(OP, ...) OP = __VA_ARGS__; if (LC_IsError(OP)) { LC_MarkDeclError(decl); return OP; } + +#define LC_IF(COND, N, ...) if (COND) { LC_Operand R_ = LC_ReportASTError(N, __VA_ARGS__); N->kind = LC_ASTKind_Error; return R_; } +#define LC_DECL_IF(COND, ...) if (COND) { LC_MarkDeclError(decl); return LC_ReportASTError(__VA_ARGS__); } +#define LC_TYPE_IF(COND, ...) if (COND) { LC_MarkDeclError(decl); type->kind = LC_TypeKind_Error; return LC_ReportASTError(__VA_ARGS__); } +// clang-format on + +LC_FUNCTION void LC_AddDecl(LC_DeclStack *scope, LC_Decl *decl) { + if (scope->len + 1 > scope->cap) { + LC_ASSERT(NULL, scope->cap); + int new_cap = scope->cap * 2; + LC_Decl **new_stack = LC_PushArray(L->arena, LC_Decl *, new_cap); + LC_MemoryCopy(new_stack, scope->stack, scope->len * sizeof(LC_Decl *)); + scope->stack = new_stack; + scope->cap = new_cap; + } + scope->stack[scope->len++] = decl; +} + +LC_FUNCTION void LC_InitDeclStack(LC_DeclStack *stack, int size) { + stack->stack = LC_PushArray(L->arena, LC_Decl *, size); + stack->cap = size; +} + +LC_FUNCTION LC_DeclStack *LC_CreateDeclStack(int size) { + LC_DeclStack *stack = LC_PushStruct(L->arena, LC_DeclStack); + LC_InitDeclStack(stack, size); + return stack; +} + +LC_FUNCTION LC_Decl *LC_FindDeclOnStack(LC_DeclStack *scp, LC_Intern name) { + for (int i = 0; i < scp->len; i += 1) { + LC_Decl *it = scp->stack[i]; + if (it->name == name) { + return it; + } + } + return NULL; +} + +LC_FUNCTION void LC_MarkDeclError(LC_Decl *decl) { + if (decl) { + decl->kind = LC_DeclKind_Error; + decl->state = LC_DeclState_Error; + if (decl->ast) decl->ast->kind = LC_ASTKind_Error; + } +} + +LC_FUNCTION LC_Decl *LC_CreateDecl(LC_DeclKind kind, LC_Intern name, LC_AST *n) { + LC_Decl *decl = LC_PushStruct(L->decl_arena, LC_Decl); + L->decl_count += 1; + + decl->name = name; + decl->kind = kind; + decl->ast = n; + decl->package = L->resolver.package; + LC_ASSERT(n, decl->package); + + LC_AST *note = LC_HasNote(n, L->iforeign); + if (note) { + decl->is_foreign = true; + if (note->anote.first) { + if (note->anote.size != 1) LC_ReportASTError(note, "invalid format of @foreign(...), more then 1 argument"); + LC_AST *expr = note->anote.first->ecompo_item.expr; + if (expr->kind == LC_ASTKind_ExprIdent) decl->foreign_name = expr->eident.name; + if (expr->kind != LC_ASTKind_ExprIdent) LC_ReportASTError(note, "invalid format of @foreign(...), expected identifier"); + } + } + if (!decl->foreign_name) decl->foreign_name = decl->name; + return decl; +} + +LC_FUNCTION LC_Operand LC_ThereIsNoDecl(DeclScope *scp, LC_Decl *decl, bool check_locals) { + LC_Decl *r = (LC_Decl *)LC_MapGetU64(scp, decl->name); + if (check_locals && !r) { + r = LC_FindDeclOnStack(&L->resolver.locals, decl->name); + } + if (r) { + LC_MarkDeclError(r); + LC_MarkDeclError(decl); + return LC_ReportASTErrorEx(decl->ast, r->ast, "there are 2 decls with the same name '%s'", decl->name); + } + return LC_OPNull; +} + +LC_FUNCTION LC_Operand LC_AddDeclToScope(DeclScope *scp, LC_Decl *decl) { + LC_Operand LC_DECL_PROP_ERROR(op, LC_ThereIsNoDecl(scp, decl, false)); + LC_MapInsertU64(scp, decl->name, decl); + return LC_OPDecl(decl); +} + +LC_FUNCTION DeclScope *LC_CreateScope(int size) { + DeclScope *scope = LC_PushStruct(L->arena, DeclScope); + scope->arena = L->arena; + LC_MapReserve(scope, size); + return scope; +} + +LC_FUNCTION LC_Decl *LC_FindDeclInScope(DeclScope *scope, LC_Intern name) { + LC_Decl *decl = (LC_Decl *)LC_MapGetU64(scope, name); + return decl; +} + +LC_FUNCTION LC_Decl *LC_GetLocalOrGlobalDecl(LC_Intern name) { + LC_Decl *decl = LC_FindDeclInScope(L->resolver.active_scope, name); + if (!decl && L->resolver.package->apackage.scope == L->resolver.active_scope) { + decl = LC_FindDeclOnStack(&L->resolver.locals, name); + } + return decl; +} + +LC_FUNCTION LC_Operand LC_PutGlobalDecl(LC_Decl *decl) { + LC_Operand LC_DECL_PROP_ERROR(op, LC_AddDeclToScope(L->resolver.package->apackage.scope, decl)); + + // :Mangle global scope name + if (!decl->is_foreign && decl->package != L->builtin_package) { + bool mangle = true; + if (LC_HasNote(decl->ast, L->idont_mangle)) mangle = false; + if (LC_HasNote(decl->ast, L->iapi)) mangle = false; + if (decl->name == L->imain) { + if (L->first_package) { + if (L->first_package == decl->package->apackage.name) { + mangle = false; + } + } else mangle = false; + } + if (mangle) { + LC_String name = LC_Format(L->arena, "lc_%s_%s", (char *)decl->package->apackage.name, (char *)decl->name); + decl->foreign_name = LC_InternStrLen(name.str, (int)name.len); + } + } + + LC_Decl *conflict = (LC_Decl *)LC_MapGetU64(&L->foreign_names, decl->foreign_name); + if (conflict && !decl->is_foreign) { + LC_ReportASTErrorEx(decl->ast, conflict->ast, "found two global declarations with the same foreign name: %s", decl->foreign_name); + } else { + LC_MapInsertU64(&L->foreign_names, decl->foreign_name, decl); + } + + return op; +} + +LC_FUNCTION LC_Operand LC_CreateLocalDecl(LC_DeclKind kind, LC_Intern name, LC_AST *ast) { + LC_Decl *decl = LC_CreateDecl(kind, name, ast); + decl->state = LC_DeclState_Resolving; + LC_Operand LC_DECL_PROP_ERROR(operr0, LC_ThereIsNoDecl(L->resolver.package->apackage.scope, decl, true)); + LC_AddDecl(&L->resolver.locals, decl); + return LC_OPDecl(decl); +} + +LC_FUNCTION LC_Decl *LC_AddConstIntDecl(char *key, int64_t value) { + LC_Intern intern = LC_ILit(key); + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Const, intern, &L->NullAST); + decl->state = LC_DeclState_Resolved; + decl->type = L->tuntypedint; + LC_Bigint_init_signed(&decl->v.i, value); + LC_AddDeclToScope(L->resolver.package->apackage.scope, decl); + return decl; +} + +LC_FUNCTION LC_Decl *LC_GetBuiltin(LC_Intern name) { + LC_Decl *decl = (LC_Decl *)LC_MapGetU64(L->builtin_package->apackage.scope, name); + return decl; +} + +LC_FUNCTION void LC_AddBuiltinConstInt(char *key, int64_t value) { + LC_PUSH_PACKAGE(L->builtin_package); + LC_AddConstIntDecl(key, value); + LC_POP_PACKAGE(); +} + +LC_FUNCTION LC_AST *LC_HasNote(LC_AST *ast, LC_Intern i) { + if (ast && ast->notes) { + LC_ASTFor(it, ast->notes->anote_list.first) { + LC_ASSERT(it, "internal compiler error: note is not an identifier"); + if (it->anote.name->eident.name == i) { + return it; + } + } + } + return NULL; +} + +LC_FUNCTION void LC_RegisterDeclsFromFile(LC_AST *file) { + LC_ASTFor(n, file->afile.fdecl) { + if (n->dbase.resolved_decl) continue; + if (n->kind == LC_ASTKind_DeclNote) continue; + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Type, n->dbase.name, n); + switch (n->kind) { + case LC_ASTKind_DeclStruct: + case LC_ASTKind_DeclUnion: + decl->type = LC_CreateIncompleteType(decl); + decl->state = LC_DeclState_Resolved; + decl->kind = LC_DeclKind_Type; + break; + case LC_ASTKind_DeclTypedef: decl->kind = LC_DeclKind_Type; break; + case LC_ASTKind_DeclProc: decl->kind = LC_DeclKind_Proc; break; + case LC_ASTKind_DeclConst: decl->kind = LC_DeclKind_Const; break; + case LC_ASTKind_DeclVar: decl->kind = LC_DeclKind_Var; break; + default: LC_ReportASTError(n, "internal compiler error: got unhandled ast declaration kind in %s", __FUNCTION__); + } + LC_PutGlobalDecl(decl); + n->dbase.resolved_decl = decl; + } +} + +LC_FUNCTION void LC_ResolveDeclsFromFile(LC_AST *file) { + LC_ASTFor(n, file->afile.fdecl) { + if (n->kind == LC_ASTKind_DeclNote) { + LC_ResolveNote(n, false); + } else { + LC_ResolveName(n, n->dbase.name); + } + } +} + +LC_FUNCTION void LC_PackageDecls(LC_AST *package) { + LC_PUSH_PACKAGE(package); + + // Register top level declarations + LC_ASTFor(file, package->apackage.ffile) { + LC_ASTFor(import, file->afile.fimport) { + if (import->gimport.resolved == false) LC_ReportASTError(import, "internal compiler error: unresolved import got into typechecking stage"); + } + LC_RegisterDeclsFromFile(file); + } + + // Resolve declarations by name + LC_ASTFor(file, package->apackage.ffile) { + LC_ResolveDeclsFromFile(file); + } + + LC_POP_PACKAGE(); +} + +LC_FUNCTION void LC_ResolveProcBodies(LC_AST *package) { + LC_PUSH_PACKAGE(package); + + LC_ASTFor(file, package->apackage.ffile) { + LC_ASTFor(n, file->afile.fdecl) { + if (n->kind == LC_ASTKind_DeclNote) continue; + + LC_Decl *decl = n->dbase.resolved_decl; + if (decl->kind == LC_DeclKind_Proc) { + LC_Operand op = LC_ResolveProcBody(decl); + if (LC_IsError(op)) LC_MarkDeclError(decl); + } + } + } + + LC_POP_PACKAGE(); +} + +LC_FUNCTION void LC_ResolveIncompleteTypes(LC_AST *package) { + LC_PUSH_PACKAGE(package); + + LC_ASTFor(file, package->apackage.ffile) { + LC_ASTFor(n, file->afile.fdecl) { + if (n->kind == LC_ASTKind_DeclNote) continue; + + LC_Decl *decl = n->dbase.resolved_decl; + if (decl->kind == LC_DeclKind_Type) { + LC_ResolveTypeAggregate(decl->ast, decl->type); + } + } + } + + LC_POP_PACKAGE(); +} + +LC_FUNCTION LC_Operand LC_ResolveNote(LC_AST *n, bool is_decl) { + LC_AST *note = n->dnote.expr; + if (n->kind == LC_ASTKind_ExprNote) note = n->enote.expr; + else if (n->kind == LC_ASTKind_StmtNote) note = n->snote.expr; + else { + LC_ASSERT(n, n->kind == LC_ASTKind_DeclNote); + if (n->dnote.processed) return LC_OPNull; + } + + if (note->ecompo.name->eident.name == L->istatic_assert) { + LC_IF(is_decl, note, "#static_assert cant be used as variable initializer"); + LC_Operand LC_PROP_ERROR(op, n, LC_ExpectBuiltinWithOneArg(note)); + LC_IF(!LC_IsUTConst(op) || !LC_IsUTInt(op.type), n, "static assert requires constant untyped integer value"); + int val = (int)LC_Bigint_as_signed(&op.val.i); + LC_IF(!val, note, "#static_assert failed !"); + n->dnote.processed = true; + } + + return LC_OPNull; +} + +void SetConstVal(LC_AST *n, LC_TypeAndVal val) { + LC_ASSERT(n, LC_IsUntyped(val.type)); + n->const_val = val; +} + +LC_FUNCTION LC_Operand LC_ResolveProcBody(LC_Decl *decl) { + if (decl->state == LC_DeclState_Error) return LC_OPError(); + if (decl->state == LC_DeclState_ResolvedBody) return LC_OPNull; + LC_ASSERT(decl->ast, decl->state == LC_DeclState_Resolved); + + LC_AST *n = decl->ast; + if (n->dproc.body == NULL) return LC_OPNull; + L->resolver.locals.len = 0; + LC_ASTFor(it, n->dproc.type->tproc.first) { + if (it->kind == LC_ASTKind_Error) { + LC_MarkDeclError(decl); + return LC_OPError(); + } + LC_ASSERT(it, it->type); + LC_Operand LC_DECL_PROP_ERROR(op, LC_CreateLocalDecl(LC_DeclKind_Var, it->tproc_arg.name, it)); + op.decl->type = it->type; + op.decl->state = LC_DeclState_Resolved; + it->tproc_arg.resolved_decl = op.decl; + } + + int errors_before = L->errors; + LC_ASSERT(n, decl->type->tproc.ret); + L->resolver.expected_ret_type = decl->type->tproc.ret; + LC_Operand LC_DECL_PROP_ERROR(op, LC_ResolveStmtBlock(n->dproc.body)); + L->resolver.locals.len = 0; + + if (errors_before == L->errors && decl->type->tproc.ret != L->tvoid && !(op.flags & LC_OPF_Returned)) { + LC_ReportASTError(n, "you can get through this procedure without hitting a return stmt, add a return to cover all control paths"); + } + decl->state = LC_DeclState_ResolvedBody; + if (L->on_proc_body_resolved) L->on_proc_body_resolved(decl); + return LC_OPNull; +} + +LC_FUNCTION LC_ResolvedCompoItem *LC_AddResolvedCallItem(LC_ResolvedCompo *list, LC_TypeMember *t, LC_AST *comp, LC_AST *expr) { + LC_AST *duplicate1 = (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, list); + if (t && !duplicate1) { + for (LC_ResolvedCompoItem *it = list->first; it; it = it->next) { + if (t == it->t) { + LC_MapInsertP(&L->resolver.duplicate_map, list, comp); + LC_MapInsertP(&L->resolver.duplicate_map, comp, it->comp); // duplicate2 + break; + } + } + } + LC_ResolvedCompoItem *match = LC_PushStruct(L->arena, LC_ResolvedCompoItem); + list->count += 1; + match->t = t; + match->expr = expr; + match->comp = comp; + LC_AddSLL(list->first, list->last, match); + return match; +} + +LC_FUNCTION LC_Operand LC_ResolveCompoCall(LC_AST *n, LC_Type *type) { + LC_ASSERT(n, type->kind == LC_TypeKind_Proc); + LC_IF(type->tproc.vargs && type->tagg.mems.count > n->ecompo.size, n, "calling procedure with invalid argument count, expected at least %d args, got %d, the procedure type is: %s", type->tagg.mems.count, n->ecompo.size, LC_GenLCType(type)); + + bool named_field_appeared = false; + LC_ASTFor(it, n->ecompo.first) { + LC_IF(type->tproc.vargs && it->ecompo_item.name, it, "variadic procedures cannot have named arguments"); + LC_IF(it->ecompo_item.index, it, "index inside a call is not allowed"); + LC_IF(named_field_appeared && it->ecompo_item.name == 0, it, "mixing named and positional arguments is illegal"); + if (it->ecompo_item.name) named_field_appeared = true; + } + + LC_ResolvedCompo *matches = LC_PushStruct(L->arena, LC_ResolvedCompo); + LC_TypeMember *type_it = type->tproc.args.first; + LC_AST *npos_it = n->ecompo.first; + + // greedy match unnamed arguments + for (; type_it; type_it = type_it->next, npos_it = npos_it->next) { + if (npos_it == NULL || npos_it->ecompo_item.name) break; + LC_AddResolvedCallItem(matches, type_it, npos_it, npos_it->ecompo_item.expr); + } + + // greedy match variadic arguments + if (type->tproc.vargs) { + for (; npos_it; npos_it = npos_it->next) { + LC_ResolvedCompoItem *m = LC_AddResolvedCallItem(matches, NULL, npos_it, npos_it->ecompo_item.expr); + m->varg = true; + } + } + + // for every required proc type argument we seek a named argument + // in either default proc values or passed in call arguments + for (; type_it; type_it = type_it->next) { + LC_ASTFor(n_it, npos_it) { + if (type_it->name == n_it->ecompo_item.name) { + LC_AddResolvedCallItem(matches, type_it, n_it, n_it->ecompo_item.expr); + goto end_of_outer_loop; + } + } + + if (type_it->default_value_expr) { + LC_ResolvedCompoItem *m = LC_AddResolvedCallItem(matches, type_it, NULL, type_it->default_value_expr); + m->defaultarg = true; + } + end_of_outer_loop:; + } + + // make sure we matched every item in call + LC_ASTFor(n_it, n->ecompo.first) { + LC_AST *expr = n_it->ecompo_item.expr; + bool included = false; + for (LC_ResolvedCompoItem *it = matches->first; it; it = it->next) { + if (it->expr == expr) { + included = true; + break; + } + } + + LC_IF(!included, expr, "unknown argument to a procedure call, couldn't match it with any of the declared arguments, the procedure type is: %s", LC_GenLCType(type)); + } + + LC_IF(!type->tproc.vargs && matches->count != type->tproc.args.count, n, "invalid argument count passed in to procedure call, expected: %d, matched: %d, the procedure type is: %s", type->tproc.args.count, matches->count, LC_GenLCType(type)); + + // error on duplicates + LC_AST *duplicate1 = (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, matches); + LC_AST *duplicate2 = duplicate1 ? (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, duplicate1) : NULL; + LC_MapClear(&L->resolver.duplicate_map); + if (duplicate1) { + LC_Operand err = LC_ReportASTErrorEx(duplicate1, duplicate2, "two call items match the same procedure argument"); + n->kind = LC_ASTKind_Error; + return err; + } + + // resolve + for (LC_ResolvedCompoItem *it = matches->first; it; it = it->next) { + if (it->varg) { + if (type->tproc.vargs_any_promotion) { + LC_Operand LC_PROP_ERROR(opexpr, it->expr, LC_ResolveExprAndPushCompoContext(it->expr, L->tany)); + LC_TryTyping(it->expr, LC_OPType(L->tany)); + } else { + LC_Operand LC_PROP_ERROR(opexpr, it->expr, LC_ResolveExpr(it->expr)); + LC_Operand LC_PROP_ERROR(op, it->expr, LC_ResolveTypeVargs(it->expr, opexpr)); + LC_TryTyping(it->expr, op); + } + continue; + } + if (it->defaultarg) { + continue; + } + LC_Operand LC_PROP_ERROR(opexpr, it->expr, LC_ResolveExprAndPushCompoContext(it->expr, it->t->type)); + LC_Operand LC_PROP_ERROR(op, it->expr, LC_ResolveTypeVarDecl(it->expr, LC_OPType(it->t->type), opexpr)); + LC_TryTyping(it->expr, op); + } + + n->ecompo.resolved_items = matches; + LC_Operand result = LC_OPLValueAndType(type->tproc.ret); + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveCompoAggregate(LC_AST *n, LC_Type *type) { + LC_ASSERT(n, type->kind == LC_TypeKind_Union || type->kind == LC_TypeKind_Struct); + LC_IF(n->ecompo.size > 1 && type->kind == LC_TypeKind_Union, n, "too many union initializers, expected 1 or 0 got %d", n->ecompo.size); + LC_IF(n->ecompo.size > type->tagg.mems.count, n, "too many struct initializers, expected less then %d got instead %d", type->tagg.mems.count, n->ecompo.size); + + bool named_field_appeared = false; + LC_ASTFor(it, n->ecompo.first) { + LC_IF(type->kind == LC_TypeKind_Union && it->ecompo_item.name == 0, it, "unions can only be initialized using named arguments"); + LC_IF(named_field_appeared && it->ecompo_item.name == 0, it, "mixing named and positional arguments is illegal"); + LC_IF(it->ecompo_item.index, it, "index specifier in non array compound is illegal"); + if (it->ecompo_item.name) named_field_appeared = true; + } + + LC_ResolvedCompo *matches = LC_PushStruct(L->arena, LC_ResolvedCompo); + LC_TypeMember *type_it = type->tagg.mems.first; + LC_AST *npos_it = n->ecompo.first; + + // greedy match unnamed arguments + for (; type_it; type_it = type_it->next, npos_it = npos_it->next) { + if (npos_it == NULL || npos_it->ecompo_item.name) break; + LC_AddResolvedCallItem(matches, type_it, npos_it, npos_it->ecompo_item.expr); + } + + // match named arguments + for (; npos_it; npos_it = npos_it->next) { + bool found = false; + LC_TypeFor(type_it, type->tagg.mems.first) { + if (type_it->name == npos_it->ecompo_item.name) { + LC_AddResolvedCallItem(matches, type_it, npos_it, npos_it->ecompo_item.expr); + found = true; + break; + } + } + + LC_IF(!found, npos_it, "no matching declaration with name '%s' in type '%s'", npos_it->ecompo_item.name, LC_GenLCType(type)); + } + + // error on duplicates + LC_AST *duplicate1 = (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, matches); + LC_AST *duplicate2 = duplicate1 ? (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, duplicate1) : NULL; + if (duplicate1) { + LC_Operand err = LC_ReportASTErrorEx(duplicate1, duplicate2, "two compound items match the same struct variable"); + n->kind = LC_ASTKind_Error; + return err; + } + + // resolve + LC_Operand result = LC_OPLValueAndType(type); + result.flags |= LC_OPF_Const; + for (LC_ResolvedCompoItem *it = matches->first; it; it = it->next) { + LC_Operand LC_PROP_ERROR(opexpr, it->expr, LC_ResolveExprAndPushCompoContext(it->expr, it->t->type)); + LC_Operand LC_PROP_ERROR(op, it->expr, LC_ResolveTypeVarDecl(it->expr, LC_OPType(it->t->type), opexpr)); + LC_TryTyping(it->expr, op); + + if (!(opexpr.flags & LC_OPF_Const)) result.flags &= ~LC_OPF_Const; + } + + n->ecompo.resolved_items = matches; + return result; +} + +LC_FUNCTION LC_ResolvedCompoArrayItem *LC_AddResolvedCompoArrayItem(LC_ResolvedArrayCompo *arr, int index, LC_AST *comp) { + LC_AST *duplicate1 = (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, arr); + if (!duplicate1) { + for (LC_ResolvedCompoArrayItem *it = arr->first; it; it = it->next) { + if (index == it->index) { + LC_MapInsertP(&L->resolver.duplicate_map, arr, comp); + LC_MapInsertP(&L->resolver.duplicate_map, comp, it->comp); + break; + } + } + } + LC_ResolvedCompoArrayItem *result = LC_PushStruct(L->arena, LC_ResolvedCompoArrayItem); + result->index = index; + result->comp = comp; + arr->count += 1; + LC_AddSLL(arr->first, arr->last, result); + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveCompoArray(LC_AST *n, LC_Type *type) { + LC_ASSERT(n, type->kind == LC_TypeKind_Array); + LC_IF(n->ecompo.size > type->tarray.size, n, "too many array intializers, array is of size '%d', got '%d'", type->tarray.size, n->ecompo.size); + + bool index_appeared = false; + LC_ASTFor(it, n->ecompo.first) { + LC_IF(index_appeared && it->ecompo_item.index == NULL, it, "mixing indexed and positional arguments is illegal"); + LC_IF(it->ecompo_item.name, it, "named arguments are invalid in array compound literal"); + if (it->ecompo_item.index) index_appeared = true; + } + + LC_ResolvedArrayCompo *matches = LC_PushStruct(L->arena, LC_ResolvedArrayCompo); + LC_AST *npos_it = n->ecompo.first; + int index = 0; + + // greedy match unnamed arguments + for (; npos_it; npos_it = npos_it->next) { + if (npos_it->ecompo_item.index) break; + LC_ASSERT(n, index < type->tarray.size); + LC_AddResolvedCompoArrayItem(matches, index++, npos_it); + } + + // match indexed arguments + for (; npos_it; npos_it = npos_it->next) { + uint64_t val = 0; + LC_Operand LC_PROP_ERROR(op, npos_it, LC_ResolveConstInt(npos_it->ecompo_item.index, L->tint, &val)); + LC_IF(val > type->tarray.size, npos_it, "array index out of bounds, array is of size %d", type->tarray.size); + LC_AddResolvedCompoArrayItem(matches, (int)val, npos_it); + } + + // error on duplicates + LC_AST *duplicate1 = (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, matches); + LC_AST *duplicate2 = duplicate1 ? (LC_AST *)LC_MapGetP(&L->resolver.duplicate_map, duplicate1) : NULL; + if (duplicate1) { + LC_Operand err = LC_ReportASTErrorEx(duplicate1, duplicate2, "two items in compound array literal match the same index"); + n->kind = LC_ASTKind_Error; + return err; + } + + // resolve + LC_Operand result = LC_OPLValueAndType(type); + result.flags |= LC_OPF_Const; + for (LC_ResolvedCompoArrayItem *it = matches->first; it; it = it->next) { + LC_AST *expr = it->comp->ecompo_item.expr; + LC_Operand LC_PROP_ERROR(opexpr, expr, LC_ResolveExprAndPushCompoContext(expr, type->tbase)); + LC_Operand LC_PROP_ERROR(op, expr, LC_ResolveTypeVarDecl(expr, LC_OPType(type->tbase), opexpr)); + LC_TryTyping(expr, op); + + if (!(opexpr.flags & LC_OPF_Const)) result.flags &= ~LC_OPF_Const; + } + + n->ecompo.resolved_array_items = matches; + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveTypeOrExpr(LC_AST *n) { + if (n->kind == LC_ASTKind_ExprType) { + LC_Operand LC_PROP_ERROR(result, n, LC_ResolveType(n->etype.type)); + n->type = result.type; + return result; + } else { + LC_Operand LC_PROP_ERROR(result, n, LC_ResolveExpr(n)); + return result; + } +} + +LC_FUNCTION LC_Operand LC_ExpectBuiltinWithOneArg(LC_AST *n) { + LC_IF(n->ecompo.size != 1, n, "expected 1 argument to builtin procedure, got: %d", n->ecompo.size); + LC_IF(n->ecompo.first->ecompo_item.name, n, "named arguments in this builtin procedure are illegal"); + LC_AST *expr = n->ecompo.first->ecompo_item.expr; + LC_Operand LC_PROP_ERROR(op, expr, LC_ResolveTypeOrExpr(expr)); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, op.type)); + expr->type = op.type; + return op; +} + +LC_FUNCTION LC_Operand LC_ResolveBuiltin(LC_AST *n) { + LC_Operand result = {0}; + if (n->ecompo.name == 0 || n->ecompo.name->kind != LC_ASTKind_ExprIdent) return result; + LC_Intern ident = n->ecompo.name->eident.name; + + if (ident == L->ilengthof) { + LC_Operand LC_PROP_ERROR(op, n, LC_ExpectBuiltinWithOneArg(n)); + if (LC_IsArray(op.type)) { + result = LC_OPInt(op.type->tarray.size); + } else if (LC_IsUTStr(op.type)) { + int64_t length = LC_StrLen((char *)op.v.name); + result = LC_OPInt(length); + } else LC_IF(1, n, "expected array or constant string type, got instead '%s'", LC_GenLCType(op.type)); + n->kind = LC_ASTKind_ExprBuiltin; + } else if (ident == L->isizeof) { + LC_Operand LC_PROP_ERROR(op, n, LC_ExpectBuiltinWithOneArg(n)); + LC_IF(LC_IsUntyped(op.type), n, "cannot get sizeof a value that is untyped: '%s'", LC_GenLCType(op.type)); + result = LC_OPInt(op.type->size); + n->kind = LC_ASTKind_ExprBuiltin; + } else if (ident == L->ialignof) { + LC_Operand LC_PROP_ERROR(op, n, LC_ExpectBuiltinWithOneArg(n)); + LC_IF(LC_IsUntyped(op.type), n, "cannot get alignof a value that is untyped: '%s'", LC_GenLCType(op.type)); + + LC_AST *expr = n->ecompo.first->ecompo_item.expr; + LC_IF(expr->kind != LC_ASTKind_ExprType, expr, "argument should be a type, instead it's '%s'", LC_ASTKindToString(expr->kind)); + + result = LC_OPInt(op.type->align); + n->kind = LC_ASTKind_ExprBuiltin; + } else if (ident == L->itypeof) { + LC_Operand LC_PROP_ERROR(op, n, LC_ExpectBuiltinWithOneArg(n)); + LC_IF(LC_IsUntyped(op.type), n, "cannot get typeof a value that is untyped: '%s'", LC_GenLCType(op.type)); + result = LC_OPInt(op.type->id); + n->kind = LC_ASTKind_ExprBuiltin; + } else if (ident == L->ioffsetof) { + LC_IF(n->ecompo.size != 2, n, "expected 2 arguments to builtin procedure 'offsetof', got: %d", n->ecompo.size); + LC_AST *a1 = n->ecompo.first; + LC_AST *a2 = a1->next; + LC_IF(a1->ecompo_item.name, a1, "named arguments in this builtin procedure are illegal"); + LC_IF(a2->ecompo_item.name, a2, "named arguments in this builtin procedure are illegal"); + LC_AST *a1e = a1->ecompo_item.expr; + LC_AST *a2e = a2->ecompo_item.expr; + LC_IF(a1e->kind != LC_ASTKind_ExprType, a1e, "first argument should be a type, instead it's '%s'", LC_ASTKindToString(a1e->kind)); + LC_Operand LC_PROP_ERROR(optype, a1e, LC_ResolveType(a1e->etype.type)); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(a1e, optype.type)); + LC_IF(!LC_IsAggType(optype.type), a1e, "expected aggregate type in first parameter of 'offsetof', instead got '%s'", LC_GenLCType(optype.type)); + LC_IF(a2e->kind != LC_ASTKind_ExprIdent, a2e, "expected identifier as second parameter to 'offsetof', instead got '%s'", LC_ASTKindToString(a2e->kind)); + a1e->type = optype.type; + + LC_Type *type = optype.type; + LC_TypeMember *found_type = NULL; + LC_TypeFor(it, type->tagg.mems.first) { + if (it->name == a2e->eident.name) { + found_type = it; + break; + } + } + + LC_ASSERT(n, type->decl); + LC_IF(!found_type, n, "field '%s' not found in '%s'", a2e->eident.name, type->decl->name); + result = LC_OPInt(found_type->offset); + n->kind = LC_ASTKind_ExprBuiltin; + } + + if (LC_IsUTConst(result)) { + n->const_val = result.val; + } + + return result; +} + +LC_FUNCTION bool LC_TryTyping(LC_AST *n, LC_Operand op) { + LC_ASSERT(n, n->type); + + if (LC_IsUntyped(n->type)) { + if (LC_IsUTInt(n->type) && LC_IsFloat(op.type)) { + LC_Operand in = {LC_OPF_UTConst | LC_OPF_Const}; + in.val = n->const_val; + LC_Operand op = LC_ConstCastFloat(NULL, in); + SetConstVal(n, op.val); + } + if (L->tany == op.type) op = LC_OPModDefaultUT(LC_OPType(n->type)); + n->type = op.type; + + // Bounds check + if (n->const_val.type && LC_IsUTInt(n->const_val.type)) { + if (LC_IsInt(n->type) && !LC_BigIntFits(n->const_val.i, n->type)) { + const char *val = LC_Bigint_str(&n->const_val.i, 10); + LC_ReportASTError(n, "value '%s', doesn't fit into type '%s'", val, LC_GenLCType(n->type)); + } + } + } + + // I think it returns true to do this: (a, b) + return true; +} + +LC_FUNCTION bool LC_TryDefaultTyping(LC_AST *n, LC_Operand *o) { + LC_ASSERT(n, n->type); + if (LC_IsUntyped(n->type)) { + n->type = n->type->tbase; + if (o) o->type = n->type; + } + return true; +} + +LC_FUNCTION LC_Operand LC_ResolveNameInScope(LC_AST *n, LC_Decl *parent_decl) { + LC_ASSERT(n, n->kind == LC_ASTKind_ExprField || n->kind == LC_ASTKind_TypespecField); + LC_PUSH_SCOPE(parent_decl->scope); + LC_Operand op = LC_ResolveName(n, n->efield.right); + LC_POP_SCOPE(); + if (LC_IsError(op)) { + n->kind = LC_ASTKind_Error; + return op; + } + + LC_ASSERT(n, op.decl); + n->efield.resolved_decl = op.decl; + n->efield.parent_decl = parent_decl; + + LC_ASSERT(n, op.decl->kind != LC_DeclKind_Import); + return op; +} + +LC_FUNCTION LC_Operand LC_ResolveExpr(LC_AST *expr) { + return LC_ResolveExprAndPushCompoContext(expr, NULL); +} + +LC_FUNCTION LC_Operand LC_ResolveExprAndPushCompoContext(LC_AST *expr, LC_Type *type) { + LC_Type *save = L->resolver.compo_context_type; + L->resolver.compo_context_type = type; + LC_Operand LC_PROP_ERROR(result, expr, LC_ResolveExprEx(expr)); + L->resolver.compo_context_type = save; + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveExprEx(LC_AST *n) { + LC_Operand result = {0}; + LC_ASSERT(n, LC_IsExpr(n)); + + switch (n->kind) { + case LC_ASTKind_ExprFloat: { + result.flags = LC_OPF_UTConst | LC_OPF_Const; + result.val.d = n->eatom.d; + result.val.type = L->tuntypedfloat; + SetConstVal(n, result.val); + } break; + case LC_ASTKind_ExprInt: { + result.flags = LC_OPF_UTConst | LC_OPF_Const; + result.val.i = n->eatom.i; + result.val.type = L->tuntypedint; + SetConstVal(n, result.val); + } break; + case LC_ASTKind_ExprBool: { + result.flags = LC_OPF_UTConst | LC_OPF_Const; + result.val.i = n->eatom.i; + result.val.type = L->tuntypedbool; + SetConstVal(n, result.val); + } break; + case LC_ASTKind_ExprString: { + result.flags = LC_OPF_LValue | LC_OPF_UTConst | LC_OPF_Const; + result.val.name = n->eatom.name; + result.val.type = L->tuntypedstring; + SetConstVal(n, result.val); + } break; + case LC_ASTKind_ExprType: { + return LC_ReportASTError(n, "cannot use type as value"); + } break; + + case LC_ASTKind_ExprIdent: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveName(n, n->eident.name)); + LC_IF(op.decl->kind == LC_DeclKind_Type, n, "declaration is type, unexpected inside expression"); + LC_IF(op.decl->kind == LC_DeclKind_Import, n, "declaration is import, unexpected usage"); + + n->eident.resolved_decl = op.decl; + result.val = op.decl->val; + if (op.decl->kind == LC_DeclKind_Const) { + result.flags |= LC_OPF_UTConst | LC_OPF_Const; + SetConstVal(n, result.val); + } else { + result.flags |= LC_OPF_LValue | LC_OPF_Const; + } + } break; + + case LC_ASTKind_ExprCast: { + LC_Operand LC_PROP_ERROR(optype, n, LC_ResolveType(n->ecast.type)); + LC_Operand LC_PROP_ERROR(opexpr, n, LC_ResolveExpr(n->ecast.expr)); + // :ConstantFold + // the idea is that this will convert the literal into corresponding + // type. In c :uint(32) will become 32u. This way we can avoid doing + // typed arithmetic and let the backend handle it. + if (LC_IsUTConst(opexpr) && (LC_IsNum(optype.type) || LC_IsStr(optype.type))) { + if (LC_IsFloat(optype.type)) { + LC_PROP_ERROR(opexpr, n, LC_ConstCastFloat(n, opexpr)); + SetConstVal(n, opexpr.val); + } else if (LC_IsInt(optype.type)) { + LC_PROP_ERROR(opexpr, n, LC_ConstCastInt(n, opexpr)); + SetConstVal(n, opexpr.val); + } else if (LC_IsStr(optype.type)) { + LC_IF(!LC_IsUTStr(opexpr.type), n, "cannot cast constant expression of type '%s' to '%s'", LC_GenLCType(opexpr.type), LC_GenLCType(optype.type)); + SetConstVal(n, opexpr.val); + } else LC_IF(1, n, "cannot cast constant expression of type '%s' to '%s'", LC_GenLCType(opexpr.type), LC_GenLCType(optype.type)); + result.type = optype.type; + } else { + LC_PROP_ERROR(result, n, LC_ResolveTypeCast(n, optype, opexpr)); + LC_TryTyping(n->ecast.expr, result); + } + result.flags |= (opexpr.flags & LC_OPF_Const); + } break; + + case LC_ASTKind_ExprUnary: { + LC_PROP_ERROR(result, n, LC_ResolveExpr(n->eunary.expr)); + + if (LC_IsUTConst(result)) { + LC_PROP_ERROR(result, n, LC_EvalUnary(n, n->eunary.op, result)); + SetConstVal(n, result.val); + } else { + LC_OPResult r = LC_IsUnaryOpValidForType(n->eunary.op, result.type); + LC_IF(r == LC_OPResult_Error, n, "invalid unary operation for type '%s'", LC_GenLCType(result.type)); + if (r == LC_OPResult_Bool) result = LC_OPModBool(result); + } + } break; + + case LC_ASTKind_ExprBinary: { + LC_Operand LC_PROP_ERROR(left, n, LC_ResolveExpr(n->ebinary.left)); + LC_Operand LC_PROP_ERROR(right, n, LC_ResolveExpr(n->ebinary.right)); + LC_PROP_ERROR(result, n, LC_ResolveBinaryExpr(n, left, right)); + } break; + + case LC_ASTKind_ExprAddPtr: { + LC_Operand LC_PROP_ERROR(left, n, LC_ResolveExpr(n->ebinary.left)); + LC_Operand LC_PROP_ERROR(right, n, LC_ResolveExpr(n->ebinary.right)); + LC_IF(!LC_IsInt(right.type), n, "trying to addptr non integer value of type '%s'", LC_GenLCType(left.type)); + if (LC_IsUTStr(left.type)) LC_TryDefaultTyping(n->ebinary.left, &left); + LC_IF(!LC_IsPtr(left.type) && !LC_IsArray(left.type), n, "left type is required to be a pointer or array, instead got '%s'", LC_GenLCType(left.type)); + result = left; + if (!LC_IsUTConst(right)) result.flags &= ~LC_OPF_Const; + if (LC_IsArray(result.type)) result.type = LC_CreatePointerType(result.type->tbase); + LC_TryTyping(n->ebinary.right, result); + } break; + + case LC_ASTKind_ExprIndex: { + LC_Operand LC_PROP_ERROR(opindex, n, LC_ResolveExpr(n->eindex.index)); + LC_Operand LC_PROP_ERROR(opexpr, n, LC_ResolveExpr(n->eindex.base)); + LC_IF(!LC_IsInt(opindex.type), n, "indexing with non integer value of type '%s'", LC_GenLCType(opindex.type)); + if (LC_IsUTStr(opexpr.type)) LC_TryDefaultTyping(n->eindex.base, &opexpr); + LC_IF(!LC_IsPtr(opexpr.type) && !LC_IsArray(opexpr.type), n, "trying to index non indexable type '%s'", LC_GenLCType(opexpr.type)); + LC_IF(LC_IsVoidPtr(opexpr.type), n, "void is non indexable"); + LC_TryDefaultTyping(n->eindex.index, &opindex); + result.type = LC_GetBase(opexpr.type); + result.flags |= LC_OPF_LValue; + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, result.type)); + } break; + + case LC_ASTKind_ExprGetPointerOfValue: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveExpr(n->eunary.expr)); + LC_IF(!LC_IsLValue(op), n, "trying to access address of a temporal object"); + result.type = LC_CreatePointerType(op.type); + result.flags |= (op.flags & LC_OPF_Const); + } break; + + case LC_ASTKind_ExprGetValueOfPointer: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveExpr(n->eunary.expr)); + LC_IF(!LC_IsPtr(op.type), n, "trying to get value of non pointer type: '%s'", LC_GenLCType(op.type)); + result.type = LC_GetBase(op.type); + result.flags |= LC_OPF_LValue; + result.flags &= ~LC_OPF_Const; + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, result.type)); + } break; + + case LC_ASTKind_ExprField: { + bool first_part_executed = false; + + LC_Operand op = {0}; + if (n->efield.left->kind == LC_ASTKind_ExprIdent) { + LC_AST *nf = n->efield.left; + LC_Operand LC_PROP_ERROR(op_name, nf, LC_ResolveName(nf, nf->eident.name)); + + // LC_Match (Package.) and fold (Package.Other) into just (Other) + if (op_name.decl->kind == LC_DeclKind_Import) { + first_part_executed = true; + nf->eident.resolved_decl = op_name.decl; + nf->type = L->tvoid; + + LC_PROP_ERROR(op, n, LC_ResolveNameInScope(n, op_name.decl)); + } + } + + if (!first_part_executed) { + LC_ASTKind left_kind = n->efield.left->kind; + LC_PROP_ERROR(op, n, LC_ResolveExpr(n->efield.left)); + + LC_Type *type = LC_StripPointer(op.type); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, type)); + LC_IF(!LC_IsAggType(type), n->efield.left, "invalid operation, expected aggregate type, '%s' is not an aggregate", LC_GenLCType(type)); + LC_PROP_ERROR(op, n, LC_ResolveNameInScope(n, type->decl)); + LC_ASSERT(n, op.decl->kind == LC_DeclKind_Var); + result.flags |= LC_OPF_LValue | LC_OPF_Const; + } + result.val = op.decl->val; + } break; + + case LC_ASTKind_ExprCall: { + LC_ASSERT(n, n->ecompo.name); + LC_PROP_ERROR(result, n, LC_ResolveBuiltin(n)); + if (!result.type) { + LC_Operand LC_PROP_ERROR(left, n, LC_ResolveExpr(n->ecompo.name)); + LC_IF(!LC_IsProc(left.type), n, "trying to call value of invalid type '%s', not a procedure", LC_GenLCType(left.type)); + if (L->before_call_args_resolved) L->before_call_args_resolved(n, left.type); + LC_PROP_ERROR(result, n, LC_ResolveCompoCall(n, left.type)); + } + } break; + + case LC_ASTKind_ExprCompound: { + LC_Type *type = NULL; + if (n->ecompo.name) { + LC_PUSH_COMP_ARRAY_SIZE(n->ecompo.size); + LC_Operand LC_PROP_ERROR(left, n, LC_ResolveTypeOrExpr(n->ecompo.name)); + type = left.type; + LC_POP_COMP_ARRAY_SIZE(); + } + if (!n->ecompo.name) type = L->resolver.compo_context_type; + LC_IF(!type, n, "failed to deduce type of compound expression"); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, type)); + + if (LC_IsAggType(type)) { + LC_PROP_ERROR(result, n, LC_ResolveCompoAggregate(n, type)); + } else if (LC_IsArray(type)) { + LC_PROP_ERROR(result, n, LC_ResolveCompoArray(n, type)); + } else { + LC_IF(1, n, "compound of type '%s' is illegal, expected array, struct or union type", LC_GenLCType(type)); + } + } break; + + default: LC_IF(1, n, "internal compiler error: unhandled expression kind '%s'", LC_ASTKindToString(n->kind)); + } + + n->type = result.type; + if (n->type != L->tany && L->resolver.compo_context_type == L->tany) { + LC_MapInsertP(&L->implicit_any, n, (void *)(intptr_t)1); + result.flags &= ~LC_OPF_Const; + } + + if (L->on_expr_resolved) L->on_expr_resolved(n, &result); + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveStmtBlock(LC_AST *n) { + LC_ASSERT(n, n->kind == LC_ASTKind_StmtBlock); + + LC_PUSH_LOCAL_SCOPE(); + LC_PushAST(&L->resolver.stmt_block_stack, n); + + LC_Operand result = {0}; + for (LC_AST *it = n->sblock.first; it; it = it->next) { + LC_Operand op = LC_ResolveStmt(it); + + // We don't want to whine about non returned procedures if we spotted any errors + // inside of it. + if (LC_IsError(op) || (op.flags & LC_OPF_Returned)) result.flags |= LC_OPF_Returned; + } + + LC_PopAST(&L->resolver.stmt_block_stack); + LC_POP_LOCAL_SCOPE(); + + if (L->on_stmt_resolved) L->on_stmt_resolved(n); + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveVarDecl(LC_Decl *decl) { + LC_ASSERT(decl->ast, decl->kind == LC_DeclKind_Var); + LC_Operand result = {0}; + result.flags |= LC_OPF_Const; + + LC_AST *n = decl->ast; + LC_Operand optype = {0}; + LC_Operand opexpr = {0}; + + LC_AST *expr = n->dvar.expr; + LC_AST *type = n->dvar.type; + if (n->kind == LC_ASTKind_StmtVar) { + expr = n->svar.expr; + type = n->svar.type; + } else { + LC_ASSERT(n, n->kind == LC_ASTKind_DeclVar); + } + + // special case := #c(``) + if (expr && expr->kind == LC_ASTKind_ExprNote) { + LC_Operand LC_PROP_ERROR(opnote, expr, LC_ResolveNote(expr, true)); + LC_IF(type == NULL, n, "invalid usage of unknown type, need to add type annotation"); + LC_DECL_PROP_ERROR(optype, LC_ResolveType(type)); + decl->type = optype.type; + } else { + if (type) { + if (expr && expr->kind == LC_ASTKind_ExprCompound) { + LC_PUSH_COMP_ARRAY_SIZE(expr->ecompo.size); + LC_DECL_PROP_ERROR(optype, LC_ResolveType(type)); + LC_POP_COMP_ARRAY_SIZE(); + } else { + LC_DECL_PROP_ERROR(optype, LC_ResolveType(type)); + } + } + if (expr) { + LC_DECL_PROP_ERROR(opexpr, LC_ResolveExprAndPushCompoContext(expr, optype.type)); + if (!(opexpr.flags & LC_OPF_Const)) result.flags &= ~LC_OPF_Const; + } + + LC_Operand LC_DECL_PROP_ERROR(opcast, LC_ResolveTypeVarDecl(n, optype, opexpr)); + if (expr) LC_TryTyping(expr, opcast); + decl->val = opcast.val; + } + + LC_ASSERT(n, decl->type); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, decl->type)); + result.type = decl->type; + return result; +} + +LC_FUNCTION LC_Operand LC_MakeSureNoDeferBlock(LC_AST *n, char *str) { + for (int i = L->resolver.stmt_block_stack.len - 1; i >= 0; i -= 1) { + LC_AST *it = L->resolver.stmt_block_stack.data[i]; + if (it->kind == LC_ASTKind_Error) return LC_OPError(); + LC_ASSERT(it, it->kind == LC_ASTKind_StmtBlock); + LC_IF(it->sblock.kind == SBLK_Defer, n, str); + } + return LC_OPNull; +} + +LC_FUNCTION LC_Operand LC_MakeSureInsideLoopBlock(LC_AST *n, char *str) { + bool loop_found = false; + for (int i = L->resolver.stmt_block_stack.len - 1; i >= 0; i -= 1) { + LC_AST *it = L->resolver.stmt_block_stack.data[i]; + if (it->kind == LC_ASTKind_Error) return LC_OPError(); + LC_ASSERT(it, it->kind == LC_ASTKind_StmtBlock); + if (it->sblock.kind == SBLK_Loop) { + loop_found = true; + break; + } + } + LC_IF(!loop_found, n, str); + return LC_OPNull; +} + +LC_FUNCTION LC_Operand LC_MatchLabeledBlock(LC_AST *n) { + if (n->sbreak.name) { + bool found = false; + for (int i = L->resolver.stmt_block_stack.len - 1; i >= 0; i -= 1) { + LC_AST *it = L->resolver.stmt_block_stack.data[i]; + if (it->kind == LC_ASTKind_Error) return LC_OPError(); + if (it->sblock.name == n->sbreak.name) { + found = true; + break; + } + } + LC_IF(!found, n, "no label with name '%s'", n->sbreak.name); + } + return LC_OPNull; +} + +LC_FUNCTION void WalkToFindCall(LC_ASTWalker *w, LC_AST *n) { + if (n->kind == LC_ASTKind_ExprCall || n->kind == LC_ASTKind_ExprBuiltin) ((bool *)w->user_data)[0] = true; +} + +LC_FUNCTION bool LC_ContainsCallExpr(LC_AST *ast) { + LC_TempArena checkpoint = LC_BeginTemp(L->arena); + bool found_call = false; + { + LC_ASTWalker walker = LC_GetDefaultWalker(L->arena, WalkToFindCall); + walker.depth_first = false; + walker.user_data = (void *)&found_call; + LC_WalkAST(&walker, ast); + } + LC_EndTemp(checkpoint); + return found_call; +} + +LC_FUNCTION LC_Operand LC_ResolveStmt(LC_AST *n) { + LC_ASSERT(n, LC_IsStmt(n)); + + LC_Operand result = {0}; + switch (n->kind) { + case LC_ASTKind_StmtVar: { + LC_Operand LC_PROP_ERROR(opdecl, n, LC_CreateLocalDecl(LC_DeclKind_Var, n->svar.name, n)); + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveVarDecl(opdecl.decl)); + opdecl.decl->state = LC_DeclState_Resolved; + n->svar.resolved_decl = opdecl.decl; + n->type = op.type; + } break; + + case LC_ASTKind_StmtConst: { + LC_Operand LC_PROP_ERROR(opdecl, n, LC_CreateLocalDecl(LC_DeclKind_Const, n->sconst.name, n)); + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveConstDecl(opdecl.decl)); + opdecl.decl->state = LC_DeclState_Resolved; + n->type = op.type; + } break; + + case LC_ASTKind_StmtAssign: { + LC_Operand LC_PROP_ERROR(left, n, LC_ResolveExpr(n->sassign.left)); + LC_IF(!LC_IsLValue(left), n, "assigning value to a temporal object (lvalue)"); + LC_Type *type = left.type; + + LC_OPResult valid = LC_IsAssignValidForType(n->sassign.op, type); + LC_IF(valid == LC_OPResult_Error, n, "invalid assignment operation '%s' for type '%s'", LC_TokenKindToString(n->sassign.op), LC_GenLCType(type)); + + LC_Operand LC_PROP_ERROR(right, n, LC_ResolveExprAndPushCompoContext(n->sassign.right, type)); + LC_PROP_ERROR(result, n, LC_ResolveTypeVarDecl(n, left, right)); + LC_TryTyping(n->sassign.left, result); + LC_TryTyping(n->sassign.right, result); + n->type = result.type; + } break; + + case LC_ASTKind_StmtExpr: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveExpr(n->sexpr.expr)); + LC_TryDefaultTyping(n->sexpr.expr, &op); + n->type = op.type; + bool contains_call = LC_ContainsCallExpr(n->sexpr.expr); + LC_AST *note = LC_HasNote(n, L->iunused); + LC_IF(!note && !contains_call, n, "very likely a bug, expression statement doesn't contain any calls so it doesn't do anything"); + } break; + + case LC_ASTKind_StmtReturn: { + LC_PROP_ERROR(result, n, LC_MakeSureNoDeferBlock(n, "returning from defer block is illegal")); + LC_Operand op = LC_OPType(L->tvoid); + if (n->sreturn.expr) { + LC_PROP_ERROR(op, n, LC_ResolveExprAndPushCompoContext(n->sreturn.expr, L->resolver.expected_ret_type)); + } + + if (!(op.type == L->resolver.expected_ret_type && op.type == L->tvoid)) { + LC_PROP_ERROR(op, n, LC_ResolveTypeVarDecl(n, LC_OPType(L->resolver.expected_ret_type), op)); + if (n->sreturn.expr) LC_TryTyping(n->sreturn.expr, op); + } + result.flags |= LC_OPF_Returned; + } break; + + case LC_ASTKind_StmtNote: LC_PROP_ERROR(result, n, LC_ResolveNote(n, false)); break; + case LC_ASTKind_StmtContinue: + LC_PROP_ERROR(result, n, LC_MakeSureNoDeferBlock(n, "continue inside of defer is illegal")); + LC_PROP_ERROR(result, n, LC_MakeSureInsideLoopBlock(n, "continue outside of a for loop is illegal")); + case LC_ASTKind_StmtBreak: { + LC_PROP_ERROR(result, n, LC_MakeSureNoDeferBlock(n, "break inside of defer is illegal")); + LC_PROP_ERROR(result, n, LC_MakeSureInsideLoopBlock(n, "break outside of a for loop is illegal")); + LC_PROP_ERROR(result, n, LC_MatchLabeledBlock(n)); + } break; + + case LC_ASTKind_StmtDefer: { + LC_PROP_ERROR(result, n, LC_MakeSureNoDeferBlock(n, "defer inside of defer is illegal")); + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveStmtBlock(n->sdefer.body)); + LC_AST *parent_block = LC_GetLastAST(&L->resolver.stmt_block_stack); + LC_ASSERT(n, parent_block->kind == LC_ASTKind_StmtBlock); + LC_SLLStackAddMod(parent_block->sblock.first_defer, n, sdefer.next); + } break; + + case LC_ASTKind_StmtSwitch: { + LC_Operand LC_PROP_ERROR(opfirst, n, LC_ResolveExpr(n->sswitch.expr)); + LC_IF(!LC_IsInt(opfirst.type), n, "invalid type in switch condition '%s', it should be an integer", LC_GenLCType(opfirst.type)); + LC_TryDefaultTyping(n->sswitch.expr, &opfirst); + + bool all_returned = true; + bool has_default = n->sswitch.last && n->sswitch.last->kind == LC_ASTKind_StmtSwitchDefault; + + LC_Operand *ops = LC_PushArray(L->arena, LC_Operand, n->sswitch.total_switch_case_count); + int opi = 0; + LC_ASTFor(case_it, n->sswitch.first) { + if (case_it->kind == LC_ASTKind_StmtSwitchCase) { + LC_ASTFor(case_expr_it, case_it->scase.first) { + LC_Operand LC_PROP_ERROR(opcase, n, LC_ResolveExpr(case_expr_it)); + LC_IF(!LC_IsUTConst(opcase), case_expr_it, "expected an untyped constant"); + ops[opi++] = opcase; + + LC_Operand LC_PROP_ERROR(o, n, LC_ResolveTypeVarDecl(case_expr_it, opfirst, opcase)); + LC_TryTyping(case_expr_it, o); + } + } + LC_Operand LC_PROP_ERROR(opbody, case_it, LC_ResolveStmtBlock(case_it->scase.body)); + if (!(opbody.flags & LC_OPF_Returned)) all_returned = false; + } + LC_ASSERT(n, opi == n->sswitch.total_switch_case_count); + + for (int i = 0; i < opi; i += 1) { + LC_Operand a = ops[i]; + for (int j = 0; j < opi; j += 1) { + if (i == j) continue; + LC_Operand b = ops[j]; + + // bounds check error is thrown in LC_ResolveTypeVarDecl + if (LC_BigIntFits(a.v.i, opfirst.type) && LC_BigIntFits(b.v.i, opfirst.type)) { + uint64_t au = LC_Bigint_as_unsigned(&a.v.i); + uint64_t bu = LC_Bigint_as_unsigned(&b.v.i); + LC_IF(au == bu, n, "duplicate fields, with value: %llu, in a switch statement", au); + } + } + } + + if (all_returned && has_default) result.flags |= LC_OPF_Returned; + } break; + + case LC_ASTKind_StmtFor: { + LC_StmtFor *sfor = &n->sfor; + LC_PUSH_LOCAL_SCOPE(); + + if (sfor->init) { + LC_Operand opinit = LC_ResolveStmt(sfor->init); + if (LC_IsError(opinit)) { + n->kind = LC_ASTKind_Error; + LC_POP_LOCAL_SCOPE(); + return opinit; + } + + LC_TryDefaultTyping(sfor->init, &opinit); + } + if (sfor->cond) { + LC_Operand opcond = LC_ResolveExpr(sfor->cond); + if (LC_IsError(opcond)) { + n->kind = LC_ASTKind_Error; + LC_POP_LOCAL_SCOPE(); + return opcond; + } + + LC_TryDefaultTyping(sfor->cond, &opcond); + if (!LC_IsIntLike(opcond.type)) { + n->kind = LC_ASTKind_Error; + LC_POP_LOCAL_SCOPE(); + return LC_ReportASTError(n, "invalid type in for condition '%s', it should be an integer or pointer", LC_GenLCType(opcond.type)); + } + } + if (sfor->inc) { + LC_Operand opinc = LC_ResolveStmt(sfor->inc); + if (LC_IsError(opinc)) { + n->kind = LC_ASTKind_Error; + LC_POP_LOCAL_SCOPE(); + return opinc; + } + } + result = LC_ResolveStmtBlock(sfor->body); + if (LC_IsError(result)) { + n->kind = LC_ASTKind_Error; + LC_POP_LOCAL_SCOPE(); + return result; + } + + LC_POP_LOCAL_SCOPE(); + } break; + + case LC_ASTKind_StmtBlock: { + // we don't handle errors here explicitly + LC_Operand op = LC_ResolveStmtBlock(n); + if (op.flags & LC_OPF_Returned) result.flags |= LC_OPF_Returned; + } break; + + case LC_ASTKind_StmtIf: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveExpr(n->sif.expr)); + LC_TryDefaultTyping(n->sif.expr, &op); + LC_IF(!LC_IsIntLike(op.type), n, "invalid type in if clause expression %s it should be an integer or pointer", LC_GenLCType(op.type)); + + bool all_returned = true; + bool has_else = n->sif.last && n->sif.last->kind == LC_ASTKind_StmtElse; + + LC_Operand LC_PROP_ERROR(opbody, n, LC_ResolveStmtBlock(n->sif.body)); + if (!(opbody.flags & LC_OPF_Returned)) all_returned = false; + + LC_ASTFor(it, n->sif.first) { + if (it->kind == LC_ASTKind_StmtElseIf) { + LC_Operand LC_PROP_ERROR(op, it, LC_ResolveExpr(it->sif.expr)); + LC_TryDefaultTyping(it->sif.expr, &op); + LC_IF(!LC_IsIntLike(op.type), n, "invalid type in if clause expression %s it should be an integer or pointer", LC_GenLCType(op.type)); + } + LC_Operand LC_PROP_ERROR(opbody, it, LC_ResolveStmtBlock(it->sif.body)); + if (!(opbody.flags & LC_OPF_Returned)) all_returned = false; + } + + if (all_returned && has_else) result.flags |= LC_OPF_Returned; + } break; + default: LC_IF(1, n, "internal compiler error: unhandled statement kind '%s'", LC_ASTKindToString(n->kind)); + } + + if (L->on_stmt_resolved) L->on_stmt_resolved(n); + return result; +} + +LC_FUNCTION LC_Operand LC_ResolveConstDecl(LC_Decl *decl) { + LC_ASSERT(decl->ast, decl->kind == LC_DeclKind_Const); + LC_AST *n = decl->ast; + LC_AST *expr = n->dconst.expr; + if (n->kind == LC_ASTKind_StmtConst) { + expr = n->sconst.expr; + } else { + LC_ASSERT(n, n->kind == LC_ASTKind_DeclConst); + } + + LC_Operand LC_DECL_PROP_ERROR(opexpr, LC_ResolveExpr(expr)); + LC_DECL_IF(!LC_IsUTConst(opexpr), n, "expected an untyped constant"); + LC_DECL_IF(!LC_IsUntyped(opexpr.type), n, "type of constant expression is not a simple type"); + decl->val = opexpr.val; + return opexpr; +} + +LC_FUNCTION LC_Operand LC_ResolveName(LC_AST *pos, LC_Intern intern) { + LC_Decl *decl = LC_GetLocalOrGlobalDecl(intern); + LC_DECL_IF(!decl, pos, "undeclared identifier '%s'", intern); + LC_DECL_IF(decl->state == LC_DeclState_Resolving, pos, "cyclic dependency %s", intern); + if (decl->state == LC_DeclState_Error) return LC_OPError(); + if (decl->state == LC_DeclState_Resolved || decl->state == LC_DeclState_ResolvedBody) return LC_OPDecl(decl); + LC_ASSERT(pos, decl->state == LC_DeclState_Unresolved); + decl->state = LC_DeclState_Resolving; + + LC_AST *n = decl->ast; + switch (decl->kind) { + case LC_DeclKind_Const: { + LC_Operand LC_DECL_PROP_ERROR(op, LC_ResolveConstDecl(decl)); + } break; + case LC_DeclKind_Var: { + LC_Operand LC_DECL_PROP_ERROR(op, LC_ResolveVarDecl(decl)); + LC_DECL_IF(!(op.flags & LC_OPF_Const), n, "non constant global declarations are illegal"); + } break; + case LC_DeclKind_Proc: { + LC_Operand LC_DECL_PROP_ERROR(optype, LC_ResolveType(n->dproc.type)); + decl->type = optype.type; + decl->type->decl = decl; + } break; + case LC_DeclKind_Import: { + LC_ASSERT(n, decl->scope); + } break; + case LC_DeclKind_Type: { + LC_ASSERT(n, n->kind == LC_ASTKind_DeclTypedef); + LC_Operand LC_DECL_PROP_ERROR(op, LC_ResolveType(n->dtypedef.type)); + decl->val = op.val; + + // I have decided that aggregates cannot be hard typedefed. + // It brings issues to LC_ResolveTypeAggregate and is not needed, what's needed + // is typedef on numbers and pointers that create distinct new + // types. I have never had a use for typedefing a struct to make + // it more typesafe etc. + LC_AST *is_weak = LC_HasNote(n, L->iweak); + bool is_agg = op.type->decl && LC_IsAgg(op.type->decl->ast); + if (!is_weak && !is_agg) decl->type = LC_CreateTypedef(decl, decl->type); + LC_DECL_IF(is_weak && is_agg, n, "@weak doesn't work on aggregate types"); + } break; + default: LC_DECL_IF(1, n, "internal compiler error: unhandled LC_DeclKind: '%s'", LC_DeclKindToString(decl->kind)) + } + decl->state = LC_DeclState_Resolved; + + if (L->on_decl_type_resolved) L->on_decl_type_resolved(decl); + LC_AST *pkg = decl->package; + LC_DLLAdd(pkg->apackage.first_ordered, pkg->apackage.last_ordered, decl); + return LC_OPDecl(decl); +} + +LC_FUNCTION LC_Operand LC_ResolveConstInt(LC_AST *n, LC_Type *int_type, uint64_t *out_size) { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveExpr(n)); + LC_IF(!LC_IsUTConst(op), n, "expected a constant untyped int"); + LC_IF(!LC_IsUTInt(op.type), n, "expected untyped int constant instead: '%s'", LC_GenLCType(op.type)); + LC_IF(!LC_BigIntFits(op.val.i, int_type), n, "constant value: '%s', doesn't fit in type '%s'", LC_GenLCTypeVal(op.val), LC_GenLCType(int_type)); + if (out_size) *out_size = LC_Bigint_as_unsigned(&op.val.i); + LC_TryTyping(n, LC_OPType(int_type)); + return op; +} + +LC_FUNCTION LC_Operand LC_ResolveType(LC_AST *n) { + LC_ASSERT(n, LC_IsType(n)); + LC_Operand result = {0}; + + switch (n->kind) { + case LC_ASTKind_TypespecField: { + LC_ASSERT(n, n->efield.left->kind == LC_ASTKind_TypespecIdent); + LC_Operand LC_PROP_ERROR(l, n, LC_ResolveName(n, n->efield.left->eident.name)); + LC_IF(l.decl->kind != LC_DeclKind_Import, n, "only accessing '.' imports in type definitions is valid, you are trying to access: '%s'", LC_DeclKindToString(l.decl->kind)); + n->efield.left->eident.resolved_decl = l.decl; + n->efield.left->type = L->tvoid; + + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveNameInScope(n, l.decl)); + LC_IF(op.decl->kind != LC_DeclKind_Type, n, "expected reference to type, instead it's: '%s'", LC_DeclKindToString(op.decl->kind)); + result.type = op.decl->type; + } break; + + case LC_ASTKind_TypespecIdent: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveName(n, n->eident.name)); + LC_IF(op.decl->kind != LC_DeclKind_Type, n, "identifier is not a type"); + result.type = op.decl->type; + n->eident.resolved_decl = op.decl; + } break; + + case LC_ASTKind_TypespecPointer: { + LC_Operand LC_PROP_ERROR(op, n, LC_ResolveType(n->tpointer.base)); + result.type = LC_CreatePointerType(op.type); + } break; + + case LC_ASTKind_TypespecArray: { + LC_Operand LC_PROP_ERROR(opbase, n, LC_ResolveType(n->tarray.base)); + uint64_t size = L->resolver.compo_context_array_size; + if (n->tarray.index) { + LC_Operand LC_PROP_ERROR(opindex, n, LC_ResolveConstInt(n->tarray.index, L->tint, &size)); + } + LC_IF(size == 0, n, "failed to deduce array size"); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, opbase.type)); + + result.type = LC_CreateArrayType(opbase.type, (int)size); + } break; + + case LC_ASTKind_TypespecProc: { + LC_Type *ret = L->tvoid; + if (n->tproc.ret) { + LC_Operand LC_PROP_ERROR(op, n->tproc.ret, LC_ResolveType(n->tproc.ret)); + ret = op.type; + } + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(n, ret)); + LC_TypeMemberList typelist = {0}; + LC_ASTFor(it, n->tproc.first) { + LC_Operand LC_PROP_ERROR(op, it, LC_ResolveType(it->tproc_arg.type)); + LC_Operand LC_PROP_ERROR(maybe_err, n, LC_ResolveTypeAggregate(it, op.type)); + + LC_AST *expr = it->tproc_arg.expr; + if (expr) { + LC_Operand LC_PROP_ERROR(opexpr, expr, LC_ResolveExprAndPushCompoContext(expr, op.type)); + LC_Operand LC_PROP_ERROR(opfin, expr, LC_ResolveTypeVarDecl(expr, op, opexpr)); + LC_TryTyping(expr, opfin); + } + + LC_TypeMember *mem = LC_AddTypeToList(&typelist, it->tproc_arg.name, op.type, it); + LC_IF(!mem, it, "duplicate proc argument '%s'", it->tproc_arg.name); + mem->default_value_expr = expr; + it->type = op.type; + } + + LC_TypeFor(i, typelist.first) { + LC_TypeFor(j, typelist.first) { + LC_IF(i != j && i->name == j->name, i->ast, "procedure has 2 arguments with the same name"); + } + } + result.type = LC_CreateProcType(typelist, ret, n->tproc.vargs, n->tproc.vargs_any_promotion); + } break; + + default: LC_IF(1, n, "internal compiler error: unhandled kind in LC_ResolveType '%s'", LC_ASTKindToString(n->kind)); + } + + n->type = result.type; + LC_ASSERT(n, result.type); + return result; +} + +// clang-format off +// NA - Not applicable +// LC_RPS - OK if right side int of pointer size +// LC_LPS +// LC_TEQ - OK if types equal +// LC_RO0 - OK if right value is int equal nil +// LT - Left untyped to typed +// RT +// LF - Left to float +// RF +// LC_SR - String +enum { LC_INT, LC_FLOAT, LC_UT_INT, LC_UT_FLOAT, LC_UT_STR, LC_PTR, LC_VOID_PTR, LC_PROC, LC_AGG, LC_ARRAY, LC_ANY, LC_VOID, LC_TYPE_COUNT }; +typedef enum { LC_NO, LC_OK, LC_LPS, LC_RPS, LC_TEQ, LC_NA, LC_RO0, LC_LT, LC_RT, LC_LF, LC_RF, LC_SR } LC_TypeRule; + +LC_TypeRule CastingRules[LC_TYPE_COUNT][LC_TYPE_COUNT] = { +//\/:tgt( src)> LC_INT , LC_FLOAT , LC_UT_INT , LC_UT_FLOAT , LC_UT_STR , LC_PTR , LC_VOID_PTR , LC_PROC , LC_AGG , LC_ARRAY +/*[LC_INT] = */{LC_OK , LC_OK , LC_OK , LC_OK , LC_NO , LC_LPS , LC_LPS , LC_NO , LC_NO , LC_NO} , +/*[LC_FLOAT] = */{LC_OK , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO} , +/*[LC_UT_INT] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NO , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA} , +/*[LC_UT_FLOAT] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NO , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA} , +/*[LC_UT_STR] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NO , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA} , +/*[LC_PTR] = */{LC_RPS , LC_NO , LC_OK , LC_NO , LC_SR , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO} , +/*[LC_VOID_PTR] = */{LC_RPS , LC_NO , LC_OK , LC_NO , LC_OK , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO} , +/*[LC_PROC] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO} , +/*[LC_AGG] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_SR , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO} , +/*[LC_ARRAY] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO} , +}; + +LC_TypeRule AssignRules[LC_TYPE_COUNT][LC_TYPE_COUNT] = { +//\/l r> LC_INT , LC_FLOAT , LC_UT_INT , LC_UT_FLOAT , LC_UT_STR , LC_PTR , LC_VOID_PTR , LC_PROC , LC_AGG , LC_ARRAY , LC_ANY +/*[LC_INT] = */{LC_TEQ , LC_NO , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO} , +/*[LC_FLOAT] = */{LC_NO , LC_TEQ , LC_OK , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO} , +/*[LC_UT_INT] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NO} , +/*[LC_UT_FLOAT] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NO} , +/*[LC_UT_STR] = */{LC_NA , LC_NA , LC_NA , LC_NA , LC_NA , LC_NO , LC_NA , LC_NA , LC_NA , LC_NA , LC_NO} , +/*[LC_PTR] = */{LC_NO , LC_NO , LC_RO0 , LC_NO , LC_SR , LC_TEQ , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO} , +/*[LC_VOID_PTR] = */{LC_NO , LC_NO , LC_RO0 , LC_NO , LC_OK , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO , LC_NO} , +/*[LC_PROC] = */{LC_NO , LC_NO , LC_RO0 , LC_NO , LC_NO , LC_NO , LC_OK , LC_TEQ , LC_NO , LC_NO , LC_NO} , +/*[LC_AGG] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_SR , LC_NO , LC_NO , LC_NO , LC_TEQ , LC_NO , LC_TEQ} , +/*[LC_ARRAY] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_TEQ , LC_NO} , +/*[LC_ANY] = */{LC_OK , LC_OK , LC_OK , LC_OK , LC_OK , LC_OK , LC_NO , LC_OK , LC_OK , LC_OK , LC_OK} , +}; + +LC_TypeRule BinaryRules[LC_TYPE_COUNT][LC_TYPE_COUNT] = { +//\/l r> LC_INT , LC_FLOAT , LC_UT_INT , LC_UT_FLOAT , LC_UT_STR , LC_PTR , LC_VOID_PTR , LC_PROC , LC_AGG , LC_ARRAY +/*[LC_INT] = */{LC_TEQ , LC_NO , LC_RT , LC_NO , LC_NO , LC_NO , LC_OK , LC_OK , LC_NO , LC_NO , } , +/*[LC_FLOAT] = */{LC_NO , LC_TEQ , LC_RT , LC_RT , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +/*[LC_UT_INT] = */{LC_LT , LC_LT , LC_OK , LC_LF , LC_NO , LC_OK , LC_OK , LC_OK , LC_NO , LC_NO , } , +/*[LC_UT_FLOAT]= */{LC_NO , LC_LT , LC_RF , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +/*[LC_UT_STR] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +/*[LC_PTR] = */{LC_OK , LC_NO , LC_OK , LC_NO , LC_NO , LC_OK , LC_OK , LC_NO , LC_NO , LC_NO , } , +/*[LC_VOID_PTR]= */{LC_OK , LC_NO , LC_OK , LC_NO , LC_NO , LC_OK , LC_OK , LC_NO , LC_NO , LC_NO , } , +/*[LC_PROC] = */{LC_OK , LC_NO , LC_OK , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +/*[LC_AGG] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +/*[LC_ARRAY] = */{LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , LC_NO , } , +}; +// clang-format on + +int GetTypeCategory(LC_Type *x) { + if (x->kind >= LC_TypeKind_char && x->kind <= LC_TypeKind_ullong) return LC_INT; + if ((x->kind == LC_TypeKind_float) || (x->kind == LC_TypeKind_double)) return LC_FLOAT; + if (x->kind == LC_TypeKind_UntypedInt) return LC_UT_INT; + if (x->kind == LC_TypeKind_UntypedFloat) return LC_UT_FLOAT; + if (x->kind == LC_TypeKind_UntypedString) return LC_UT_STR; + if (x == L->tpvoid) return LC_VOID_PTR; + if (x == L->tany) return LC_ANY; + if (x->kind == LC_TypeKind_Pointer) return LC_PTR; + if (x->kind == LC_TypeKind_Proc) return LC_PROC; + if (LC_IsAggType(x)) return LC_AGG; + if (LC_IsArray(x)) return LC_ARRAY; + return LC_VOID; +} + +LC_FUNCTION LC_Operand LC_ResolveBinaryExpr(LC_AST *n, LC_Operand l, LC_Operand r) { + bool isconst = LC_IsConst(l) && LC_IsConst(r); + + LC_TypeRule rule = BinaryRules[GetTypeCategory(l.type)][GetTypeCategory(r.type)]; + LC_IF(rule == LC_NO, n, "cannot perform binary operation, types don't qualify for it, left: '%s' right: '%s'", LC_GenLCType(l.type), LC_GenLCType(r.type)); + LC_IF(rule == LC_TEQ && l.type != r.type, n, "cannot perform binary operation, types are incompatible, left: '%s' right: '%s'", LC_GenLCType(l.type), LC_GenLCType(r.type)); + if (rule == LC_LT) l = LC_OPModType(l, r.type); + if (rule == LC_RT) r = LC_OPModType(r, l.type); + if (rule == LC_LF) l = LC_ConstCastFloat(n, l); + if (rule == LC_RF) r = LC_ConstCastFloat(n, r); + LC_ASSERT(n, rule == LC_LT || rule == LC_RT || rule == LC_LF || rule == LC_RF || rule == LC_OK || rule == LC_TEQ); + + // WARNING: if we allow for more then boolean operations on pointers then + // we need to fix the propagated type here, we are counting on it getting + // modified to bool. + LC_Operand op = LC_OPType(l.type); + if (isconst) op.flags |= LC_OPF_Const; + if (LC_IsUTConst(l) && LC_IsUTConst(r)) { + LC_PROP_ERROR(op, n, LC_EvalBinary(n, l, n->ebinary.op, r)); + SetConstVal(n, op.val); + } else { + LC_OPResult r = LC_IsBinaryExprValidForType(n->ebinary.op, op.type); + LC_IF(r == LC_OPResult_Error, n, "invalid binary operation for type '%s'", LC_GenLCType(op.type)); + (LC_TryTyping(n->ebinary.left, op), LC_TryTyping(n->ebinary.right, op)); + if (r == LC_OPResult_Bool) op = LC_OPModBool(op); + } + + return op; +} + +LC_FUNCTION LC_Operand LC_ResolveTypeVargs(LC_AST *pos, LC_Operand v) { + if (LC_IsUntyped(v.type)) v = LC_OPModDefaultUT(v); // untyped => typed + if (LC_IsSmallerThenInt(v.type)) v = LC_OPModType(v, L->tint); // c int promotion + if (v.type == L->tfloat) v = LC_OPModType(v, L->tdouble); // c int promotion + return v; +} + +LC_FUNCTION LC_Operand LC_ResolveTypeCast(LC_AST *pos, LC_Operand t, LC_Operand v) { + LC_TypeRule rule = CastingRules[GetTypeCategory(t.type)][GetTypeCategory(v.type)]; + LC_IF(rule == LC_NO, pos, "cannot cast, types are incompatible, left: '%s' right: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_RPS && v.type->size != L->tpvoid->size, pos, "cannot cast, integer type on right is not big enough to hold a pointer, left: '%s' right: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_LPS && t.type->size != L->tpvoid->size, pos, "cannot cast, integer type on left is not big enough to hold a pointer, left: '%s' right: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_SR && !LC_IsStr(t.type), pos, "cannot cast untyped string to non string type: '%s'", LC_GenLCType(t.type)); + LC_ASSERT(pos, rule == LC_LPS || rule == LC_RPS || rule == LC_OK); + + LC_Operand op = LC_OPType(t.type); + op.flags = (v.flags & LC_OPF_LValue) | (v.flags & LC_OPF_Const); + return op; +} + +LC_FUNCTION LC_Operand LC_ResolveTypeVarDecl(LC_AST *pos, LC_Operand t, LC_Operand v) { + t.v = v.v; + LC_IF(t.type && t.type->kind == LC_TypeKind_void, pos, "cannot create a variable of type void"); + LC_IF(v.type && v.type->kind == LC_TypeKind_void, pos, "cannot assign void expression to a variable"); + if (v.type && t.type) { + LC_TypeRule rule = AssignRules[GetTypeCategory(t.type)][GetTypeCategory(v.type)]; + LC_IF(rule == LC_NO, pos, "cannot assign, types are incompatible, variable type: '%s' expression type: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_RPS && v.type->size != L->tpvoid->size, pos, "cannot assign, integer type of expression is not big enough to hold a pointer, left: '%s' right: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_LPS && t.type->size != L->tpvoid->size, pos, "cannot assign, integer type of variable is not big enough to hold a pointer, left: '%s' right: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_TEQ && t.type != v.type, pos, "cannot assign, types require explicit cast, variable type: '%s' expression type: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_RO0 && v.type != L->tuntypednil, pos, "cannot assign, can assign only const integer equal to 0, variable type: '%s' expression type: '%s'", LC_GenLCType(t.type), LC_GenLCType(v.type)); + LC_IF(rule == LC_SR && !LC_IsStr(t.type), pos, "cannot assign untyped string to non string type: '%s'", LC_GenLCType(t.type)); + LC_ASSERT(pos, rule == LC_LPS || rule == LC_RPS || rule == LC_OK || rule == LC_TEQ || rule == LC_RO0 || rule == LC_SR); + return t; + } + + if (v.type) return LC_OPModDefaultUT(v); // NULL := untyped => default + if (t.type) return t; // T := NULL => T + return LC_ReportASTError(pos, "internal compiler error: failed to resolve type of variable, both type and expression are null"); +} + +LC_FUNCTION LC_Operand LC_ResolveTypeAggregate(LC_AST *pos, LC_Type *type) { + LC_Decl *decl = type->decl; + if (type->kind == LC_TypeKind_Error) return LC_OPError(); + LC_TYPE_IF(type->kind == LC_TypeKind_Completing, pos, "cyclic dependency in type '%s'", type->decl->name); + if (type->kind != LC_TypeKind_Incomplete) return LC_OPNull; + LC_PUSH_SCOPE(L->resolver.package->apackage.scope); + + LC_AST *n = decl->ast; + LC_ASSERT(n, decl); + LC_ASSERT(n, n->kind == LC_ASTKind_DeclStruct || n->kind == LC_ASTKind_DeclUnion); + int decl_stack_size = 0; + + type->kind = LC_TypeKind_Completing; + LC_ASTFor(it, n->dagg.first) { + LC_Intern name = it->tagg_mem.name; + + LC_Operand op = LC_ResolveType(it->tagg_mem.type); + if (LC_IsError(op)) { + LC_MarkDeclError(decl); + type->kind = LC_TypeKind_Error; + continue; // handle error after we go through all fields + } + + LC_Operand opc = LC_ResolveTypeAggregate(it, op.type); + if (LC_IsError(opc)) { + LC_MarkDeclError(decl); + type->kind = LC_TypeKind_Error; + continue; // handle error after we go through all fields + } + + LC_TypeMember *mem = LC_AddTypeToList(&type->tagg.mems, name, op.type, it); + LC_TYPE_IF(mem == NULL, it, "duplicate field '%s' in aggregate type '%s'", name, decl->name); + } + if (type->kind == LC_TypeKind_Error) { + return LC_OPError(); + } + LC_TYPE_IF(type->tagg.mems.count == 0, n, "aggregate type '%s' has no fields", decl->name); + decl_stack_size += type->tagg.mems.count; + + LC_AST *packed = LC_HasNote(n, L->ipacked); + if (n->kind == LC_ASTKind_DeclStruct) { + type->kind = LC_TypeKind_Struct; + int field_sizes = 0; + LC_TypeFor(it, type->tagg.mems.first) { + int mem_align = packed ? 1 : it->type->align; + LC_ASSERT(n, LC_IS_POW2(mem_align)); + type->size = (int)LC_AlignUp(type->size, mem_align); + it->offset = type->size; + field_sizes += it->type->size; + type->align = LC_MAX(type->align, mem_align); + type->size = it->type->size + (int)LC_AlignUp(type->size, mem_align); + } + type->size = (int)LC_AlignUp(type->size, type->align); + type->padding = type->size - field_sizes; + } + + if (n->kind == LC_ASTKind_DeclUnion) { + type->kind = LC_TypeKind_Union; + if (packed) LC_ReportASTError(packed, "@packed on union is invalid"); + LC_TypeFor(it, type->tagg.mems.first) { + LC_ASSERT(n, LC_IS_POW2(it->type->align)); + type->size = LC_MAX(type->size, it->type->size); + type->align = LC_MAX(type->align, it->type->align); + } + type->size = (int)LC_AlignUp(type->size, type->align); + } + + int map_size = LC_NextPow2(decl_stack_size * 2 + 1); + decl->scope = LC_CreateScope(map_size); + + LC_TypeFor(it, type->tagg.mems.first) { + LC_Decl *d = LC_CreateDecl(LC_DeclKind_Var, it->name, it->ast); + d->state = LC_DeclState_Resolved; + d->type = it->type; + d->type_member = it; + LC_AddDeclToScope(decl->scope, d); + } + + LC_ASSERT(n, decl->scope->cap == map_size); + + if (L->on_decl_type_resolved) L->on_decl_type_resolved(decl); + LC_AST *pkg = decl->package; + LC_DLLAdd(pkg->apackage.first_ordered, pkg->apackage.last_ordered, decl); + LC_POP_SCOPE(); + return LC_OPNull; +} + +#undef LC_IF +#undef LC_DECL_IF +#undef LC_PROP_ERROR +#undef LC_DECL_PROP_ERROR +const int ParseStmtBlock_AllowSingleStmt = 1; + +LC_FUNCTION LC_Parser LC_MakeParser(LC_Lex *x) { + LC_Parser p = {0}; + p.at = x->tokens; + p.begin = x->tokens; + p.end = x->tokens + x->token_count; + p.x = x; + return p; +} + +LC_FUNCTION LC_Parser *LC_MakeParserQuick(char *str) { + LC_Lex *x = LC_LexStream("quick_lex", str, 0); + LC_InternTokens(x); + + L->quick_parser = LC_MakeParser(x); + L->parser = &L->quick_parser; + return L->parser; +} + +LC_FUNCTION LC_AST *LC_ReportParseError(LC_Token *pos, const char *str, ...) { + LC_FORMAT(L->arena, str, n); + LC_SendErrorMessage(pos, n); + L->errors += 1; + LC_AST *r = LC_CreateAST(pos, LC_ASTKind_Error); + return r; +} + +LC_FUNCTION LC_Token *LC_Next(void) { + if (L->parser->at < L->parser->end) { + LC_Token *result = L->parser->at; + L->parser->at += 1; + return result; + } + return &L->NullToken; +} + +LC_FUNCTION LC_Token *LC_Get(void) { + if (L->parser->at < L->parser->end) { + return L->parser->at; + } + return &L->NullToken; +} + +LC_FUNCTION LC_Token *LC_GetI(int i) { + LC_Token *result = L->parser->at + i; + if (result >= L->parser->begin && result < L->parser->end) { + return result; + } + return &L->NullToken; +} + +LC_FUNCTION LC_Token *LC_Is(LC_TokenKind kind) { + LC_Token *t = LC_Get(); + if (t->kind == kind) { + return t; + } + return 0; +} + +LC_FUNCTION LC_Token *LC_IsKeyword(LC_Intern intern) { + LC_Token *t = LC_Get(); + if (t->kind == LC_TokenKind_Keyword && t->ident == intern) { + return t; + } + return 0; +} + +LC_FUNCTION LC_Token *LC_Match(LC_TokenKind kind) { + LC_Token *t = LC_Get(); + if (t->kind == kind) { + LC_Next(); + return t; + } + return 0; +} + +LC_FUNCTION LC_Token *LC_MatchKeyword(LC_Intern intern) { + LC_Token *t = LC_Get(); + if (t->kind == LC_TokenKind_Keyword && t->ident == intern) { + LC_Next(); + return t; + } + return 0; +} + +#define LC_EXPECT(token, KIND, context) \ + LC_Token *token = LC_Match(KIND); \ + if (!token) { \ + LC_Token *t = LC_Get(); \ + return LC_ReportParseError(t, "expected %s got instead %s, this happened while parsing: %s", LC_TokenKindToString(KIND), LC_TokenKindToString(t->kind), context); \ + } + +#define LC_PROP_ERROR(expr, ...) \ + expr = __VA_ARGS__; \ + do { \ + if (expr->kind == LC_ASTKind_Error) { \ + return expr; \ + } \ + } while (0) + +// Pratt expression parser +// Based on this really good article: https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html +// clang-format off +LC_FUNCTION LC_BindingPower LC_MakeBP(int left, int right) { + LC_BindingPower result = {left, right}; + return result; +} + +LC_FUNCTION LC_BindingPower LC_GetBindingPower(LC_Binding binding, LC_TokenKind kind) { + if (binding == LC_Binding_Prefix) goto Prefix; + if (binding == LC_Binding_Infix) goto Infix; + if (binding == LC_Binding_Postfix) goto Postfix; + LC_ASSERT(NULL, !"invalid codepath"); + +Prefix: + switch (kind) { + case LC_TokenKind_OpenBracket: return LC_MakeBP(-2, 22); + case LC_TokenKind_Mul: case LC_TokenKind_BitAnd: case LC_TokenKind_Keyword: case LC_TokenKind_OpenParen: + case LC_TokenKind_Sub: case LC_TokenKind_Add: case LC_TokenKind_Neg: case LC_TokenKind_Not: case LC_TokenKind_OpenBrace: return LC_MakeBP(-2, 20); + default: return LC_MakeBP(-1, -1); + } +Infix: + switch (kind) { + case LC_TokenKind_Or: return LC_MakeBP(9, 10); + case LC_TokenKind_And: return LC_MakeBP(11, 12); + case LC_TokenKind_Equals: case LC_TokenKind_NotEquals: case LC_TokenKind_GreaterThen: + case LC_TokenKind_GreaterThenEq: case LC_TokenKind_LesserThen: case LC_TokenKind_LesserThenEq: return LC_MakeBP(13, 14); + case LC_TokenKind_Sub: case LC_TokenKind_Add: case LC_TokenKind_BitOr: case LC_TokenKind_BitXor: return LC_MakeBP(15, 16); + case LC_TokenKind_RightShift: case LC_TokenKind_LeftShift: case LC_TokenKind_BitAnd: + case LC_TokenKind_Mul: case LC_TokenKind_Div: case LC_TokenKind_Mod: return LC_MakeBP(17, 18); + default: return LC_MakeBP(0, 0); + } +Postfix: + switch (kind) { + case LC_TokenKind_Dot: case LC_TokenKind_OpenBracket: case LC_TokenKind_OpenParen: return LC_MakeBP(21, -2); + default: return LC_MakeBP(-1, -1); + } +} + +LC_FUNCTION LC_AST *LC_ParseExprEx(int min_bp) { + LC_AST *left = NULL; + LC_Token *prev = LC_GetI(-1); + LC_Token *t = LC_Next(); + LC_BindingPower prefixbp = LC_GetBindingPower(LC_Binding_Prefix, t->kind); + + // parse prefix expression + switch (t->kind) { + case LC_TokenKind_RawString: + case LC_TokenKind_String: { left = LC_CreateAST(t, LC_ASTKind_ExprString); left->eatom.name = t->ident; } break; + case LC_TokenKind_Ident: { left = LC_CreateAST(t, LC_ASTKind_ExprIdent); left->eident.name = t->ident; } break; + case LC_TokenKind_Int: { left = LC_CreateAST(t, LC_ASTKind_ExprInt); left->eatom.i = t->i; } break; + case LC_TokenKind_Float: { left = LC_CreateAST(t, LC_ASTKind_ExprFloat); left->eatom.d = t->f64; } break; + case LC_TokenKind_Unicode: { left = LC_CreateAST(t, LC_ASTKind_ExprInt); left->eatom.i = t->i; } break; + + case LC_TokenKind_Keyword: { + if (t->ident == L->kfalse) { + left = LC_CreateAST(t, LC_ASTKind_ExprBool); + LC_Bigint_init_signed(&left->eatom.i, false); + } else if (t->ident == L->ktrue) { + left = LC_CreateAST(t, LC_ASTKind_ExprBool); + LC_Bigint_init_signed(&left->eatom.i, true); + } else { + return LC_ReportParseError(t, "got unexpected keyword '%s' while parsing expression", t->ident); + } + } break; + + case LC_TokenKind_AddPtr: { + LC_EXPECT(open_paren, LC_TokenKind_OpenParen, "addptr"); + LC_AST *LC_PROP_ERROR(ptr, LC_ParseExprEx(0)); + LC_EXPECT(comma, LC_TokenKind_Comma, "addptr"); + LC_AST *LC_PROP_ERROR(offset, LC_ParseExprEx(0)); + LC_EXPECT(close_paren, LC_TokenKind_CloseParen, "addptr"); + left = LC_CreateBinary(t, ptr, offset, LC_TokenKind_EOF); + left->kind = LC_ASTKind_ExprAddPtr; + } break; + + case LC_TokenKind_Colon: { + left = LC_CreateAST(t, LC_ASTKind_ExprType); + LC_PROP_ERROR(left->etype.type, LC_ParseType()); + + LC_Token *open = LC_Get(); + if (LC_Match(LC_TokenKind_OpenBrace)) { + left = LC_ParseCompo(open, left); + if (left->kind == LC_ASTKind_Error) { + L->parser->at = t; + return left; + } + } else if (LC_Match(LC_TokenKind_OpenParen)) { + LC_AST *type = left; + left = LC_CreateAST(open, LC_ASTKind_ExprCast); + left->ecast.type = type->etype.type; + type->kind = LC_ASTKind_Ignore; + + LC_PROP_ERROR(left->ecast.expr, LC_ParseExpr()); + LC_EXPECT(close_paren, LC_TokenKind_CloseParen, "cast expression"); + } + } break; + + case LC_TokenKind_OpenBrace: { + left = LC_ParseCompo(t, left); + if (left->kind == LC_ASTKind_Error) { + L->parser->at = prev; + return left; + } + } break; + + case LC_TokenKind_Not: case LC_TokenKind_Neg: case LC_TokenKind_Add: case LC_TokenKind_Sub: { + LC_AST *LC_PROP_ERROR(expr, LC_ParseExprEx(prefixbp.right)); + left = LC_CreateUnary(t, t->kind, expr); + } break; + + case LC_TokenKind_BitAnd: { + LC_AST *LC_PROP_ERROR(expr, LC_ParseExprEx(prefixbp.right)); + left = LC_CreateUnary(t, t->kind, expr); + left->kind = LC_ASTKind_ExprGetPointerOfValue; + } break; + + case LC_TokenKind_Mul: { + LC_AST *LC_PROP_ERROR(expr, LC_ParseExprEx(prefixbp.right)); + left = LC_CreateUnary(t, t->kind, expr); + left->kind = LC_ASTKind_ExprGetValueOfPointer; + } break; + + case LC_TokenKind_OpenParen: { + LC_AST *LC_PROP_ERROR(expr, LC_ParseExprEx(0)); + left = expr; + LC_EXPECT(_c, LC_TokenKind_CloseParen, "expression"); + } break; + + default: return LC_ReportParseError(prev, "got invalid token: %s, while parsing expression", LC_TokenKindToString(t->kind)); + } + + for (;;) { + t = LC_Get(); + + // lets say [+] is left:1, right:2 and we parse 2+3+4 + // We pass min_bp of 2 to the next recursion + // in recursion we check if left(1) > min_bp(2) + // it's not so we don't recurse - we break + // We do the for loop instead + + LC_BindingPower postfix_bp = LC_GetBindingPower(LC_Binding_Postfix, t->kind); + LC_BindingPower infix_bp = LC_GetBindingPower(LC_Binding_Infix, t->kind); + + // parse postfix expression + if (postfix_bp.left > min_bp) { + LC_Next(); + switch (t->kind) { + case LC_TokenKind_OpenBracket: { + LC_AST *LC_PROP_ERROR(index, LC_ParseExprEx(0)); + LC_EXPECT(close_bracket, LC_TokenKind_CloseBracket, "index expression"); + left = LC_CreateIndex(t, left, index); + } break; + case LC_TokenKind_OpenParen: { + LC_PROP_ERROR(left, LC_ParseCompo(t, left)); + } break; + case LC_TokenKind_Dot: { + LC_EXPECT(ident, LC_TokenKind_Ident, "field access expression"); + LC_AST *field = LC_CreateAST(t, LC_ASTKind_ExprField); + field->efield.left = left; + field->efield.right = ident->ident; + left = field; + } break; + default: {} + } + } + + // parse infix expression + else if (infix_bp.left > min_bp) { + t = LC_Next(); + LC_AST *LC_PROP_ERROR(right, LC_ParseExprEx(infix_bp.right)); + left = LC_CreateBinary(t, left, right, t->kind); + } + + else break; + } + + if (L->on_expr_parsed) L->on_expr_parsed(left); + return left; +} +// clang-format on + +LC_FUNCTION LC_AST *LC_ParseCompo(LC_Token *pos, LC_AST *left) { + if (pos->kind != LC_TokenKind_OpenBrace && pos->kind != LC_TokenKind_OpenParen) { + return LC_ReportParseError(pos, "internal compiler error: expected open brace or open paren in %s", __FUNCTION__); + } + + LC_ASTKind kind = pos->kind == LC_TokenKind_OpenBrace ? LC_ASTKind_ExprCompound : LC_ASTKind_ExprCall; + LC_TokenKind close_kind = pos->kind == LC_TokenKind_OpenBrace ? LC_TokenKind_CloseBrace : LC_TokenKind_CloseParen; + LC_ASTKind item_kind = pos->kind == LC_TokenKind_OpenBrace ? LC_ASTKind_ExprCompoundItem : LC_ASTKind_ExprCallItem; + + LC_AST *n = LC_CreateAST(pos, kind); + n->ecompo.name = left; + + while (!LC_Is(close_kind)) { + LC_Token *vpos = LC_Get(); + LC_AST *v = LC_CreateAST(vpos, item_kind); + + if (LC_Match(LC_TokenKind_OpenBracket)) { + if (kind == LC_ASTKind_ExprCall) return LC_ReportParseError(vpos, "procedure calls cant have indexed arguments"); + LC_PROP_ERROR(v->ecompo_item.index, LC_ParseExpr()); + LC_EXPECT(close_bracket, LC_TokenKind_CloseBracket, "compo expression"); + LC_EXPECT(assign, LC_TokenKind_Assign, "compo expression"); + LC_PROP_ERROR(v->ecompo_item.expr, LC_ParseExpr()); + } else { + LC_PROP_ERROR(v->ecompo_item.expr, LC_ParseExpr()); + if (LC_Match(LC_TokenKind_Assign)) { + LC_AST *e = v->ecompo_item.expr; + if (e->kind != LC_ASTKind_ExprIdent) return LC_ReportParseError(LC_GetI(-1), "named argument is required to be an identifier"); + LC_PROP_ERROR(v->ecompo_item.expr, LC_ParseExpr()); + v->ecompo_item.name = e->eident.name; + e->kind = LC_ASTKind_Ignore; // :FreeAST + } + } + + n->ecompo.size += 1; + LC_DLLAdd(n->ecompo.first, n->ecompo.last, v); + if (!LC_Match(LC_TokenKind_Comma)) break; + } + LC_EXPECT(close_token, close_kind, "compo expression"); + return n; +} + +LC_FUNCTION LC_AST *LC_ParseExpr(void) { + return LC_ParseExprEx(0); +} + +LC_FUNCTION LC_AST *LC_ParseProcType(LC_Token *pos) { + LC_AST *n = LC_CreateAST(pos, LC_ASTKind_TypespecProc); + LC_EXPECT(open_paren, LC_TokenKind_OpenParen, "procedure typespec"); + if (!LC_Match(LC_TokenKind_CloseParen)) { + for (;;) { + if (LC_Match(LC_TokenKind_ThreeDots)) { + n->tproc.vargs = true; + + LC_Token *any = LC_Get(); + if (any->kind == LC_TokenKind_Ident && any->ident == L->iAny) { + n->tproc.vargs_any_promotion = true; + LC_Next(); + } + break; + } + LC_EXPECT(ident, LC_TokenKind_Ident, "procedure typespec argument list"); + LC_AST *v = LC_CreateAST(ident, LC_ASTKind_TypespecProcArg); + v->tproc_arg.name = ident->ident; + + LC_EXPECT(colon, LC_TokenKind_Colon, "procedure typespec argument list"); + LC_PROP_ERROR(v->tproc_arg.type, LC_ParseType()); + + if (LC_Match(LC_TokenKind_Assign)) { + LC_PROP_ERROR(v->tproc_arg.expr, LC_ParseExpr()); + } + + v->notes = LC_ParseNotes(); + LC_DLLAdd(n->tproc.first, n->tproc.last, v); + + if (!LC_Match(LC_TokenKind_Comma)) break; + } + LC_EXPECT(close_paren, LC_TokenKind_CloseParen, "procedure typespec argument list"); + } + if (LC_Match(LC_TokenKind_Colon)) { + LC_PROP_ERROR(n->tproc.ret, LC_ParseType()); + } + return n; +} + +LC_FUNCTION LC_AST *LC_ParseType(void) { + LC_AST *n = NULL; + LC_Token *t = LC_Next(); + if (t->kind == LC_TokenKind_Ident) { + n = LC_CreateAST(t, LC_ASTKind_TypespecIdent); + n->eident.name = t->ident; + LC_Token *dot = LC_Match(LC_TokenKind_Dot); + if (dot) { + LC_AST *field = LC_CreateAST(t, LC_ASTKind_TypespecField); + field->efield.left = n; + LC_EXPECT(ident, LC_TokenKind_Ident, "field access typespec"); + field->efield.right = ident->ident; + return field; + } + } else if (t->kind == LC_TokenKind_Mul) { + n = LC_CreateAST(t, LC_ASTKind_TypespecPointer); + LC_PROP_ERROR(n->tpointer.base, LC_ParseType()); + } else if (t->kind == LC_TokenKind_OpenBracket) { + n = LC_CreateAST(t, LC_ASTKind_TypespecArray); + if (!LC_Match(LC_TokenKind_CloseBracket)) { + LC_PROP_ERROR(n->tarray.index, LC_ParseExpr()); + LC_EXPECT(close_bracket, LC_TokenKind_CloseBracket, "array typespec"); + } + LC_PROP_ERROR(n->tarray.base, LC_ParseType()); + } else if (t->kind == LC_TokenKind_Keyword && t->ident == L->kproc) { + LC_PROP_ERROR(n, LC_ParseProcType(t)); + } else { + return LC_ReportParseError(t, "failed to parse typespec, invalid token %s", LC_TokenKindToString(t->kind)); + } + + if (L->on_typespec_parsed) L->on_typespec_parsed(n); + return n; +} + +LC_FUNCTION LC_AST *LC_ParseForStmt(LC_Token *pos) { + LC_AST *n = LC_CreateAST(pos, LC_ASTKind_StmtFor); + + if (LC_Get()->kind != LC_TokenKind_OpenBrace) { + if (!LC_Is(LC_TokenKind_Semicolon)) { + LC_PROP_ERROR(n->sfor.init, LC_ParseStmt(false)); + if (n->sfor.init->kind == LC_ASTKind_StmtExpr) { + n->sfor.cond = n->sfor.init->sexpr.expr; + n->sfor.init->kind = LC_ASTKind_Ignore; // :FreeAST + n->sfor.init = NULL; + goto skip_to_last; + } else if (n->sfor.init->kind != LC_ASTKind_StmtVar && n->sfor.init->kind != LC_ASTKind_StmtAssign) { + return LC_ReportParseError(n->sfor.init->pos, "invalid for loop syntax, expected variable intializer or assignment"); + } + } + + if (LC_Match(LC_TokenKind_Semicolon) && !LC_Is(LC_TokenKind_Semicolon)) { + LC_PROP_ERROR(n->sfor.cond, LC_ParseExpr()); + } + + skip_to_last:; + if (LC_Match(LC_TokenKind_Semicolon)) { + LC_PROP_ERROR(n->sfor.inc, LC_ParseStmt(false)); + if (n->sfor.inc->kind != LC_ASTKind_StmtAssign && n->sfor.inc->kind != LC_ASTKind_StmtExpr) { + return LC_ReportParseError(n->sfor.inc->pos, "invalid for loop syntax, expected assignment or expression"); + } + } + } + + LC_PROP_ERROR(n->sfor.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + n->sfor.body->sblock.kind = SBLK_Loop; + return n; +} + +LC_FUNCTION LC_AST *LC_ParseSwitchStmt(LC_Token *pos) { + LC_AST *n = LC_CreateAST(pos, LC_ASTKind_StmtSwitch); + LC_PROP_ERROR(n->sswitch.expr, LC_ParseExpr()); + LC_EXPECT(open_brace, LC_TokenKind_OpenBrace, "switch statement"); + for (;;) { + LC_Token *pos = LC_Get(); + if (LC_MatchKeyword(L->kcase)) { + LC_AST *v = LC_CreateAST(pos, LC_ASTKind_StmtSwitchCase); + do { + LC_AST *LC_PROP_ERROR(expr, LC_ParseExpr()); + LC_DLLAdd(v->scase.first, v->scase.last, expr); + n->sswitch.total_switch_case_count += 1; + } while (LC_Match(LC_TokenKind_Comma)); + LC_EXPECT(colon, LC_TokenKind_Colon, "switch statement case"); + LC_PROP_ERROR(v->scase.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + v->notes = LC_ParseNotes(); + LC_DLLAdd(n->sswitch.first, n->sswitch.last, v); + } else if (LC_MatchKeyword(L->kdefault)) { + LC_EXPECT(colon, LC_TokenKind_Colon, "switch statement default case"); + LC_AST *v = LC_CreateAST(pos, LC_ASTKind_StmtSwitchDefault); + LC_PROP_ERROR(v->scase.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + LC_EXPECT(close_brace, LC_TokenKind_CloseBrace, "switch statement default case"); + v->notes = LC_ParseNotes(); + LC_DLLAdd(n->sswitch.first, n->sswitch.last, v); + break; + } else { + return LC_ReportParseError(LC_Get(), "invalid token while parsing switch statement"); + } + + if (LC_Match(LC_TokenKind_EOF)) return LC_ReportParseError(pos, "Unclosed '}' switch stmt, reached end of file"); + if (LC_Match(LC_TokenKind_CloseBrace)) break; + } + return n; +} + +LC_FUNCTION LC_AST *LC_ParseStmt(bool check_semicolon) { + LC_AST *n = 0; + LC_Token *pos = LC_Get(); + LC_Token *pos1 = LC_GetI(1); + if (LC_MatchKeyword(L->kreturn)) { + n = LC_CreateAST(pos, LC_ASTKind_StmtReturn); + if (LC_Get()->kind != LC_TokenKind_Semicolon) { + LC_PROP_ERROR(n->sreturn.expr, LC_ParseExpr()); + } + } + + else if (LC_MatchKeyword(L->kbreak)) { + n = LC_CreateAST(pos, LC_ASTKind_StmtBreak); + LC_Token *ident = LC_Match(LC_TokenKind_Ident); + if (ident) n->sbreak.name = ident->ident; + } + + else if (LC_MatchKeyword(L->kcontinue)) { + n = LC_CreateAST(pos, LC_ASTKind_StmtContinue); + LC_Token *ident = LC_Match(LC_TokenKind_Ident); + if (ident) n->scontinue.name = ident->ident; + } + + else if (LC_MatchKeyword(L->kdefer)) { + check_semicolon = false; + n = LC_CreateAST(pos, LC_ASTKind_StmtDefer); + LC_PROP_ERROR(n->sdefer.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + n->sdefer.body->sblock.kind = SBLK_Defer; + } + + else if (LC_MatchKeyword(L->kfor)) { + LC_PROP_ERROR(n, LC_ParseForStmt(pos)); + check_semicolon = false; + } + + else if (LC_MatchKeyword(L->kswitch)) { + LC_PROP_ERROR(n, LC_ParseSwitchStmt(pos)); + check_semicolon = false; + } + + else if (LC_MatchKeyword(L->kif)) { + n = LC_CreateAST(pos, LC_ASTKind_StmtIf); + LC_PROP_ERROR(n->sif.expr, LC_ParseExpr()); + LC_PROP_ERROR(n->sif.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + for (;;) { + if (!LC_MatchKeyword(L->kelse)) break; + + LC_AST *v = LC_CreateAST(LC_GetI(-1), LC_ASTKind_StmtElse); + if (LC_MatchKeyword(L->kif)) { + v->kind = LC_ASTKind_StmtElseIf; + LC_PROP_ERROR(v->sif.expr, LC_ParseExpr()); + } + LC_PROP_ERROR(v->sif.body, LC_ParseStmtBlock(ParseStmtBlock_AllowSingleStmt)); + LC_DLLAdd(n->sif.first, n->sif.last, v); + } + check_semicolon = false; + } + + else if (LC_Match(LC_TokenKind_Hash)) { // #c(``); + n = LC_CreateAST(LC_Get(), LC_ASTKind_StmtNote); + LC_PROP_ERROR(n->snote.expr, LC_ParseNote()); + } else if (pos->kind == LC_TokenKind_OpenBrace) { // { block } + n = LC_ParseStmtBlock(0); + check_semicolon = false; + } + + else if (pos->kind == LC_TokenKind_Ident && pos1->kind == LC_TokenKind_Colon) { // Name: ... + LC_Next(); + LC_Next(); + + if (LC_MatchKeyword(L->kfor)) { + LC_PROP_ERROR(n, LC_ParseForStmt(LC_GetI(-1))); + n->sfor.body->sblock.name = pos->ident; + check_semicolon = false; + } else { + n = LC_CreateAST(pos, LC_ASTKind_StmtVar); + LC_Intern name = pos->ident; + if (LC_Match(LC_TokenKind_Assign)) { + LC_PROP_ERROR(n->svar.expr, LC_ParseExpr()); + n->svar.name = name; + } else if (LC_Match(LC_TokenKind_Colon)) { + n->kind = LC_ASTKind_StmtConst; + LC_PROP_ERROR(n->sconst.expr, LC_ParseExpr()); + n->sconst.name = name; + } else { + n->svar.name = name; + LC_PROP_ERROR(n->svar.type, LC_ParseType()); + if (LC_Match(LC_TokenKind_Assign)) { + if (LC_Match(LC_TokenKind_Hash)) { + LC_AST *note = LC_CreateAST(LC_Get(), LC_ASTKind_ExprNote); + LC_PROP_ERROR(note->enote.expr, LC_ParseNote()); + n->svar.expr = note; + } else { + LC_PROP_ERROR(n->svar.expr, LC_ParseExpr()); + } + } + } + } + } else { + n = LC_CreateAST(pos, LC_ASTKind_StmtExpr); + LC_PROP_ERROR(n->sexpr.expr, LC_ParseExpr()); + + LC_Token *t = LC_Get(); + if (LC_IsAssign(t->kind)) { + LC_Next(); + LC_AST *left = n->sexpr.expr; + + n->kind = LC_ASTKind_StmtAssign; + LC_PROP_ERROR(n->sassign.right, LC_ParseExpr()); + n->sassign.left = left; + n->sassign.op = t->kind; + } + } + + if (check_semicolon) { + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "statement lacks a semicolon at the end"); + } + + n->notes = LC_ParseNotes(); + return n; +} + +LC_FUNCTION LC_AST *LC_ParseStmtBlock(int flags) { + LC_AST *n = LC_CreateAST(LC_Get(), LC_ASTKind_StmtBlock); + + bool single_stmt = false; + if (flags & ParseStmtBlock_AllowSingleStmt) { + if (!LC_Is(LC_TokenKind_OpenBrace)) { + LC_AST *LC_PROP_ERROR(v, LC_ParseStmt(true)); + LC_DLLAdd(n->sblock.first, n->sblock.last, v); + single_stmt = true; + } + } + + if (!single_stmt) { + LC_EXPECT(open_brace, LC_TokenKind_OpenBrace, "statement block"); + if (!LC_Match(LC_TokenKind_CloseBrace)) { + for (;;) { + LC_AST *v = LC_ParseStmt(true); + + // Eat until next statement in case of error + if (v->kind == LC_ASTKind_Error) { + for (;;) { + if (LC_Is(LC_TokenKind_EOF) || LC_Is(LC_TokenKind_OpenBrace) || LC_Match(LC_TokenKind_CloseBrace)) return v; + if (LC_Match(LC_TokenKind_Semicolon)) break; + LC_Next(); + } + } + + if (L->on_stmt_parsed) L->on_stmt_parsed(v); + LC_DLLAdd(n->sblock.first, n->sblock.last, v); + if (LC_Match(LC_TokenKind_EOF)) return LC_ReportParseError(open_brace, "Unclosed '}' stmt list, reached end of file"); + if (LC_Match(LC_TokenKind_CloseBrace)) break; + } + } + } + + if (L->on_stmt_parsed) L->on_stmt_parsed(n); + return n; +} + +LC_FUNCTION LC_AST *LC_ParseProcDecl(LC_Token *name) { + LC_AST *n = LC_CreateAST(name, LC_ASTKind_DeclProc); + n->dbase.name = name->ident; + LC_PROP_ERROR(n->dproc.type, LC_ParseProcType(name)); + + LC_Token *ob = LC_Get(); + if (ob->kind == LC_TokenKind_OpenBrace) { + // Here I added additional error handling which slows down compilation a bit. + // We can for sure deduce where procs end and where they begin because of the syntaxes + // nature - so to avoid any error spills from one procedure to another and I + // seek for the last brace of procedure and set 'end' on parser to 1 after that token. + LC_Token *cb = ob; + LC_Token *last_open_brace = ob; + int pair_counter = 0; + + // Seek for the last '}' close brace of procedure + for (;;) { + LC_Token *d = LC_GetI(3); + if (LC_GetI(0)->kind == LC_TokenKind_Ident && LC_GetI(1)->kind == LC_TokenKind_Colon && LC_GetI(2)->kind == LC_TokenKind_Colon && d->kind == LC_TokenKind_Keyword) { + if (d->ident == L->kproc || d->ident == L->kstruct || d->ident == L->kunion || d->ident == L->ktypedef) { + break; + } + } + + LC_Token *token = LC_Next(); + if (token == &L->NullToken) break; + if (token->kind == LC_TokenKind_OpenBrace) pair_counter += 1; + if (token->kind == LC_TokenKind_OpenBrace) last_open_brace = token; + if (token->kind == LC_TokenKind_CloseBrace) pair_counter -= 1; + if (token->kind == LC_TokenKind_CloseBrace) cb = token; + } + if (pair_counter != 0) return LC_ReportParseError(last_open_brace, "unclosed open brace '{' inside this procedure"); + L->parser->at = ob; + + // Set the parsing boundary to one after the last close brace + LC_Token *save_end = L->parser->end; + L->parser->end = cb + 1; + n->dproc.body = LC_ParseStmtBlock(0); + L->parser->end = save_end; + if (n->dproc.body->kind == LC_ASTKind_Error) return n->dproc.body; + + n->dproc.body->sblock.kind = SBLK_Proc; + } else { + LC_EXPECT(semicolon, LC_TokenKind_Semicolon, "procedure declaration"); + } + + return n; +} + +LC_FUNCTION LC_AST *LC_ParseStruct(LC_ASTKind kind, LC_Token *ident) { + LC_AST *n = LC_CreateAST(ident, kind); + n->dbase.name = ident->ident; + LC_EXPECT(open_brace, LC_TokenKind_OpenBrace, "struct declaration"); + for (;;) { + LC_AST *v = LC_CreateAST(ident, LC_ASTKind_TypespecAggMem); + LC_EXPECT(ident, LC_TokenKind_Ident, "struct member"); + v->tagg_mem.name = ident->ident; + LC_EXPECT(colon, LC_TokenKind_Colon, "struct member"); + LC_PROP_ERROR(v->tagg_mem.type, LC_ParseType()); + LC_EXPECT(semicolon, LC_TokenKind_Semicolon, "struct member"); + + v->notes = LC_ParseNotes(); + LC_DLLAdd(n->dagg.first, n->dagg.last, v); + if (LC_Match(LC_TokenKind_EOF)) return LC_ReportParseError(ident, "Unclosed '}' struct, reached end of file"); + if (LC_Match(LC_TokenKind_CloseBrace)) break; + } + + return n; +} + +LC_FUNCTION LC_AST *LC_ParseTypedef(LC_Token *ident) { + LC_AST *n = LC_CreateAST(ident, LC_ASTKind_DeclTypedef); + n->dbase.name = ident->ident; + LC_PROP_ERROR(n->dtypedef.type, LC_ParseType()); + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected semicolon ';' after typedef declaration, got instead %s", LC_TokenKindToString(LC_GetI(-1)->kind)); + return n; +} + +LC_FUNCTION LC_AST *LC_CreateNote(LC_Token *pos, LC_Intern ident) { + LC_AST *n = LC_CreateAST(pos, LC_ASTKind_Note); + + LC_AST *astident = LC_CreateAST(pos, LC_ASTKind_ExprIdent); + astident->eident.name = ident; + n->ecompo.name = astident; + + return n; +} + +LC_FUNCTION LC_AST *LC_ParseNote(void) { + LC_AST *n = NULL; + + // syntactic sugar + // #`stuff` => #c(`stuff`) + LC_Token *str_token = LC_Match(LC_TokenKind_RawString); + if (str_token) { + n = LC_CreateNote(str_token, L->ic); + + // Add CallItem + { + LC_AST *astcallitem = LC_CreateAST(str_token, LC_ASTKind_ExprCallItem); + astcallitem->ecompo_item.expr = LC_CreateAST(str_token, LC_ASTKind_ExprString); + astcallitem->ecompo_item.expr->eatom.name = str_token->ident; + LC_DLLAdd(n->ecompo.first, n->ecompo.last, astcallitem); + } + } else { + + LC_EXPECT(ident, LC_TokenKind_Ident, "note"); + if (!LC_IsNoteDeclared(ident->ident)) { + LC_ReportParseError(ident, "unregistered note name: '%s'", ident->ident); + } + + LC_AST *astident = LC_CreateAST(ident, LC_ASTKind_ExprIdent); + astident->eident.name = ident->ident; + + LC_Token *open_paren = LC_Match(LC_TokenKind_OpenParen); + if (open_paren) { + n = LC_ParseCompo(open_paren, astident); + } else { + n = LC_CreateAST(ident, LC_ASTKind_Note); + } + n->ecompo.name = astident; + n->kind = LC_ASTKind_Note; + } + return n; +} + +LC_FUNCTION LC_AST *LC_ParseNotes(void) { + LC_Token *pos = LC_Get(); + LC_AST *first = 0; + LC_AST *last = 0; + for (;;) { + LC_Token *t = LC_Match(LC_TokenKind_Note); + if (!t) break; + LC_AST *n = LC_ParseNote(); + if (n->kind == LC_ASTKind_Error) continue; + LC_DLLAdd(first, last, n); + } + + if (first) { + LC_AST *n = LC_CreateAST(pos, LC_ASTKind_NoteList); + n->anote_list.first = first; + n->anote_list.last = last; + return n; + } + return 0; +} + +LC_FUNCTION bool LC_ResolveBuildIf(LC_AST *build_if) { + LC_ExprCompo *note = &build_if->anote; + if (note->size != 1) { + LC_ReportParseError(LC_GetI(-1), "invalid argument count for #build_if directive, expected 1, got %d", note->size); + return true; + } + + LC_ExprCompoItem *item = ¬e->first->ecompo_item; + if (item->index != NULL || item->name != 0) { + LC_ReportParseError(LC_GetI(-1), "invalid syntax, #build_if shouldn't have a named or indexed first argument"); + return true; + } + + LC_PUSH_PACKAGE(L->builtin_package); + LC_Operand op = LC_ResolveExpr(item->expr); + LC_POP_PACKAGE(); + if (!LC_IsUTConst(op)) { + LC_ReportParseError(LC_GetI(-1), "expected #build_if to have an untyped constant expcession"); + return true; + } + if (!LC_IsUTInt(op.type)) { + LC_ReportParseError(LC_GetI(-1), "expected #build_if to have expression of type untyped int"); + return true; + } + + int64_t result = LC_Bigint_as_signed(&op.v.i); + return (bool)result; +} + +LC_FUNCTION LC_AST *LC_ParseDecl(LC_AST *file) { + LC_AST *n = 0; + LC_Token *doc_comment = LC_Match(LC_TokenKind_DocComment); + LC_Token *ident = LC_Get(); + + if (LC_Match(LC_TokenKind_Ident)) { + if (LC_Match(LC_TokenKind_Colon)) { + if (LC_Match(LC_TokenKind_Colon)) { + if (LC_MatchKeyword(L->kproc)) { + LC_PROP_ERROR(n, LC_ParseProcDecl(ident)); + } else if (LC_MatchKeyword(L->kstruct)) { + LC_PROP_ERROR(n, LC_ParseStruct(LC_ASTKind_DeclStruct, ident)); + } else if (LC_MatchKeyword(L->kunion)) { + LC_PROP_ERROR(n, LC_ParseStruct(LC_ASTKind_DeclUnion, ident)); + } else if (LC_MatchKeyword(L->ktypedef)) { + LC_PROP_ERROR(n, LC_ParseTypedef(ident)); + } else { + n = LC_CreateAST(ident, LC_ASTKind_DeclConst); + n->dbase.name = ident->ident; + if (LC_Match(LC_TokenKind_BitXor)) { + LC_AST *last_decl = file->afile.ldecl; + if (!last_decl || last_decl->kind != LC_ASTKind_DeclConst) return LC_ReportParseError(LC_GetI(-1), "invalid usage, there is no constant declaration preceding '^', this operator implies - PREV_CONST + 1"); + LC_AST *left = LC_CreateAST(n->pos, LC_ASTKind_ExprIdent); + left->eident.name = last_decl->dbase.name; + LC_AST *right = LC_CreateAST(n->pos, LC_ASTKind_ExprInt); + right->eatom.i = LC_Bigint_u64(1); + + n->dconst.expr = LC_CreateBinary(n->pos, left, right, LC_TokenKind_Add); + } else if (LC_Match(LC_TokenKind_LeftShift)) { + LC_AST *last_decl = file->afile.ldecl; + if (!last_decl || last_decl->kind != LC_ASTKind_DeclConst) return LC_ReportParseError(LC_GetI(-1), "invalid usage, there is no constant declaration preceding '^', this operator implies - PREV_CONST << 1"); + LC_AST *left = LC_CreateAST(n->pos, LC_ASTKind_ExprIdent); + left->eident.name = last_decl->dbase.name; + LC_AST *right = LC_CreateAST(n->pos, LC_ASTKind_ExprInt); + right->eatom.i = LC_Bigint_u64(1); + + n->dconst.expr = LC_CreateBinary(n->pos, left, right, LC_TokenKind_LeftShift); + } else { + LC_PROP_ERROR(n->dconst.expr, LC_ParseExpr()); + } + + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + } + } else if (LC_Match(LC_TokenKind_Assign)) { + n = LC_CreateAST(ident, LC_ASTKind_DeclVar); + LC_PROP_ERROR(n->dvar.expr, LC_ParseExpr()); + n->dbase.name = ident->ident; + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + } else { + n = LC_CreateAST(ident, LC_ASTKind_DeclVar); + n->dbase.name = ident->ident; + + LC_PROP_ERROR(n->dvar.type, LC_ParseType()); + if (LC_Match(LC_TokenKind_Assign)) { + if (LC_Match(LC_TokenKind_Hash)) { + LC_AST *note = LC_CreateAST(LC_Get(), LC_ASTKind_ExprNote); + LC_PROP_ERROR(note->enote.expr, LC_ParseNote()); + n->dvar.expr = note; + } else { + LC_PROP_ERROR(n->dvar.expr, LC_ParseExpr()); + } + } + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + } + } else return LC_ReportParseError(ident, "got unexpected token: %s, while parsing declaration", LC_TokenKindToString(ident->kind)); + } else if (LC_Match(LC_TokenKind_Hash)) { + n = LC_CreateAST(ident, LC_ASTKind_DeclNote); + LC_PROP_ERROR(n->dnote.expr, LC_ParseNote()); + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + } else if (LC_MatchKeyword(L->kimport)) { + return LC_ReportParseError(LC_Get(), "imports can only appear at the top level"); + } else if (ident->kind == LC_TokenKind_EOF) return NULL; + else return LC_ReportParseError(ident, "got unexpected token: %s, while parsing declaration", LC_TokenKindToString(ident->kind)); + + LC_AST *notes = LC_ParseNotes(); + if (n) { + n->notes = notes; + n->dbase.doc_comment = doc_comment; + } + return n; +} + +LC_FUNCTION bool LC_EatUntilNextValidDecl(void) { + for (;;) { + LC_Token *a = LC_GetI(0); + if (a->kind == LC_TokenKind_Keyword && a->ident == L->kimport) { + return true; + } + + LC_Token *d = LC_GetI(3); + if (a->kind == LC_TokenKind_Ident && LC_GetI(1)->kind == LC_TokenKind_Colon && LC_GetI(2)->kind == LC_TokenKind_Colon && d->kind == LC_TokenKind_Keyword) { + if (d->ident == L->kproc || d->ident == L->kstruct || d->ident == L->kunion || d->ident == L->ktypedef) { + return false; + } + } + + LC_Token *token = LC_Next(); + if (token == &L->NullToken) { + return false; + } + } +} + +LC_FUNCTION bool LC_ParseHashBuildOn(LC_AST *n) { + LC_Token *t0 = LC_GetI(0); + LC_Token *t1 = LC_GetI(1); + if (t0->kind == LC_TokenKind_Hash && t1->kind == LC_TokenKind_Ident && t1->ident == L->ibuild_if) { + LC_Next(); + + LC_AST *build_if = LC_CreateAST(t1, LC_ASTKind_DeclNote); + build_if->dnote.expr = LC_ParseNote(); + if (build_if->dnote.expr->kind == LC_ASTKind_Error) { + LC_EatUntilNextValidDecl(); + return true; + } + + if (!LC_Match(LC_TokenKind_Semicolon)) { + LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + LC_EatUntilNextValidDecl(); + return true; + } + + LC_AST *note_list = LC_CreateAST(t0, LC_ASTKind_NoteList); + LC_DLLAdd(note_list->anote_list.first, note_list->anote_list.last, build_if); + n->notes = note_list; + + return LC_ResolveBuildIf(build_if->dnote.expr); + } + return true; +} + +LC_FUNCTION LC_AST *LC_ParseImport(void) { + LC_AST *n = NULL; + LC_Token *import = LC_MatchKeyword(L->kimport); + if (import) { + n = LC_CreateAST(import, LC_ASTKind_GlobImport); + + LC_Token *ident = LC_Match(LC_TokenKind_Ident); + if (ident) n->gimport.name = ident->ident; + + LC_Token *path = LC_Match(LC_TokenKind_String); + if (!path) return LC_ReportParseError(LC_GetI(-1), "expected string after an import, instead got %s", LC_TokenKindToString(LC_Get()->kind)); + + n->gimport.path = path->ident; + if (!LC_Match(LC_TokenKind_Semicolon)) return LC_ReportParseError(LC_GetI(-1), "expected ';' semicolon"); + } + return n; +} + +LC_FUNCTION void LC_AddFileToPackage(LC_AST *pkg, LC_AST *f) { + f->afile.package = pkg; + LC_DLLAdd(pkg->apackage.ffile, pkg->apackage.lfile, f); +} + +LC_FUNCTION LC_AST *LC_ParseFileEx(LC_AST *package) { + LC_Token *package_doc_comment = LC_Match(LC_TokenKind_PackageDocComment); + + LC_AST *n = LC_CreateAST(LC_Get(), LC_ASTKind_File); + n->afile.x = L->parser->x; + n->afile.doc_comment = LC_Match(LC_TokenKind_FileDocComment); + n->afile.build_if = LC_ParseHashBuildOn(n); + + // Parse imports + while (!LC_Is(LC_TokenKind_EOF)) { + LC_AST *import = LC_ParseImport(); + if (!import) break; + + if (import->kind == LC_ASTKind_Error) { + bool is_import = LC_EatUntilNextValidDecl(); + if (!is_import) break; + } else { + LC_DLLAdd(n->afile.fimport, n->afile.limport, import); + } + } + + // Parse top level decls + while (!LC_Is(LC_TokenKind_EOF)) { + LC_AST *decl = LC_ParseDecl(n); + if (!decl) continue; + + if (decl->kind == LC_ASTKind_Error) { + LC_EatUntilNextValidDecl(); + } else { + bool skip = false; + + LC_AST *build_if = LC_HasNote(decl, L->ibuild_if); + if (build_if) { + skip = !LC_ResolveBuildIf(build_if); + } + + if (L->on_decl_parsed) { + skip = L->on_decl_parsed(skip, decl); + } + + if (skip) { + LC_DLLAdd(n->afile.fdiscarded, n->afile.ldiscarded, decl); + } else { + LC_DLLAdd(n->afile.fdecl, n->afile.ldecl, decl); + } + } + } + + if (package) { + if (package->apackage.doc_comment) LC_ReportParseError(package_doc_comment, "there are more then 1 package doc comments in %s package", (char *)package->apackage.name); + package->apackage.doc_comment = package_doc_comment; + + if (n->afile.build_if) { + LC_AddFileToPackage(package, n); + } else { + LC_DLLAdd(package->apackage.fdiscarded, package->apackage.ldiscarded, n); + n->afile.package = package; + } + } + + return n; +} + +LC_FUNCTION LC_AST *LC_ParseTokens(LC_AST *package, LC_Lex *x) { + LC_Parser p = LC_MakeParser(x); + L->parser = &p; + LC_AST *file = LC_ParseFileEx(package); + return L->errors ? NULL : file; +} + +LC_FUNCTION LC_AST *LC_ParseFile(LC_AST *package, char *filename, char *content, int line) { + if (content == NULL) { + LC_SendErrorMessagef(NULL, NULL, "internal compiler error: file passed to %s is null", __FUNCTION__); + return NULL; + } + if (filename == NULL) { + LC_SendErrorMessagef(NULL, NULL, "internal compiler error: filename passed to %s is null", __FUNCTION__); + return NULL; + } + + LC_Lex *x = LC_LexStream(filename, content, line); + if (L->errors) return NULL; + LC_InternTokens(x); + + LC_AST *file = LC_ParseTokens(package, x); + if (!file) return NULL; + return file; +} + +LC_FUNCTION LC_AST *LC_ParseStmtf(const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + + LC_Parser *old = L->parser; + LC_Parser *p = LC_MakeParserQuick(s8.str); + LC_AST *result = LC_ParseStmt(false); + L->parser = old; + + return result; +} + +LC_FUNCTION LC_AST *LC_ParseExprf(const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + + LC_Parser *old = L->parser; + LC_Parser *p = LC_MakeParserQuick(s8.str); + LC_AST *result = LC_ParseExpr(); + L->parser = old; + + return result; +} + +LC_FUNCTION LC_AST *LC_ParseDeclf(const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + + LC_Parser *old = L->parser; + LC_Parser *p = LC_MakeParserQuick(s8.str); + LC_AST *result = LC_ParseDecl(&L->NullAST); + L->parser = old; + + return result; +} + +#undef LC_EXPECT +#undef LC_PROP_ERROR +LC_FUNCTION LC_StringList *LC_BeginStringGen(LC_Arena *arena) { + L->printer.list = LC_MakeEmptyList(); + L->printer.arena = arena; + L->printer.last_filename = 0; + L->printer.last_line_num = 0; + L->printer.indent = 0; + return &L->printer.list; +} + +LC_FUNCTION LC_String LC_EndStringGen(LC_Arena *arena) { + LC_String result = LC_MergeString(arena, L->printer.list); + return result; +} + +LC_FUNCTION void LC_GenIndent(void) { + LC_String s = LC_Lit(" "); + for (int i = 0; i < L->printer.indent; i++) { + LC_AddNode(L->printer.arena, &L->printer.list, s); + } +} + +LC_FUNCTION char *LC_Strf(const char *str, ...) { + LC_FORMAT(L->arena, str, s8); + return s8.str; +} + +LC_FUNCTION void LC_GenLine(void) { + LC_Genf("\n"); + LC_GenIndent(); +} + +LC_FUNCTION char *LC_GenLCType(LC_Type *type) { + LC_StringList out = {0}; + for (LC_Type *it = type; it;) { + if (it->kind == LC_TypeKind_Pointer) { + LC_Addf(L->arena, &out, "*"); + it = it->tptr.base; + } else if (it->kind == LC_TypeKind_Array) { + LC_Addf(L->arena, &out, "[%d]", it->tarray.size); + it = it->tarray.base; + } else if (it->kind == LC_TypeKind_Proc) { + LC_Addf(L->arena, &out, "proc("); + LC_TypeFor(mem, it->tproc.args.first) { + LC_Addf(L->arena, &out, "%s: %s", (char *)mem->name, LC_GenLCType(mem->type)); + if (mem->default_value_expr) LC_Addf(L->arena, &out, "/*has default value*/"); + if (mem->next) LC_Addf(L->arena, &out, ", "); + } + if (it->tproc.vargs) LC_Addf(L->arena, &out, ".."); + LC_Addf(L->arena, &out, ")"); + if (it->tproc.ret->kind != LC_TypeKind_void) LC_Addf(L->arena, &out, ": %s", LC_GenLCType(it->tproc.ret)); + break; + } else if (it->decl) { + LC_Decl *decl = it->decl; + LC_ASSERT(decl->ast, decl); + LC_Addf(L->arena, &out, "%s", (char *)decl->name); + break; + } else { + LC_SendErrorMessagef(NULL, NULL, "internal compiler error: unhandled type kind in %s", __FUNCTION__); + } + } + LC_String s = LC_MergeString(L->arena, out); + return s.str; +} + +LC_FUNCTION char *LC_GenLCTypeVal(LC_TypeAndVal v) { + if (LC_IsInt(v.type) || LC_IsPtr(v.type) || LC_IsProc(v.type)) { + return LC_Bigint_str(&v.i, 10); + } + if (LC_IsFloat(v.type)) { + LC_String s = LC_Format(L->arena, "%f", v.d); + return s.str; + } + LC_ASSERT(NULL, !"invalid codepath"); + return ""; +} + +LC_FUNCTION char *LC_GenLCAggName(LC_Type *t) { + if (t->kind == LC_TypeKind_Struct) return "struct"; + if (t->kind == LC_TypeKind_Union) return "union"; + return NULL; +} + +LC_FUNCTION void LC_GenLCNode(LC_AST *n) { + switch (n->kind) { + case LC_ASTKind_Package: { + LC_ASTFor(it, n->apackage.ffile) { + LC_GenLCNode(it); + } + } break; + + case LC_ASTKind_File: { + LC_ASTFor(it, n->afile.fimport) { + LC_GenLCNode(it); + } + + LC_ASTFor(it, n->afile.fdecl) { + LC_GenLCNode(it); + } + // @todo: we need to do something with notes so we can generate them in order! + + } break; + + case LC_ASTKind_GlobImport: { + LC_GenLinef("import %s \"%s\";", (char *)n->gimport.name, (char *)n->gimport.path); + } break; + + case LC_ASTKind_DeclProc: { + LC_GenLinef("%s :: ", (char *)n->dbase.name); + LC_GenLCNode(n->dproc.type); + if (n->dproc.body) { + LC_Genf(" "); + LC_GenLCNode(n->dproc.body); + } else { + LC_Genf(";"); + } + } break; + + case LC_ASTKind_DeclUnion: + case LC_ASTKind_DeclStruct: { + const char *agg = n->kind == LC_ASTKind_DeclUnion ? "union" : "struct"; + LC_GenLinef("%s :: %s {", (char *)n->dbase.name, agg); + L->printer.indent += 1; + LC_ASTFor(it, n->dagg.first) { + LC_GenLine(); + LC_GenLCNode(it); + LC_Genf(";"); + } + L->printer.indent -= 1; + LC_GenLinef("}"); + } break; + + case LC_ASTKind_TypespecAggMem: { + LC_Genf("%s: ", (char *)n->tagg_mem.name); + LC_GenLCNode(n->tagg_mem.type); + } break; + + case LC_ASTKind_DeclVar: { + LC_GenLinef("%s ", (char *)n->dbase.name); + if (n->dvar.type) { + LC_Genf(": "); + LC_GenLCNode(n->dvar.type); + if (n->dvar.expr) { + LC_Genf("= "); + LC_GenLCNode(n->dvar.expr); + } + } else { + LC_Genf(":= "); + LC_GenLCNode(n->dvar.expr); + } + LC_Genf(";"); + } break; + + case LC_ASTKind_DeclConst: { + LC_GenLinef("%s :: ", (char *)n->dbase.name); + LC_GenLCNode(n->dconst.expr); + LC_Genf(";"); + } break; + + case LC_ASTKind_DeclTypedef: { + LC_GenLinef("%s :: typedef ", (char *)n->dbase.name); + LC_GenLCNode(n->dtypedef.type); + LC_Genf(";"); + } break; + + case LC_ASTKind_ExprIdent: + case LC_ASTKind_TypespecIdent: { + LC_Genf("%s", (char *)n->eident.name); + } break; + + case LC_ASTKind_ExprField: + case LC_ASTKind_TypespecField: { + LC_GenLCNode(n->efield.left); + LC_Genf(".%s", (char *)n->efield.right); + } break; + + case LC_ASTKind_TypespecPointer: { + LC_Genf("*"); + LC_GenLCNode(n->tpointer.base); + } break; + + case LC_ASTKind_TypespecArray: { + LC_Genf("["); + if (n->tarray.index) LC_GenLCNode(n->tarray.index); + LC_Genf("]"); + LC_GenLCNode(n->tpointer.base); + } break; + + case LC_ASTKind_TypespecProc: { + LC_Genf("proc("); + LC_ASTFor(it, n->tproc.first) { + LC_GenLCNode(it); + if (it != n->tproc.last) LC_Genf(", "); + } + if (n->tproc.vargs) { + LC_Genf(", ..."); + if (n->tproc.vargs_any_promotion) LC_Genf("Any"); + } + LC_Genf(")"); + if (n->tproc.ret) { + LC_Genf(": "); + LC_GenLCNode(n->tproc.ret); + } + } break; + + case LC_ASTKind_TypespecProcArg: { + LC_Genf("%s: ", (char *)n->tproc_arg.name); + LC_GenLCNode(n->tproc_arg.type); + if (n->tproc_arg.expr) { + LC_Genf(" = "); + LC_GenLCNode(n->tproc_arg.expr); + } + } break; + + case LC_ASTKind_StmtBlock: { + if (n->sblock.name && n->sblock.kind != SBLK_Loop) LC_Genf("%s: ", (char *)n->sblock.name); + LC_Genf("{"); + L->printer.indent += 1; + LC_ASTFor(it, n->sblock.first) { + LC_GenLine(); + LC_GenLCNode(it); + if (it->kind != LC_ASTKind_StmtBlock && it->kind != LC_ASTKind_StmtDefer && it->kind != LC_ASTKind_StmtFor && it->kind != LC_ASTKind_StmtIf && it->kind != LC_ASTKind_StmtSwitch) LC_Genf(";"); + } + L->printer.indent -= 1; + LC_GenLinef("}"); + } break; + + case LC_ASTKind_StmtReturn: { + LC_Genf("return"); + if (n->sreturn.expr) { + LC_Genf(" "); + LC_GenLCNode(n->sreturn.expr); + } + } break; + + case LC_ASTKind_StmtBreak: { + LC_Genf("break"); + if (n->sbreak.name) LC_Genf(" %s", (char *)n->sbreak.name); + } break; + + case LC_ASTKind_StmtContinue: { + LC_Genf("continue"); + if (n->scontinue.name) LC_Genf(" %s", (char *)n->scontinue.name); + } break; + + case LC_ASTKind_StmtDefer: { + LC_Genf("defer "); + LC_GenLCNode(n->sdefer.body); + } break; + + case LC_ASTKind_StmtFor: { + LC_StmtBlock *sblock = &n->sfor.body->sblock; + if (sblock->name && sblock->kind == SBLK_Loop) { + LC_Genf("%s: ", (char *)sblock->name); + } + + LC_Genf("for "); + if (n->sfor.init) { + LC_GenLCNode(n->sfor.init); + if (n->sfor.cond) LC_Genf("; "); + } + + if (n->sfor.cond) { + LC_GenLCNode(n->sfor.cond); + if (n->sfor.inc) { + LC_Genf("; "); + LC_GenLCNode(n->sfor.inc); + } + } + + LC_Genf(" "); + LC_GenLCNode(n->sfor.body); + } break; + + case LC_ASTKind_StmtElseIf: + LC_Genf("else "); + case LC_ASTKind_StmtIf: { + LC_Genf("if "); + LC_GenLCNode(n->sif.expr); + LC_GenLCNode(n->sif.body); + LC_ASTFor(it, n->sif.first) { + LC_GenLCNode(it); + } + } break; + + case LC_ASTKind_StmtElse: { + LC_Genf("else "); + LC_GenLCNode(n->sif.body); + } break; + + case LC_ASTKind_StmtSwitch: { + LC_Genf("switch "); + LC_GenLCNode(n->sswitch.expr); + LC_Genf("{"); + L->printer.indent += 1; + LC_ASTFor(it, n->sswitch.first) { + LC_GenLine(); + LC_GenLCNode(it); + } + L->printer.indent -= 1; + LC_Genf("}"); + } break; + + case LC_ASTKind_StmtSwitchCase: { + LC_Genf("case "); + LC_ASTFor(it, n->scase.first) { + LC_GenLCNode(it); + if (it != n->scase.last) LC_Genf(", "); + } + LC_Genf(": "); + LC_GenLCNode(n->scase.body); + } break; + case LC_ASTKind_StmtSwitchDefault: { + LC_Genf("default: "); + LC_GenLCNode(n->scase.body); + } break; + + case LC_ASTKind_StmtAssign: { + LC_GenLCNode(n->sassign.left); + LC_Genf(" %s ", LC_TokenKindToOperator(n->sassign.op)); + LC_GenLCNode(n->sassign.right); + } break; + + case LC_ASTKind_StmtExpr: { + LC_GenLCNode(n->sexpr.expr); + } break; + + case LC_ASTKind_StmtVar: { + LC_Genf("%s", (char *)n->svar.name); + if (n->svar.type) { + LC_Genf(": "); + LC_GenLCNode(n->svar.type); + if (n->svar.expr) { + LC_Genf(" = "); + LC_GenLCNode(n->svar.expr); + } + } else { + LC_Genf(" := "); + LC_GenLCNode(n->svar.expr); + } + } break; + + case LC_ASTKind_StmtConst: { + LC_GenLinef("%s :: ", (char *)n->sconst.name); + LC_GenLCNode(n->sconst.expr); + } break; + + case LC_ASTKind_ExprString: { + LC_Genf("`%s`", (char *)n->eatom.name); + } break; + + case LC_ASTKind_ExprInt: { + LC_Genf("%s", LC_Bigint_str(&n->eatom.i, 10)); + } break; + + case LC_ASTKind_ExprFloat: { + LC_Genf("%f", n->eatom.d); + } break; + + case LC_ASTKind_ExprBool: { + int64_t value = LC_Bigint_as_unsigned(&n->eatom.i); + if (value) { + LC_Genf("true"); + } else { + LC_Genf("false"); + } + } break; + + case LC_ASTKind_ExprType: { + LC_Genf(":"); + LC_GenLCNode(n->etype.type); + } break; + + case LC_ASTKind_ExprBinary: { + LC_Genf("("); + LC_GenLCNode(n->ebinary.left); + LC_Genf("%s", LC_TokenKindToOperator(n->ebinary.op)); + LC_GenLCNode(n->ebinary.right); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprUnary: { + LC_Genf("%s(", LC_TokenKindToOperator(n->eunary.op)); + LC_GenLCNode(n->eunary.expr); + LC_Genf(")"); + } break; + + case LC_ASTKind_StmtNote: { + LC_Genf("#"); + LC_GenLCNode(n->snote.expr); + } break; + + case LC_ASTKind_ExprNote: { + LC_Genf("#"); + LC_GenLCNode(n->enote.expr); + } break; + + case LC_ASTKind_DeclNote: { + LC_GenLinef("#"); + LC_GenLCNode(n->dnote.expr); + LC_Genf(";"); + } break; + + case LC_ASTKind_Note: + case LC_ASTKind_ExprBuiltin: + case LC_ASTKind_ExprCall: { + LC_GenLCNode(n->ecompo.name); + LC_Genf("("); + LC_ASTFor(it, n->ecompo.first) { + LC_GenLCNode(it); + if (it != n->ecompo.last) LC_Genf(", "); + } + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprCompoundItem: + case LC_ASTKind_ExprCallItem: { + if (n->ecompo_item.name) { + LC_Genf("%s = ", (char *)n->ecompo_item.name); + } + if (n->ecompo_item.index) { + LC_Genf("["); + LC_GenLCNode(n->ecompo_item.index); + LC_Genf("] = "); + } + LC_GenLCNode(n->ecompo_item.expr); + } break; + + case LC_ASTKind_ExprCompound: { + if (n->ecompo.name) LC_GenLCNode(n->ecompo.name); + LC_Genf("{"); + LC_ASTFor(it, n->ecompo.first) { + LC_GenLCNode(it); + if (it != n->ecompo.last) LC_Genf(", "); + } + LC_Genf("}"); + } break; + + case LC_ASTKind_ExprCast: { + LC_Genf(":"); + LC_GenLCNode(n->ecast.type); + LC_Genf("("); + LC_GenLCNode(n->ecast.expr); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprIndex: { + LC_Genf("("); + LC_GenLCNode(n->eindex.base); + LC_Genf("["); + LC_GenLCNode(n->eindex.index); + LC_Genf("]"); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprAddPtr: { + LC_Genf("addptr("); + LC_GenLCNode(n->ebinary.left); + LC_Genf(", "); + LC_GenLCNode(n->ebinary.right); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprGetValueOfPointer: { + LC_Genf("*("); + LC_GenLCNode(n->eunary.expr); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprGetPointerOfValue: { + LC_Genf("&("); + LC_GenLCNode(n->eunary.expr); + LC_Genf(")"); + } break; + + default: LC_ReportASTError(n, "internal compiler error: unhandled ast kind in %s", __FUNCTION__); + } +} + +const bool LC_GenCInternalGenerateSizeofs = true; + +LC_FUNCTION void LC_GenCLineDirective(LC_AST *node) { + if (L->emit_line_directives) { + L->printer.last_line_num = node->pos->line; + LC_GenLinef("#line %d", L->printer.last_line_num); + LC_Intern file = node->pos->lex->file; + if (file != L->printer.last_filename) { + L->printer.last_filename = file; + LC_Genf(" \"%s\"", (char *)L->printer.last_filename); + } + } +} + +LC_FUNCTION void LC_GenLastCLineDirective(void) { + if (L->emit_line_directives) { + LC_Genf("#line %d", L->printer.last_line_num); + } +} + +LC_FUNCTION void LC_GenCLineDirectiveNum(int num) { + if (L->emit_line_directives) { + LC_Genf("#line %d", num); + } +} + +LC_FUNCTION char *LC_GenCTypeParen(char *str, char c) { + return c && c != '[' ? LC_Strf("(%s)", str) : str; +} + +LC_FUNCTION char *LC_GenCType(LC_Type *type, char *str) { + switch (type->kind) { + case LC_TypeKind_Pointer: { + return LC_GenCType(type->tptr.base, LC_GenCTypeParen(LC_Strf("*%s", str), *str)); + } break; + case LC_TypeKind_Array: { + if (type->tarray.size == 0) { + return LC_GenCType(type->tarray.base, LC_GenCTypeParen(LC_Strf("%s[]", str), *str)); + } else { + return LC_GenCType(type->tarray.base, LC_GenCTypeParen(LC_Strf("%s[%d]", str, type->tarray.size), *str)); + } + + } break; + case LC_TypeKind_Proc: { + LC_StringList out = {0}; + LC_Addf(L->arena, &out, "(*%s)", str); + LC_Addf(L->arena, &out, "("); + if (type->tagg.mems.count == 0) { + LC_Addf(L->arena, &out, "void"); + } else { + int i = 0; + for (LC_TypeMember *it = type->tproc.args.first; it; it = it->next) { + LC_Addf(L->arena, &out, "%s%s", i == 0 ? "" : ", ", LC_GenCType(it->type, "")); + i += 1; + } + } + if (type->tproc.vargs) { + LC_Addf(L->arena, &out, ", ..."); + } + LC_Addf(L->arena, &out, ")"); + char *front = LC_MergeString(L->arena, out).str; + char *result = LC_GenCType(type->tproc.ret, front); + return result; + } break; + default: return LC_Strf("%s%s%s", type->decl->foreign_name, str[0] ? " " : "", str); + } +} + +LC_FUNCTION LC_Intern LC_GetStringFromSingleArgNote(LC_AST *note) { + LC_ASSERT(note, note->kind == LC_ASTKind_Note); + LC_ASSERT(note, note->ecompo.first == note->ecompo.last); + LC_AST *arg = note->ecompo.first; + LC_ASSERT(note, arg->kind == LC_ASTKind_ExprCallItem); + LC_AST *str = arg->ecompo_item.expr; + LC_ASSERT(note, str->kind == LC_ASTKind_ExprString); + return str->eatom.name; +} + +LC_FUNCTION void LC_GenCCompound(LC_AST *n) { + LC_Type *type = n->type; + if (LC_IsAggType(type)) { + LC_ResolvedCompo *rd = n->ecompo.resolved_items; + LC_Genf("{"); + if (rd->first == NULL) LC_Genf("0"); + for (LC_ResolvedCompoItem *it = rd->first; it; it = it->next) { + LC_Genf(".%s = ", (char *)it->t->name); + LC_GenCExpr(it->expr); + if (it->next) LC_Genf(", "); + } + LC_Genf("}"); + } else if (LC_IsArray(type)) { + LC_ResolvedArrayCompo *rd = n->ecompo.resolved_array_items; + LC_Genf("{"); + for (LC_ResolvedCompoArrayItem *it = rd->first; it; it = it->next) { + LC_Genf("[%d] = ", it->index); + LC_GenCExpr(it->comp->ecompo_item.expr); + if (it->next) LC_Genf(", "); + } + LC_Genf("}"); + } else { + LC_ReportASTError(n, "internal compiler error: got unhandled case in %s", __FUNCTION__); + } +} + +LC_THREAD_LOCAL bool GC_SpecialCase_GlobalScopeStringDecl; + +LC_FUNCTION void LC_GenCString(char *s, LC_Type *type) { + if (type == L->tstring) { + if (!GC_SpecialCase_GlobalScopeStringDecl) LC_Genf("(LC_String)"); + LC_Genf("{ "); + } + LC_Genf("\""); + for (int i = 0; s[i]; i += 1) { + LC_String escape = LC_GetEscapeString(s[i]); + if (escape.len) { + LC_Genf("%.*s", LC_Expand(escape)); + } else { + LC_Genf("%c", s[i]); + } + } + LC_Genf("\""); + if (type == L->tstring) LC_Genf(", %d }", (int)LC_StrLen(s)); +} + +LC_FUNCTION char *LC_GenCVal(LC_TypeAndVal v, LC_Type *type) { + char *str = LC_GenLCTypeVal(v); + switch (type->kind) { + case LC_TypeKind_uchar: + case LC_TypeKind_ushort: + case LC_TypeKind_uint: str = LC_Strf("%su", str); break; + case LC_TypeKind_ulong: str = LC_Strf("%sul", str); break; + case LC_TypeKind_Pointer: + case LC_TypeKind_Proc: + case LC_TypeKind_ullong: str = LC_Strf("%sull", str); break; + case LC_TypeKind_long: str = LC_Strf("%sull", str); break; + case LC_TypeKind_llong: str = LC_Strf("%sull", str); break; + case LC_TypeKind_float: str = LC_Strf("%sf", str); break; + case LC_TypeKind_UntypedFloat: str = LC_Strf(" /*utfloat*/%s", str); break; + case LC_TypeKind_UntypedInt: str = LC_Strf(" /*utint*/%sull", str); break; + default: { + } + } + if (LC_IsUTInt(v.type) && !LC_IsUntyped(type) && type->size < 4) { + str = LC_Strf("(%s)%s", LC_GenCType(type, ""), str); + } + return str; +} + +LC_FUNCTION void LC_GenCExpr(LC_AST *n) { + LC_ASSERT(n, LC_IsExpr(n)); + intptr_t is_any = (intptr_t)LC_MapGetP(&L->implicit_any, n); + if (is_any) LC_Genf("(LC_Any){%d, (%s[]){", n->type->id, LC_GenCType(n->type, "")); + + if (n->const_val.type) { + bool contains_sizeof_like = LC_GenCInternalGenerateSizeofs ? LC_ContainsCBuiltin(n) : false; + if (!contains_sizeof_like) { + if (LC_IsUTStr(n->const_val.type)) { + LC_GenCString((char *)n->const_val.name, n->type); + } else { + char *val = LC_GenCVal(n->const_val, n->type); + LC_Genf("%s", val); + } + if (is_any) LC_Genf("}}"); + return; + } + } + + LC_Type *type = n->type; + switch (n->kind) { + case LC_ASTKind_ExprIdent: { + LC_Genf("%s", (char *)n->eident.resolved_decl->foreign_name); + } break; + + case LC_ASTKind_ExprCast: { + LC_Genf("("); + LC_Genf("(%s)", LC_GenCType(type, "")); + LC_Genf("("); + LC_GenCExpr(n->ecast.expr); + LC_Genf(")"); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprUnary: { + LC_Genf("%s(", LC_TokenKindToOperator(n->eunary.op)); + LC_GenCExpr(n->eunary.expr); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprAddPtr: { + LC_Genf("("); + LC_GenCExpr(n->ebinary.left); + LC_Genf("+"); + LC_GenCExpr(n->ebinary.right); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprBinary: { + LC_Genf("("); + LC_GenCExpr(n->ebinary.left); + LC_Genf("%s", LC_TokenKindToOperator(n->ebinary.op)); + LC_GenCExpr(n->ebinary.right); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprIndex: { + LC_Genf("("); + LC_GenCExpr(n->eindex.base); + LC_Genf("["); + LC_GenCExpr(n->eindex.index); + LC_Genf("]"); + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprGetValueOfPointer: { + LC_Genf("(*("); + LC_GenCExpr(n->eunary.expr); + LC_Genf("))"); + } break; + + case LC_ASTKind_ExprGetPointerOfValue: { + LC_Genf("(&("); + LC_GenCExpr(n->eunary.expr); + LC_Genf("))"); + } break; + + case LC_ASTKind_ExprField: { + if (n->efield.parent_decl->kind != LC_DeclKind_Import) { + LC_Type *left_type = n->efield.left->type; + LC_GenCExpr(n->efield.left); + if (LC_IsPtr(left_type)) LC_Genf("->"); + else LC_Genf("."); + LC_Genf("%s", (char *)n->efield.right); + } else { + LC_Genf("%s", (char *)n->efield.resolved_decl->foreign_name); + } + } break; + + case LC_ASTKind_ExprCall: { + LC_ResolvedCompo *rd = n->ecompo.resolved_items; + LC_GenCExpr(n->ecompo.name); + LC_Genf("("); + for (LC_ResolvedCompoItem *it = rd->first; it; it = it->next) { + LC_GenCExpr(it->expr); + if (it->next) LC_Genf(", "); + } + LC_Genf(")"); + } break; + + case LC_ASTKind_ExprCompound: { + LC_Genf("(%s)", LC_GenCType(type, "")); + LC_GenCCompound(n); + } break; + + case LC_ASTKind_ExprBuiltin: { + LC_ASSERT(n, n->ecompo.name->kind == LC_ASTKind_ExprIdent); + if (n->ecompo.name->eident.name == L->isizeof) { + LC_Genf("sizeof("); + LC_AST *expr = n->ecompo.first->ecompo_item.expr; + if (expr->kind == LC_ASTKind_ExprType) { + LC_Genf("%s", LC_GenCType(expr->type, "")); + } else { + LC_GenCExpr(expr); + } + LC_Genf(")"); + } else if (n->ecompo.name->eident.name == L->ialignof) { + LC_Genf("LC_Alignof("); + LC_AST *expr = n->ecompo.first->ecompo_item.expr; + if (expr->kind == LC_ASTKind_ExprType) { + LC_Genf("%s", LC_GenCType(expr->type, "")); + } else { + LC_GenCExpr(expr); + } + LC_Genf(")"); + } else if (n->ecompo.name->eident.name == L->ioffsetof) { + LC_AST *i1 = n->ecompo.first->ecompo_item.expr; + LC_AST *i2 = n->ecompo.first->next->ecompo_item.expr; + LC_Genf("offsetof(%s, %s)", LC_GenCType(i1->type, ""), (char *)i2->eident.name); + } else { + LC_ReportASTError(n, "internal compiler error: got unhandled case in %s / LC_ASTKind_ExprBuiltin", __FUNCTION__); + } + } break; + + default: LC_ReportASTError(n, "internal compiler error: got unhandled case in %s", __FUNCTION__); + } + + if (is_any) LC_Genf("}}"); +} + +const int GC_Stmt_OmitSemicolonAndNewLine = 1; + +LC_FUNCTION void LC_GenCNote(LC_AST *note) { + if (note->ecompo.name->eident.name == L->ic) { + LC_Genf("%s", (char *)LC_GetStringFromSingleArgNote(note)); + } +} + +LC_FUNCTION void LC_GenCVarExpr(LC_AST *n, bool is_declaration) { + if (LC_HasNote(n, L->inot_init)) return; + + LC_AST *e = n->dvar.expr; + if (n->kind == LC_ASTKind_StmtVar) e = n->svar.expr; + if (e) { + LC_Genf(" = "); + if (e->kind == LC_ASTKind_ExprNote) { + LC_GenCNote(e->enote.expr); + } else if (is_declaration && e->kind == LC_ASTKind_ExprCompound) { + LC_GenCCompound(e); + } else { + LC_GenCExpr(e); + } + } else { + LC_Genf(" = {0}"); + } +} + +LC_FUNCTION void LC_GenCDefers(LC_AST *block) { + LC_AST *first = block->sblock.first_defer; + if (first == NULL) return; + + int save = L->printer.last_line_num; + LC_GenLine(); + LC_GenLastCLineDirective(); + + LC_GenLinef("/*defer*/"); + for (LC_AST *it = first; it; it = it->sdefer.next) { + LC_GenCStmtBlock(it->sdefer.body); + } + + L->printer.last_line_num = save + 1; + LC_GenLine(); + LC_GenLastCLineDirective(); +} + +LC_FUNCTION void LC_GenCDefersLoopBreak(LC_AST *n) { + LC_ASSERT(n, n->kind == LC_ASTKind_StmtBreak || n->kind == LC_ASTKind_StmtContinue); + LC_AST *it = NULL; + for (int i = L->printer.out_block_stack.len - 1; i >= 0; i -= 1) { + it = L->printer.out_block_stack.data[i]; + LC_GenCDefers(it); + LC_ASSERT(it, it->sblock.kind != SBLK_Proc); + if (it->sblock.kind == SBLK_Loop) { + if (!n->sbreak.name) break; + if (n->sbreak.name && it->sblock.name == n->sbreak.name) break; + } + } + LC_ASSERT(it, it->sblock.kind == SBLK_Loop); +} + +LC_FUNCTION void LC_GenCDefersReturn(LC_AST *n) { + LC_ASSERT(n, n->kind == LC_ASTKind_StmtReturn); + LC_AST *it = NULL; + for (int i = L->printer.out_block_stack.len - 1; i >= 0; i -= 1) { + it = L->printer.out_block_stack.data[i]; + LC_GenCDefers(it); + if (it->sblock.kind == SBLK_Proc) { + break; + } + } + LC_ASSERT(it, it); + LC_ASSERT(it, it->sblock.kind == SBLK_Proc); +} + +LC_FUNCTION void LC_GenCStmt2(LC_AST *n, int flags) { + LC_ASSERT(n, LC_IsStmt(n)); + bool semicolon = !(flags & GC_Stmt_OmitSemicolonAndNewLine); + + if (semicolon) { + LC_GenLine(); + } + + switch (n->kind) { + case LC_ASTKind_StmtVar: { + LC_Type *type = n->type; + LC_Genf("%s", LC_GenCType(type, (char *)n->svar.name)); + LC_GenCVarExpr(n, true); + } break; + case LC_ASTKind_StmtExpr: LC_GenCExpr(n->sexpr.expr); break; + + case LC_ASTKind_StmtAssign: { + // Assigning to array doesn't work in C so we need to handle that + // specific compo case here. :CompoArray + if (LC_IsArray(n->type) && n->sassign.right->kind == LC_ASTKind_ExprCompound) { + LC_ASSERT(n, n->sassign.op == LC_TokenKind_Assign); + LC_AST *expr = n->sassign.right; + LC_Genf("memset("); + LC_GenCExpr(n->sassign.left); + LC_Genf(", 0, sizeof("); + LC_GenCExpr(n->sassign.left); + LC_Genf("));"); + + LC_ResolvedArrayCompo *rd = expr->ecompo.resolved_array_items; + for (LC_ResolvedCompoArrayItem *it = rd->first; it; it = it->next) { + LC_GenCExpr(n->sassign.left); + LC_Genf("[%d] = ", it->index); + LC_GenCExpr(it->comp->ecompo_item.expr); + LC_Genf(";"); + } + + } else { + LC_GenCExpr(n->sassign.left); + LC_Genf(" %s ", LC_TokenKindToOperator(n->sassign.op)); + LC_GenCExpr(n->sassign.right); + } + } break; + default: LC_ReportASTError(n, "internal compiler error: got unhandled case in %s", __FUNCTION__); + } + + if (semicolon) LC_Genf(";"); +} + +LC_FUNCTION void LC_GenCStmt(LC_AST *n) { + LC_ASSERT(n, LC_IsStmt(n)); + LC_GenCLineDirective(n); + switch (n->kind) { + case LC_ASTKind_StmtConst: + case LC_ASTKind_StmtDefer: break; + case LC_ASTKind_StmtNote: { + LC_GenLine(); + LC_GenCNote(n->snote.expr); + LC_Genf(";"); + } break; + + case LC_ASTKind_StmtReturn: { + LC_GenCDefersReturn(n); + LC_GenLinef("return"); + if (n->sreturn.expr) { + LC_Genf(" "); + LC_GenCExpr(n->sreturn.expr); + } + LC_Genf(";"); + } break; + + case LC_ASTKind_StmtContinue: + case LC_ASTKind_StmtBreak: { + const char *stmt = n->kind == LC_ASTKind_StmtBreak ? "break" : "continue"; + LC_GenCDefersLoopBreak(n); + if (n->sbreak.name) { + LC_GenLinef("goto %s_%s;", (char *)n->sbreak.name, stmt); + } else { + LC_GenLinef("%s;", stmt); + } + } break; + + case LC_ASTKind_StmtBlock: { + LC_GenLinef("/*block*/"); + LC_GenCStmtBlock(n); + } break; + + case LC_ASTKind_StmtSwitch: { + LC_GenLinef("switch("); + LC_GenCExpr(n->sswitch.expr); + LC_Genf(") {"); + + L->printer.indent += 1; + LC_ASTFor(it, n->sswitch.first) { + LC_GenCLineDirective(it); + if (it->kind == LC_ASTKind_StmtSwitchCase) { + LC_ASTFor(label_it, it->scase.first) { + LC_GenLinef("case "); + LC_GenCExpr(label_it); + LC_Genf(":"); + } + } + if (it->kind == LC_ASTKind_StmtSwitchDefault) { + LC_GenLinef("default:"); + } + LC_GenCStmtBlock(it->scase.body); + if (LC_HasNote(it, L->ifallthrough)) { + LC_Genf(" /*@fallthough*/"); + } else { + LC_Genf(" break;"); + } + } + L->printer.indent -= 1; + LC_GenLinef("}"); + } break; + + case LC_ASTKind_StmtFor: { + LC_GenLinef("for ("); + if (n->sfor.init) LC_GenCStmt2(n->sfor.init, GC_Stmt_OmitSemicolonAndNewLine); + LC_Genf(";"); + if (n->sfor.cond) { + LC_Genf(" "); + LC_GenCExpr(n->sfor.cond); + } + LC_Genf(";"); + if (n->sfor.inc) { + LC_Genf(" "); + LC_GenCStmt2(n->sfor.inc, GC_Stmt_OmitSemicolonAndNewLine); + } + LC_Genf(")"); + LC_GenCStmtBlock(n->sfor.body); + } break; + + case LC_ASTKind_StmtIf: { + LC_GenLinef("if "); + LC_GenCExprParen(n->sif.expr); + LC_GenCStmtBlock(n->sif.body); + LC_ASTFor(it, n->sif.first) { + LC_GenCLineDirective(it); + LC_GenLinef("else"); + if (it->kind == LC_ASTKind_StmtElseIf) { + LC_Genf(" if "); + LC_GenCExprParen(it->sif.expr); + } + LC_GenCStmtBlock(it->sif.body); + } + } break; + + default: LC_GenCStmt2(n, 0); + } +} + +LC_FUNCTION void LC_GenCExprParen(LC_AST *expr) { + bool paren = expr->kind != LC_ASTKind_ExprBinary; + if (paren) LC_Genf("("); + LC_GenCExpr(expr); + if (paren) LC_Genf(")"); +} + +LC_FUNCTION void LC_GenCStmtBlock(LC_AST *n) { + LC_PushAST(&L->printer.out_block_stack, n); + LC_ASSERT(n, n->kind == LC_ASTKind_StmtBlock); + LC_Genf(" {"); + L->printer.indent += 1; + LC_ASTFor(it, n->sblock.first) { + LC_GenCStmt(it); + } + LC_GenCDefers(n); + if (n->sblock.name) LC_GenLinef("%s_continue:;", (char *)n->sblock.name); + L->printer.indent -= 1; + LC_GenLinef("}"); + if (n->sblock.name) LC_GenLinef("%s_break:;", (char *)n->sblock.name); + LC_PopAST(&L->printer.out_block_stack); +} + +LC_FUNCTION void LC_GenCProcDecl(LC_Decl *decl) { + LC_StringList out = {0}; + LC_Type *type = decl->type; + LC_AST *n = decl->ast; + LC_AST *typespec = n->dproc.type; + + LC_Addf(L->arena, &out, "%s(", (char *)decl->foreign_name); + if (type->tagg.mems.count == 0) { + LC_Addf(L->arena, &out, "void"); + } else { + int i = 0; + LC_ASTFor(it, typespec->tproc.first) { + LC_Type *type = it->type; + LC_Addf(L->arena, &out, "%s%s", i == 0 ? "" : ", ", LC_GenCType(type, (char *)it->tproc_arg.name)); + i += 1; + } + } + if (type->tproc.vargs) { + LC_Addf(L->arena, &out, ", ..."); + } + LC_Addf(L->arena, &out, ")"); + char *front = LC_MergeString(L->arena, out).str; + char *result = LC_GenCType(type->tproc.ret, front); + + LC_GenLine(); + bool is_public = LC_HasNote(n, L->iapi) || decl->foreign_name == L->imain; + if (!is_public) LC_Genf("static "); + LC_Genf("%s", result); +} + +LC_FUNCTION void LC_GenCAggForwardDecl(LC_Decl *decl) { + LC_ASSERT(decl->ast, LC_IsAgg(decl->ast)); + char *agg = LC_GenLCAggName(decl->type); + LC_GenLinef("typedef %s %s %s;", agg, (char *)decl->foreign_name, (char *)decl->foreign_name); +} + +LC_FUNCTION void LC_GenCTypeDecl(LC_Decl *decl) { + LC_AST *n = decl->ast; + LC_ASSERT(n, decl->kind == LC_DeclKind_Type); + if (n->kind == LC_ASTKind_DeclTypedef) { + LC_Type *type = decl->typedef_renamed_type_decl ? decl->typedef_renamed_type_decl->type : decl->type; + LC_GenLinef("typedef %s;", LC_GenCType(type, (char *)decl->foreign_name)); + } else { + LC_Type *type = decl->type; + LC_Intern name = decl->foreign_name; + { + bool packed = LC_HasNote(n, L->ipacked) ? true : false; + if (packed) LC_GenLinef("#pragma pack(push, 1)"); + + LC_GenLinef("%s %s {", LC_GenLCAggName(type), name ? (char *)name : ""); + L->printer.indent += 1; + for (LC_TypeMember *it = type->tagg.mems.first; it; it = it->next) { + LC_GenLinef("%s;", LC_GenCType(it->type, (char *)it->name)); + } + L->printer.indent -= 1; + LC_GenLinef("};"); + if (packed) LC_GenLinef("#pragma pack(pop)"); + LC_GenLine(); + } + } +} + +LC_FUNCTION void LC_GenCVarFDecl(LC_Decl *decl) { + if (!LC_HasNote(decl->ast, L->iapi)) return; + LC_Type *type = decl->type; // make string arrays assignable + LC_GenLinef("extern "); + if (LC_HasNote(decl->ast, L->ithread_local)) LC_Genf("_Thread_local "); + LC_Genf("%s;", LC_GenCType(type, (char *)decl->foreign_name)); +} + +LC_FUNCTION void LC_GenCHeader(LC_AST *package) { + // C notes + LC_ASTFor(file, package->apackage.ffile) { + LC_ASTFor(it, file->afile.fdecl) { + if (it->kind != LC_ASTKind_DeclNote) continue; + + LC_AST *note = it->dnote.expr; + if (note->ecompo.name->eident.name == L->ic) { + LC_GenLinef("%s", (char *)LC_GetStringFromSingleArgNote(note)); + } + } + } + + // struct forward decls + LC_DeclFor(decl, package->apackage.first_ordered) { + if (decl->is_foreign) continue; + LC_AST *n = decl->ast; + if (decl->kind == LC_DeclKind_Type && LC_IsAgg(n)) LC_GenCAggForwardDecl(decl); + } + + // type decls + LC_GenLine(); + LC_DeclFor(decl, package->apackage.first_ordered) { + if (decl->is_foreign) continue; + LC_AST *n = decl->ast; + if (decl->kind == LC_DeclKind_Type) LC_GenCTypeDecl(decl); + } + + // proc and var forward decls + LC_DeclFor(decl, package->apackage.first_ordered) { + if (decl->is_foreign) continue; + LC_AST *n = decl->ast; + if (decl->kind == LC_DeclKind_Var) { + LC_GenCVarFDecl(decl); + } else if (decl->kind == LC_DeclKind_Proc) { + LC_GenCProcDecl(decl); + LC_Genf(";"); + } + } +} + +LC_FUNCTION void LC_GenCImpl(LC_AST *package) { + // implementation of vars + LC_DeclFor(decl, package->apackage.first_ordered) { + if (decl->kind == LC_DeclKind_Var && !decl->is_foreign) { + LC_AST *n = decl->ast; + LC_Type *type = decl->type; // make string arrays assignable + LC_GenLine(); + if (!LC_HasNote(n, L->iapi)) LC_Genf("static "); + if (LC_HasNote(n, L->ithread_local)) LC_Genf("_Thread_local "); + LC_Genf("%s", LC_GenCType(type, (char *)decl->foreign_name)); + + GC_SpecialCase_GlobalScopeStringDecl = true; + LC_GenCVarExpr(n, true); + GC_SpecialCase_GlobalScopeStringDecl = false; + LC_Genf(";"); + LC_GenLine(); + } + } + + // implementation of procs + LC_DeclFor(decl, package->apackage.first_ordered) { + LC_AST *n = decl->ast; + if (decl->kind == LC_DeclKind_Proc && n->dproc.body && !decl->is_foreign) { + LC_GenCLineDirective(n); + LC_GenCProcDecl(decl); + LC_GenCStmtBlock(n->dproc.body); + LC_GenLine(); + } + } +} + +LC_FUNCTION void WalkAndCountDeclRefs(LC_ASTWalker *ctx, LC_AST *n) { + LC_Decl *decl = NULL; + if (n->kind == LC_ASTKind_ExprIdent || n->kind == LC_ASTKind_TypespecIdent) { + if (n->eident.resolved_decl) decl = n->eident.resolved_decl; + } + if (n->kind == LC_ASTKind_ExprField) { + if (n->efield.resolved_decl) decl = n->efield.resolved_decl; + } + if (decl) { + LC_Map *map_of_visits = (LC_Map *)ctx->user_data; + intptr_t visited = (intptr_t)LC_MapGetP(map_of_visits, decl); + LC_MapInsertP(map_of_visits, decl, (void *)(visited + 1)); + if (visited == 0 && decl->ast->kind != LC_ASTKind_Null) { + LC_WalkAST(ctx, decl->ast); + } + } +} + +LC_FUNCTION LC_Map LC_CountDeclRefs(LC_Arena *arena) { + LC_Map map = {arena}; + LC_MapReserve(&map, 512); + + LC_AST *package = LC_GetPackageByName(L->first_package); + LC_ASTWalker walker = LC_GetDefaultWalker(arena, WalkAndCountDeclRefs); + walker.user_data = (void *)↦ + walker.visit_notes = true; + LC_WalkAST(&walker, package); + + return map; +} + +LC_FUNCTION void LC_RemoveUnreferencedGlobalDecls(LC_Map *map_of_visits) { + for (LC_ASTRef *it = L->ordered_packages.first; it; it = it->next) { + for (LC_Decl *decl = it->ast->apackage.first_ordered; decl;) { + intptr_t ref_count = (intptr_t)LC_MapGetP(map_of_visits, decl); + + LC_Decl *remove = decl; + decl = decl->next; + if (ref_count == 0 && remove->foreign_name != LC_ILit("main")) { + LC_DLLRemove(it->ast->apackage.first_ordered, it->ast->apackage.last_ordered, remove); + } + } + } +} + +LC_FUNCTION void LC_ErrorOnUnreferencedLocals(LC_Map *map_of_visits) { + LC_Decl *first = (LC_Decl *)L->decl_arena->memory.data; + for (int i = 0; i < L->decl_count; i += 1) { + LC_Decl *decl = first + i; + if (decl->package == L->builtin_package) { + continue; + } + + intptr_t ref_count = (intptr_t)LC_MapGetP(map_of_visits, decl); + if (ref_count == 0) { + if (LC_IsStmt(decl->ast)) { + if (!LC_HasNote(decl->ast, L->iunused)) LC_ReportASTError(decl->ast, "unused local variable '%s'", decl->name); + } + } + } +} + +LC_FUNCTION void LC_FindUnusedLocalsAndRemoveUnusedGlobalDecls(void) { + if (L->errors) return; + LC_TempArena check = LC_BeginTemp(L->arena); + + LC_Map map = LC_CountDeclRefs(check.arena); + LC_ErrorOnUnreferencedLocals(&map); + LC_RemoveUnreferencedGlobalDecls(&map); + + LC_EndTemp(check); +} +LC_FUNCTION LC_Operand LC_ImportPackage(LC_AST *import, LC_AST *dst, LC_AST *src) { + DeclScope *dst_scope = dst->apackage.scope; + int scope_size = LC_NextPow2(src->apackage.scope->len * 2 + 1); + if (import && import->gimport.name) { + LC_PUSH_PACKAGE(dst); + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Import, import->gimport.name, import); + decl->scope = LC_CreateScope(scope_size); + LC_PutGlobalDecl(decl); + import->gimport.resolved_decl = decl; + LC_POP_PACKAGE(); + dst_scope = decl->scope; + } + + for (int i = 0; i < src->apackage.scope->cap; i += 1) { + LC_MapEntry entry = src->apackage.scope->entries[i]; + if (entry.key != 0) { + LC_Decl *decl = (LC_Decl *)entry.value; + if (decl->package != src) continue; + LC_Decl *existing = (LC_Decl *)LC_MapGetU64(dst_scope, decl->name); + if (existing && decl->package == L->builtin_package) { + continue; + } + if (existing) { + LC_MarkDeclError(existing); + LC_MarkDeclError(decl); + return LC_ReportASTErrorEx(decl->ast, existing->ast, "name colission while importing '%s' into '%s', there are 2 decls with the same name '%s'", src->apackage.name, dst->apackage.name, decl->name); + } + LC_MapInsertU64(dst_scope, decl->name, decl); + } + } + + if (import && import->gimport.name) { + LC_ASSERT(import, dst_scope->cap == scope_size); + } + + if (import) import->gimport.resolved = true; + return LC_OPNull; +} + +LC_FUNCTION LC_Intern LC_MakePackageNameFromPath(LC_String path) { + if (path.str[path.len - 1] == '/') path = LC_Chop(path, 1); + LC_String s8name = LC_SkipToLastSlash(path); + if (!LC_IsDir(L->arena, path) && LC_EndsWith(path, LC_Lit(".lc"), true)) { + s8name = LC_ChopLastPeriod(s8name); + } + if (s8name.len == 0) { + L->errors += 1; + LC_SendErrorMessagef(NULL, NULL, "failed to extract name from path %.*s", LC_Expand(path)); + return LC_GetUniqueIntern("invalid_package_name"); + } + LC_Intern result = LC_InternStrLen(s8name.str, (int)s8name.len); + return result; +} + +LC_FUNCTION bool LC_PackageNameValid(LC_Intern name) { + char *str = (char *)name; + if (LC_IsDigit(str[0])) return false; + for (int i = 0; str[i]; i += 1) { + bool is_valid = LC_IsIdent(str[i]) || LC_IsDigit(str[i]); + if (!is_valid) return false; + } + return true; +} + +LC_FUNCTION bool LC_PackageNameDuplicate(LC_Intern name) { + LC_ASTFor(it, L->fpackage) { + if (it->apackage.name == name) return true; + } + return false; +} + +LC_FUNCTION void LC_AddPackageToList(LC_AST *n) { + LC_Intern name = n->apackage.name; + if (LC_PackageNameDuplicate(name)) { + LC_SendErrorMessagef(NULL, NULL, "found 2 packages with the same name: '%s' / '%.*s'\n", name, LC_Expand(n->apackage.path)); + L->errors += 1; + return; + } + if (!LC_PackageNameValid(name)) { + LC_SendErrorMessagef(NULL, NULL, "invalid package name, please change the name of the package directory: '%s'\n", name); + L->errors += 1; + return; + } + LC_DLLAdd(L->fpackage, L->lpackage, n); +} + +LC_FUNCTION LC_AST *LC_RegisterPackage(LC_String path) { + LC_ASSERT(NULL, path.len != 0); + LC_AST *n = LC_CreateAST(NULL, LC_ASTKind_Package); + n->apackage.name = LC_MakePackageNameFromPath(path); + n->apackage.path = path; + LC_AddPackageToList(n); + return n; +} + +LC_FUNCTION LC_AST *LC_FindImportInRefList(LC_ASTRefList *arr, LC_Intern path) { + for (LC_ASTRef *it = arr->first; it; it = it->next) { + if (it->ast->gimport.path == path) return it->ast; + } + return NULL; +} + +LC_FUNCTION void LC_AddASTToRefList(LC_ASTRefList *refs, LC_AST *ast) { + LC_ASTRef *ref = LC_PushStruct(L->arena, LC_ASTRef); + ref->ast = ast; + LC_DLLAdd(refs->first, refs->last, ref); +} + +LC_FUNCTION LC_ASTRefList LC_GetPackageImports(LC_AST *package) { + LC_ASSERT(package, package->kind == LC_ASTKind_Package); + + LC_ASTRefList refs = {0}; + LC_ASTFor(file, package->apackage.ffile) { + LC_ASTFor(import, file->afile.fimport) { + LC_AST *found = LC_FindImportInRefList(&refs, import->gimport.path); + if (found) { + LC_ReportASTErrorEx(import, found, "duplicate import of: '%s', into package '%s'\n", import->gimport.path, package->apackage.name); + continue; + } + LC_AddASTToRefList(&refs, import); + } + } + + return refs; +} + +LC_FUNCTION void LC_RegisterPackageDir(char *dir) { + LC_String sdir = LC_MakeFromChar(dir); + if (!LC_IsDir(L->arena, sdir)) { + LC_SendErrorMessagef(NULL, NULL, "dir with name '%s', doesn't exist\n", dir); + return; + } + LC_AddNode(L->arena, &L->package_dirs, sdir); +} + +LC_FUNCTION LC_AST *LC_GetPackageByName(LC_Intern name) { + LC_ASTFor(it, L->fpackage) { + if (it->apackage.name == name) return it; + } + + LC_AST *result = NULL; + for (LC_StringNode *it = L->package_dirs.first; it; it = it->next) { + LC_String s = it->string; + LC_String path = LC_Format(L->arena, "%.*s/%s", LC_Expand(s), (char *)name); + if (LC_IsDir(L->arena, path)) { + if (result != NULL) { + LC_SendErrorMessagef(NULL, NULL, "found 2 directories with the same name: '%.*s', '%.*s'\n", LC_Expand(path), LC_Expand(result->apackage.path)); + L->errors += 1; + break; + } + result = LC_RegisterPackage(path); + } + } + + return result; +} + +LC_FUNCTION LC_StringList LC_ListFilesInPackage(LC_Arena *arena, LC_String path) { + LC_StringList result = LC_MakeEmptyList(); + for (LC_FileIter it = LC_IterateFiles(arena, path); LC_IsValid(it); LC_Advance(&it)) { + if (LC_EndsWith(it.absolute_path, LC_Lit(".lc"), LC_IgnoreCase)) { + LC_AddNode(arena, &result, it.absolute_path); + } + } + return result; +} + +LC_FUNCTION LoadedFile LC_ReadFileHook(LC_AST *package, LC_String path) { + LoadedFile result = {path}; + if (L->on_file_load) { + L->on_file_load(package, &result); + } else { + result.content = LC_ReadFile(L->arena, result.path); + } + + return result; +} + +LC_FUNCTION void LC_ParsePackage(LC_AST *n) { + LC_ASSERT(n, n->kind == LC_ASTKind_Package); + LC_ASSERT(n, n->apackage.scope == NULL); + n->apackage.scope = LC_CreateScope(256); + + LC_StringList files = n->apackage.injected_filepaths; + if (files.node_count == 0) { + files = LC_ListFilesInPackage(L->arena, n->apackage.path); + if (files.first == NULL) { + LC_SendErrorMessagef(NULL, NULL, "no valid .lc files in '%.*s'", LC_Expand(n->apackage.path)); + n->apackage.state = LC_DeclState_Error; + L->errors += 1; + return; + } + } + + for (LC_StringNode *it = files.first; it; it = it->next) { + LoadedFile file = LC_ReadFileHook(n, it->string); + if (file.content.str == NULL) file.content.str = ""; + + LC_AST *ast_file = LC_ParseFile(n, file.path.str, file.content.str, file.line); + if (!ast_file) { + n->apackage.state = LC_DeclState_Error; + return; + } + } +} + +LC_FUNCTION void LC_ParsePackagesUsingRegistry(LC_Intern name) { + LC_AST *n = LC_GetPackageByName(name); + if (!n) { + LC_SendErrorMessagef(NULL, NULL, "no package with name '%s'\n", name); + L->errors += 1; + return; + } + if (n->apackage.scope) { + return; + } + LC_ParsePackage(n); + LC_ASTRefList imports = LC_GetPackageImports(n); + for (LC_ASTRef *it = imports.first; it; it = it->next) { + LC_ParsePackagesUsingRegistry(it->ast->gimport.path); + } +} + +LC_FUNCTION void LC_AddOrderedPackageToRefList(LC_AST *n) { + LC_ASTRefList *ordered = &L->ordered_packages; + for (LC_ASTRef *it = ordered->first; it; it = it->next) { + if (it->ast->apackage.name == n->apackage.name) { + return; + } + } + LC_AddASTToRefList(ordered, n); +} + +// Here we use import statements to produce a list of ordered packages. +// While we are at it we also resolve most top level declarations. I say +// most because aggregations are handled a bit differently, their resolution +// is deffered. This is added because a pointer doesn't require full typeinfo of +// an aggregate. It's just a number. +LC_FUNCTION LC_AST *LC_OrderPackagesAndBasicResolve(LC_AST *pos, LC_Intern name) { + LC_AST *n = LC_GetPackageByName(name); + if (n->apackage.state == LC_DeclState_Error) { + return NULL; + } + if (n->apackage.state == LC_DeclState_Resolved) { + // This function can be called multiple times, I assume user might + // want to use type information to generate something. Pattern: + // typecheck -> generate -> typecheck is expected! + LC_PackageDecls(n); + return n; + } + if (n->apackage.state == LC_DeclState_Resolving) { + LC_ReportASTError(pos, "circular import '%s'", name); + n->apackage.state = LC_DeclState_Error; + return NULL; + } + LC_ASSERT(pos, n->apackage.state == LC_DeclState_Unresolved); + n->apackage.state = LC_DeclState_Resolving; + + LC_Operand op = LC_ImportPackage(NULL, n, L->builtin_package); + LC_ASSERT(pos, !LC_IsError(op)); + + // Resolve all imports regardless of errors. + // If current package has wrong import it means it's also + // wrong but it should still look into all imports + // despite this. + int wrong_import = 0; + LC_ASTRefList refs = LC_GetPackageImports(n); + for (LC_ASTRef *it = refs.first; it; it = it->next) { + LC_AST *import = LC_OrderPackagesAndBasicResolve(it->ast, it->ast->gimport.path); + if (!import) { + n->apackage.state = LC_DeclState_Error; + wrong_import += 1; + continue; + } + + LC_Operand op = LC_ImportPackage(it->ast, n, import); + if (LC_IsError(op)) { + n->apackage.state = LC_DeclState_Error; + wrong_import += 1; + continue; + } + } + + if (wrong_import) return NULL; + + LC_PackageDecls(n); + LC_AddOrderedPackageToRefList(n); + n->apackage.state = LC_DeclState_Resolved; + return n; +} + +LC_FUNCTION void LC_OrderAndResolveTopLevelDecls(LC_Intern name) { + L->first_package = name; + LC_OrderPackagesAndBasicResolve(NULL, name); + + // Resolve still incomplete aggregate types, this operates on all packages + // that didn't have errors so even if something broke in package ordering + // it should still be fine to go forward with this and also proc body analysis + for (LC_ASTRef *it = L->ordered_packages.first; it; it = it->next) { + LC_AST *package = it->ast; + LC_ASSERT(package, package->apackage.state == LC_DeclState_Resolved); + LC_ResolveIncompleteTypes(package); + } +} + +LC_FUNCTION void LC_ResolveAllProcBodies(void) { + // We don't need to check errors, only valid packages should have been put into + // the list. + for (LC_ASTRef *it = L->ordered_packages.first; it; it = it->next) { + LC_AST *package = it->ast; + LC_ASSERT(package, package->apackage.state == LC_DeclState_Resolved); + LC_ResolveProcBodies(package); + } +} + +LC_FUNCTION LC_ASTRefList LC_ResolvePackageByName(LC_Intern name) { + LC_ParsePackagesUsingRegistry(name); + LC_ASTRefList empty = {0}; + if (L->errors) return empty; + + LC_OrderAndResolveTopLevelDecls(name); + LC_ResolveAllProcBodies(); + return L->ordered_packages; +} + +LC_FUNCTION LC_String LC_GenerateUnityBuild(LC_ASTRefList packages) { + if (L->errors) return LC_MakeEmptyString(); + + LC_BeginStringGen(L->arena); + + LC_GenLinef("#include "); + LC_GenLinef("#include "); + LC_GenLinef("#ifndef LC_String_IMPL"); + LC_GenLinef("#define LC_String_IMPL"); + LC_GenLinef("typedef struct { char *str; long long len; } LC_String;"); + LC_GenLinef("#endif"); + LC_GenLinef("#ifndef LC_Any_IMPL"); + LC_GenLinef("#define LC_Any_IMPL"); + LC_GenLinef("typedef struct { int type; void *data; } LC_Any;"); + LC_GenLinef("#endif"); + + LC_GenLinef("#ifndef LC_Alignof"); + LC_GenLinef("#if defined(__TINYC__)"); + LC_GenLinef("#define LC_Alignof(...) __alignof__(__VA_ARGS__)"); + LC_GenLinef("#else"); + LC_GenLinef("#define LC_Alignof(...) _Alignof(__VA_ARGS__)"); + LC_GenLinef("#endif"); + LC_GenLinef("#endif"); + LC_GenLinef("void *memset(void *, int, size_t);"); + + for (LC_ASTRef *it = packages.first; it; it = it->next) LC_GenCHeader(it->ast); + for (LC_ASTRef *it = packages.first; it; it = it->next) LC_GenCImpl(it->ast); + LC_String s = LC_EndStringGen(L->arena); + return s; +} + +LC_FUNCTION void LC_AddSingleFilePackage(LC_Intern name, LC_String path) { + LC_AST *n = LC_CreateAST(0, LC_ASTKind_Package); + n->apackage.name = name; + n->apackage.path = path; + LC_AddNode(L->arena, &n->apackage.injected_filepaths, path); + LC_AddPackageToList(n); +} +LC_FUNCTION LC_Lang *LC_LangAlloc(void) { + LC_Arena *arena = LC_BootstrapArena(); + LC_Arena *lex_arena = LC_PushStruct(arena, LC_Arena); + LC_Arena *decl_arena = LC_PushStruct(arena, LC_Arena); + LC_Arena *ast_arena = LC_PushStruct(arena, LC_Arena); + LC_Arena *type_arena = LC_PushStruct(arena, LC_Arena); + LC_InitArena(lex_arena); + LC_InitArena(decl_arena); + LC_InitArena(ast_arena); + LC_InitArena(type_arena); + + LC_Lang *l = LC_PushStruct(arena, LC_Lang); + l->arena = arena; + l->lex_arena = lex_arena; + l->decl_arena = decl_arena; + l->ast_arena = ast_arena; + l->type_arena = type_arena; + + l->emit_line_directives = true; + l->breakpoint_on_error = true; + l->use_colored_terminal_output = true; + + return l; +} + +LC_FUNCTION void LC_LangEnd(LC_Lang *lang) { + LC_DeallocateArena(lang->lex_arena); + LC_DeallocateArena(lang->type_arena); + LC_DeallocateArena(lang->decl_arena); + LC_DeallocateArena(lang->ast_arena); + LC_DeallocateArena(lang->arena); + if (L == lang) L = NULL; +} + +LC_FUNCTION void LC_LangBegin(LC_Lang *l) { + L = l; + + // Init default target settings + { + if (L->os == LC_OS_Invalid) { + L->os = LC_OS_LINUX; +#if LC_OPERATING_SYSTEM_WINDOWS + L->os = LC_OS_WINDOWS; +#elif LC_OPERATING_SYSTEM_MAC + L->os = LC_OS_MAC; +#endif + } + if (L->arch == LC_ARCH_Invalid) { + L->arch = LC_ARCH_X64; + } + if (L->gen == LC_GEN_Invalid) { + L->gen = LC_GEN_C; + } + } + + // + // Init declared notes, interns and foreign names checker + // + { + L->declared_notes.arena = L->arena; + L->interns.arena = L->arena; + L->foreign_names.arena = L->arena; + L->implicit_any.arena = L->arena; + + LC_MapReserve(&L->declared_notes, 128); + LC_MapReserve(&L->interns, 4096); + LC_MapReserve(&L->foreign_names, 256); + LC_MapReserve(&L->implicit_any, 64); + +#define X(x) l->k##x = LC_InternStrLen(#x, sizeof(#x) - 1); + LC_LIST_KEYWORDS +#undef X + l->first_keyword = l->kfor; + l->last_keyword = l->kfalse; + +#define X(x, declare) l->i##x = LC_InternStrLen(#x, sizeof(#x) - 1); + LC_LIST_INTERNS +#undef X +#define X(x, declare) \ + if (declare) LC_DeclareNote(L->i##x); + LC_LIST_INTERNS +#undef X + } + + // Nulls + { + L->NullLEX.begin = "builtin declarations"; + L->NullLEX.file = LC_ILit("builtin declarations"); + L->BuiltinToken.lex = &L->NullLEX; + L->BuiltinToken.str = "builtin declarations"; + L->BuiltinToken.len = sizeof("builtin declarations") - 1; + L->NullAST.pos = &L->BuiltinToken; + } + + { + LC_AST *builtins = LC_CreateAST(0, LC_ASTKind_Package); + L->builtin_package = builtins; + builtins->apackage.name = LC_ILit("builtins"); + builtins->apackage.scope = LC_CreateScope(256); + LC_AddPackageToList(builtins); + } + + LC_InitDeclStack(&L->resolver.locals, 128); + L->resolver.duplicate_map.arena = L->arena; + LC_MapReserve(&L->resolver.duplicate_map, 32); + + L->resolver.stmt_block_stack.arena = L->arena; + L->printer.out_block_stack.arena = L->arena; + + LC_PUSH_PACKAGE(L->builtin_package); + + // + // Init default type sizes using current platform + // + // Here we use the sizes of our current platform but + // later on it gets swapped based on LC override global variables in + // InitTarget + // + { + l->type_map.arena = L->arena; + LC_MapReserve(&l->type_map, 256); + + typedef long long llong; + typedef unsigned long long ullong; + typedef unsigned long ulong; + typedef unsigned short ushort; + typedef unsigned char uchar; + typedef unsigned int uint; + + L->pointer_align = LC_Alignof(void *); + L->pointer_size = sizeof(void *); + + int i = 0; +#define X(TNAME, IS_UNSIGNED) \ + l->types[i].kind = LC_TypeKind_##TNAME; \ + l->types[i].size = sizeof(TNAME); \ + l->types[i].align = LC_Alignof(TNAME); \ + l->types[i].is_unsigned = IS_UNSIGNED; \ + l->t##TNAME = l->types + i++; + + LC_LIST_TYPES +#undef X + + // + // Overwrite types with target + // + if (L->arch == LC_ARCH_X64) { + LC_SetPointerSizeAndAlign(8, 8); + if (L->os == LC_OS_WINDOWS) { + L->tlong->size = 4; + L->tlong->align = 4; + L->tulong->size = 4; + L->tulong->align = 4; + } else { + L->tlong->size = 8; + L->tlong->align = 8; + L->tulong->size = 8; + L->tulong->align = 8; + } + } else if (L->arch == LC_ARCH_X86) { + LC_SetPointerSizeAndAlign(4, 4); + L->tlong->size = 4; + L->tlong->align = 4; + L->tulong->size = 4; + L->tulong->align = 4; + } + + l->types[i].kind = LC_TypeKind_void; + l->tvoid = l->types + i++; + + // Init decls for types + for (int i = 0; i < T_Count; i += 1) { + char *it = (char *)LC_TypeKindToString((LC_TypeKind)i) + 12; + LC_Intern intern = LC_ILit(it); + LC_Type *t = l->types + i; + t->id = ++l->typeids; + + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Type, intern, &L->NullAST); + decl->state = LC_DeclState_Resolved; + decl->type = t; + t->decl = decl; + LC_AddDeclToScope(L->builtin_package->apackage.scope, decl); + + if (t->kind == LC_TypeKind_uchar) decl->foreign_name = LC_ILit("unsigned char"); + if (t->kind == LC_TypeKind_ushort) decl->foreign_name = LC_ILit("unsigned short"); + if (t->kind == LC_TypeKind_uint) decl->foreign_name = LC_ILit("unsigned"); + if (t->kind == LC_TypeKind_ulong) decl->foreign_name = LC_ILit("unsigned long"); + if (t->kind == LC_TypeKind_llong) decl->foreign_name = LC_ILit("long long"); + if (t->kind == LC_TypeKind_ullong) decl->foreign_name = LC_ILit("unsigned long long"); + } + } + + l->tpvoid = LC_CreatePointerType(l->tvoid); + l->tpchar = LC_CreatePointerType(l->tchar); + + { + l->tuntypedint = LC_CreateUntypedInt(L->tint); + l->tuntypedbool = LC_CreateUntypedInt(L->tbool); + l->tuntypednil = LC_CreateUntypedInt(L->tullong); + + l->ttuntypedfloat.kind = LC_TypeKind_UntypedFloat; + l->ttuntypedfloat.id = ++L->typeids; + l->tuntypedfloat = &L->ttuntypedfloat; + l->tuntypedfloat->tutdefault = l->tdouble; + l->tuntypedfloat->decl = LC_CreateDecl(LC_DeclKind_Type, LC_ILit("UntypedFloat"), &L->NullAST); + + l->ttuntypedstring.kind = LC_TypeKind_UntypedString; + l->ttuntypedstring.id = ++L->typeids; + l->tuntypedstring = &L->ttuntypedstring; + l->tuntypedstring->tutdefault = l->tpchar; + l->tuntypedstring->decl = LC_CreateDecl(LC_DeclKind_Type, LC_ILit("UntypedString"), &L->NullAST); + } + + // Add builtin "String" type + { + L->ttstring.kind = LC_TypeKind_Incomplete; + L->ttstring.id = ++L->typeids; + L->tstring = &L->ttstring; + + LC_AST *ast = LC_ParseDeclf("String :: struct { str: *char; len: int; }"); + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Type, ast->dbase.name, ast); + decl->foreign_name = LC_ILit("LC_String"); + decl->state = LC_DeclState_Resolved; + decl->type = L->tstring; + L->tstring->decl = decl; + LC_AddDeclToScope(L->builtin_package->apackage.scope, decl); + LC_Operand result = LC_ResolveTypeAggregate(ast, decl->type); + LC_ASSERT(ast, !LC_IsError(result)); + } + + // Add builtin "Any" type + { + L->ttany.kind = LC_TypeKind_Incomplete; + L->ttany.id = ++L->typeids; + L->tany = &L->ttany; + + LC_AST *ast = LC_ParseDeclf("Any :: struct { type: int; data: *void; }"); + LC_Decl *decl = LC_CreateDecl(LC_DeclKind_Type, ast->dbase.name, ast); + decl->foreign_name = LC_ILit("LC_Any"); + decl->state = LC_DeclState_Resolved; + decl->type = L->tany; + L->tany->decl = decl; + LC_AddDeclToScope(L->builtin_package->apackage.scope, decl); + LC_Operand result = LC_ResolveTypeAggregate(ast, decl->type); + LC_ASSERT(ast, !LC_IsError(result)); + } + + LC_Decl *decl_nil = LC_AddConstIntDecl("nil", 0); + decl_nil->type = L->tuntypednil; + + for (int i = LC_ARCH_X64; i < LC_ARCH_Count; i += 1) LC_AddBuiltinConstInt((char *)LC_ARCHToString((LC_ARCH)i), i); + for (int i = LC_OS_WINDOWS; i < LC_OS_Count; i += 1) LC_AddBuiltinConstInt((char *)LC_OSToString((LC_OS)i), i); + for (int i = LC_GEN_C; i < LC_GEN_Count; i += 1) LC_AddBuiltinConstInt((char *)LC_GENToString((LC_GEN)i), i); + LC_AddBuiltinConstInt("LC_ARCH", L->arch); + LC_AddBuiltinConstInt("LC_GEN", L->gen); + LC_AddBuiltinConstInt("LC_OS", L->os); + + LC_POP_PACKAGE(); +} + + +#if _WIN32 + typedef struct LC_Win32_FileIter { + HANDLE handle; + WIN32_FIND_DATAW data; +} LC_Win32_FileIter; + +LC_FUNCTION bool LC_IsDir(LC_Arena *arena, LC_String path) { + wchar_t wbuff[1024]; + LC_CreateWidecharFromChar(wbuff, LC_StrLenof(wbuff), path.str, path.len); + DWORD dwAttrib = GetFileAttributesW(wbuff); + return dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY); +} + +LC_FUNCTION LC_String LC_GetAbsolutePath(LC_Arena *arena, LC_String relative) { + wchar_t wpath[1024]; + LC_CreateWidecharFromChar(wpath, LC_StrLenof(wpath), relative.str, relative.len); + wchar_t wpath_abs[1024]; + DWORD written = GetFullPathNameW((wchar_t *)wpath, LC_StrLenof(wpath_abs), wpath_abs, 0); + if (written == 0) + return LC_MakeEmptyString(); + LC_String path = LC_FromWidecharEx(arena, wpath_abs, written); + LC_NormalizePathUnsafe(path); + return path; +} + +LC_FUNCTION bool LC_IsValid(LC_FileIter it) { + return it.is_valid; +} + +LC_FUNCTION void LC_Advance(LC_FileIter *it) { + while (FindNextFileW(it->w32->handle, &it->w32->data) != 0) { + WIN32_FIND_DATAW *data = &it->w32->data; + + // Skip '.' and '..' + if (data->cFileName[0] == '.' && data->cFileName[1] == '.' && data->cFileName[2] == 0) continue; + if (data->cFileName[0] == '.' && data->cFileName[1] == 0) continue; + + it->is_directory = data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY; + it->filename = LC_FromWidecharEx(it->arena, data->cFileName, LC_WideLength(data->cFileName)); + const char *is_dir = it->is_directory ? "/" : ""; + const char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/"; + it->relative_path = LC_Format(it->arena, "%.*s%s%.*s%s", LC_Expand(it->path), separator, LC_Expand(it->filename), is_dir); + it->absolute_path = LC_GetAbsolutePath(it->arena, it->relative_path); + it->is_valid = true; + + if (it->is_directory) { + LC_ASSERT(NULL, it->relative_path.str[it->relative_path.len - 1] == '/'); + LC_ASSERT(NULL, it->absolute_path.str[it->absolute_path.len - 1] == '/'); + } + return; + } + + it->is_valid = false; + DWORD error = GetLastError(); + LC_ASSERT(NULL, error == ERROR_NO_MORE_FILES); + FindClose(it->w32->handle); +} + +LC_FUNCTION LC_FileIter LC_IterateFiles(LC_Arena *scratch_arena, LC_String path) { + LC_FileIter it = {0}; + it.arena = scratch_arena; + it.path = path; + + LC_String modified_path = LC_Format(it.arena, "%.*s\\*", LC_Expand(path)); + wchar_t *wbuff = LC_PushArray(it.arena, wchar_t, modified_path.len + 1); + int64_t wsize = LC_CreateWidecharFromChar(wbuff, modified_path.len + 1, modified_path.str, modified_path.len); + LC_ASSERT(NULL, wsize); + + it.w32 = LC_PushStruct(it.arena, LC_Win32_FileIter); + it.w32->handle = FindFirstFileW(wbuff, &it.w32->data); + if (it.w32->handle == INVALID_HANDLE_VALUE) { + it.is_valid = false; + return it; + } + + LC_ASSERT(NULL, it.w32->data.cFileName[0] == '.' && it.w32->data.cFileName[1] == 0); + LC_Advance(&it); + return it; +} + +LC_FUNCTION LC_String LC_ReadFile(LC_Arena *arena, LC_String path) { + LC_String result = LC_MakeEmptyString(); + + wchar_t wpath[1024]; + LC_CreateWidecharFromChar(wpath, LC_StrLenof(wpath), path.str, path.len); + HANDLE handle = CreateFileW(wpath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (handle != INVALID_HANDLE_VALUE) { + LARGE_INTEGER file_size; + if (GetFileSizeEx(handle, &file_size)) { + if (file_size.QuadPart != 0) { + result.len = (int64_t)file_size.QuadPart; + result.str = (char *)LC_PushSizeNonZeroed(arena, result.len + 1); + DWORD read; + if (ReadFile(handle, result.str, (DWORD)result.len, &read, NULL)) { // @todo: can only read 32 byte size files? + if (read == result.len) { + result.str[result.len] = 0; + } + } + } + } + CloseHandle(handle); + } + + return result; +} + +LC_FUNCTION bool LC_EnableTerminalColors(void) { + HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); + if (hOut != INVALID_HANDLE_VALUE) { + DWORD dwMode = 0; + if (GetConsoleMode(hOut, &dwMode)) { + dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING; + if (SetConsoleMode(hOut, dwMode)) { + return true; + } + } + } + return false; +} + +#elif __linux__ || __APPLE__ || __unix__ + #include + #include + #include + #include + #include + #include + + LC_FUNCTION bool LC_EnableTerminalColors(void) { + return true; +} + +LC_FUNCTION bool LC_IsDir(LC_Arena *arena, LC_String path) { + bool result = false; + LC_TempArena ch = LC_BeginTemp(arena); + LC_String copy = LC_CopyString(arena, path); + + struct stat s; + if (stat(copy.str, &s) != 0) { + result = false; + } else { + result = S_ISDIR(s.st_mode); + } + + LC_EndTemp(ch); + return result; +} + +LC_FUNCTION LC_String LC_GetAbsolutePath(LC_Arena *arena, LC_String relative) { + LC_String copy = LC_CopyString(arena, relative); + char *buffer = (char *)LC_PushSizeNonZeroed(arena, PATH_MAX); + realpath((char *)copy.str, buffer); + LC_String result = LC_MakeFromChar(buffer); + return result; +} + +LC_FUNCTION bool LC_IsValid(LC_FileIter it) { + return it.is_valid; +} + +LC_FUNCTION void LC_Advance(LC_FileIter *it) { + struct dirent *file = 0; + while ((file = readdir((DIR *)it->dir)) != NULL) { + if (file->d_name[0] == '.' && file->d_name[1] == '.' && file->d_name[2] == 0) continue; + if (file->d_name[0] == '.' && file->d_name[1] == 0) continue; + + it->is_directory = file->d_type == DT_DIR; + it->filename = LC_CopyChar(it->arena, file->d_name); + + const char *dir_char_ending = it->is_directory ? "/" : ""; + const char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/"; + it->relative_path = LC_Format(it->arena, "%.*s%s%s%s", LC_Expand(it->path), separator, file->d_name, dir_char_ending); + it->absolute_path = LC_GetAbsolutePath(it->arena, it->relative_path); + if (it->is_directory) it->absolute_path = LC_Format(it->arena, "%.*s/", LC_Expand(it->absolute_path)); + it->is_valid = true; + return; + } + it->is_valid = false; + closedir((DIR *)it->dir); +} + +LC_FUNCTION LC_FileIter LC_IterateFiles(LC_Arena *arena, LC_String path) { + LC_FileIter it = {0}; + it.arena = arena; + it.path = path = LC_CopyString(arena, path); + it.dir = (void *)opendir((char *)path.str); + if (!it.dir) return it; + + LC_Advance(&it); + return it; +} + +LC_FUNCTION LC_String LC_ReadFile(LC_Arena *arena, LC_String path) { + LC_String result = LC_MakeEmptyString(); + + // ftell returns insane size if file is + // a directory **on some machines** KEKW + if (LC_IsDir(arena, path)) { + return result; + } + + path = LC_CopyString(arena, path); + FILE *f = fopen(path.str, "rb"); + if (f) { + fseek(f, 0, SEEK_END); + result.len = ftell(f); + fseek(f, 0, SEEK_SET); + + result.str = (char *)LC_PushSizeNonZeroed(arena, result.len + 1); + fread(result.str, result.len, 1, f); + result.str[result.len] = 0; + + fclose(f); + } + + return result; +} + +#endif + +#ifndef LC_USE_CUSTOM_ARENA + #if defined(LC_USE_ADDRESS_SANITIZER) + #include +#endif + +#if !defined(ASAN_POISON_MEMORY_REGION) + #define LC_ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) + #define LC_ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) +#else + #define LC_ASAN_POISON_MEMORY_REGION(addr, size) ASAN_POISON_MEMORY_REGION(addr, size) + #define LC_ASAN_UNPOISON_MEMORY_REGION(addr, size) ASAN_UNPOISON_MEMORY_REGION(addr, size) +#endif + +#define LC_DEFAULT_RESERVE_SIZE LC_GIB(1) +#define LC_DEFAULT_ALIGNMENT 8 +#define LC_COMMIT_ADD_SIZE LC_MIB(4) + +LC_FUNCTION uint8_t *LC_V_AdvanceCommit(LC_VMemory *m, size_t *commit_size, size_t page_size) { + size_t aligned_up_commit = LC_AlignUp(*commit_size, page_size); + size_t to_be_total_commited_size = aligned_up_commit + m->commit; + size_t to_be_total_commited_size_clamped_to_reserve = LC_CLAMP_TOP(to_be_total_commited_size, m->reserve); + size_t adjusted_to_boundary_commit = to_be_total_commited_size_clamped_to_reserve - m->commit; + LC_Assertf(adjusted_to_boundary_commit, "Reached the virtual memory reserved boundary"); + *commit_size = adjusted_to_boundary_commit; + + if (adjusted_to_boundary_commit == 0) { + return 0; + } + uint8_t *result = m->data + m->commit; + return result; +} + +LC_FUNCTION void LC_PopToPos(LC_Arena *arena, size_t pos) { + LC_Assertf(arena->len >= arena->base_len, "Bug: arena->len shouldn't ever be smaller then arena->base_len"); + pos = LC_CLAMP(pos, arena->base_len, arena->len); + size_t size = arena->len - pos; + arena->len = pos; + LC_ASAN_POISON_MEMORY_REGION(arena->memory.data + arena->len, size); +} + +LC_FUNCTION void LC_PopSize(LC_Arena *arena, size_t size) { + LC_PopToPos(arena, arena->len - size); +} + +LC_FUNCTION void LC_DeallocateArena(LC_Arena *arena) { + LC_VDeallocate(&arena->memory); +} + +LC_FUNCTION void LC_ResetArena(LC_Arena *arena) { + LC_PopToPos(arena, 0); +} + +LC_FUNCTION size_t LC__AlignLen(LC_Arena *a) { + size_t align_offset = a->alignment ? LC_GetAlignOffset((uintptr_t)a->memory.data + (uintptr_t)a->len, a->alignment) : 0; + size_t aligned = a->len + align_offset; + return aligned; +} + +LC_FUNCTION void *LC__PushSizeNonZeroed(LC_Arena *a, size_t size) { + size_t align_offset = a->alignment ? LC_GetAlignOffset((uintptr_t)a->memory.data + (uintptr_t)a->len, a->alignment) : 0; + size_t aligned_len = a->len + align_offset; + size_t size_with_alignment = size + align_offset; + + if (a->len + size_with_alignment > a->memory.commit) { + if (a->memory.reserve == 0) { + LC_Assertf(0, "Pushing on uninitialized arena with zero initialization turned off"); + } + bool result = LC_VCommit(&a->memory, size_with_alignment + LC_COMMIT_ADD_SIZE); + LC_Assertf(result, "%s(%d): Failed to commit memory more memory! reserve: %zu commit: %zu len: %zu size_with_alignment: %zu", LC_BeginTempdSourceLoc.file, LC_BeginTempdSourceLoc.line, a->memory.reserve, a->memory.commit, a->len, size_with_alignment); + (void)result; + } + + uint8_t *result = a->memory.data + aligned_len; + a->len += size_with_alignment; + LC_Assertf(a->len <= a->memory.commit, "%s(%d): Reached commit boundary! reserve: %zu commit: %zu len: %zu base_len: %zu alignment: %d size_with_alignment: %zu", LC_BeginTempdSourceLoc.file, LC_BeginTempdSourceLoc.line, a->memory.reserve, a->memory.commit, a->len, a->base_len, a->alignment, size_with_alignment); + LC_ASAN_UNPOISON_MEMORY_REGION(result, size); + return (void *)result; +} + +LC_FUNCTION void *LC__PushSize(LC_Arena *arena, size_t size) { + void *result = LC__PushSizeNonZeroed(arena, size); + LC_MemoryZero(result, size); + return result; +} + +LC_FUNCTION LC_Arena LC_PushArena(LC_Arena *arena, size_t size) { + LC_Arena result; + LC_MemoryZero(&result, sizeof(result)); + result.memory.data = LC_PushArrayNonZeroed(arena, uint8_t, size); + result.memory.commit = size; + result.memory.reserve = size; + result.alignment = arena->alignment; + return result; +} + +LC_FUNCTION LC_Arena *LC_PushArenaP(LC_Arena *arena, size_t size) { + LC_Arena *result = LC_PushStruct(arena, LC_Arena); + *result = LC_PushArena(arena, size); + return result; +} + +LC_FUNCTION void LC_InitArenaEx(LC_Arena *a, size_t reserve) { + a->memory = LC_VReserve(reserve); + LC_ASAN_POISON_MEMORY_REGION(a->memory.data, a->memory.reserve); + a->alignment = LC_DEFAULT_ALIGNMENT; +} + +LC_FUNCTION void LC_InitArena(LC_Arena *a) { + LC_InitArenaEx(a, LC_DEFAULT_RESERVE_SIZE); +} + +LC_FUNCTION LC_Arena *LC_BootstrapArena(void) { + LC_Arena bootstrap_arena = {0}; + LC_InitArena(&bootstrap_arena); + + LC_Arena *arena = LC_PushStruct(&bootstrap_arena, LC_Arena); + *arena = bootstrap_arena; + arena->base_len = arena->len; + return arena; +} + +LC_FUNCTION void LC_InitArenaFromBuffer(LC_Arena *arena, void *buffer, size_t size) { + arena->memory.data = (uint8_t *)buffer; + arena->memory.commit = size; + arena->memory.reserve = size; + arena->alignment = LC_DEFAULT_ALIGNMENT; + LC_ASAN_POISON_MEMORY_REGION(arena->memory.data, arena->memory.reserve); +} + +LC_FUNCTION LC_TempArena LC_BeginTemp(LC_Arena *arena) { + LC_TempArena result; + result.pos = arena->len; + result.arena = arena; + return result; +} + +LC_FUNCTION void LC_EndTemp(LC_TempArena checkpoint) { + LC_PopToPos(checkpoint.arena, checkpoint.pos); +} + #if _WIN32 + const size_t LC_V_WIN32_PAGE_SIZE = 4096; + +LC_FUNCTION LC_VMemory LC_VReserve(size_t size) { + LC_VMemory result; + LC_MemoryZero(&result, sizeof(result)); + size_t adjusted_size = LC_AlignUp(size, LC_V_WIN32_PAGE_SIZE); + result.data = (uint8_t *)VirtualAlloc(0, adjusted_size, MEM_RESERVE, PAGE_READWRITE); + LC_Assertf(result.data, "Failed to reserve virtual memory"); + result.reserve = adjusted_size; + return result; +} + +LC_FUNCTION bool LC_VCommit(LC_VMemory *m, size_t commit) { + uint8_t *pointer = LC_V_AdvanceCommit(m, &commit, LC_V_WIN32_PAGE_SIZE); + if (pointer) { + void *result = VirtualAlloc(pointer, commit, MEM_COMMIT, PAGE_READWRITE); + LC_Assertf(result, "Failed to commit more memory"); + if (result) { + m->commit += commit; + return true; + } + } + return false; +} + +LC_FUNCTION void LC_VDeallocate(LC_VMemory *m) { + BOOL result = VirtualFree(m->data, 0, MEM_RELEASE); + LC_Assertf(result != 0, "Failed to release LC_VMemory"); +} + +LC_FUNCTION bool LC_VDecommitPos(LC_VMemory *m, size_t pos) { + size_t aligned = LC_AlignDown(pos, LC_V_WIN32_PAGE_SIZE); + size_t adjusted_pos = LC_CLAMP_TOP(aligned, m->commit); + size_t size_to_decommit = m->commit - adjusted_pos; + if (size_to_decommit) { + uint8_t *base_address = m->data + adjusted_pos; + BOOL result = VirtualFree(base_address, size_to_decommit, MEM_DECOMMIT); + if (result) { + m->commit -= size_to_decommit; + return true; + } + } + return false; +} + #elif __linux__ || __APPLE__ || __unix__ + #define LC_V_UNIX_PAGE_SIZE 4096 + +LC_FUNCTION LC_VMemory LC_VReserve(size_t size) { + LC_VMemory result = {}; + size_t size_aligned = LC_AlignUp(size, LC_V_UNIX_PAGE_SIZE); + result.data = (uint8_t *)mmap(0, size_aligned, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + LC_Assertf(result.data, "Failed to reserve memory using mmap!!"); + if (result.data) { + result.reserve = size_aligned; + } + return result; +} + +LC_FUNCTION bool LC_VCommit(LC_VMemory *m, size_t commit) { + uint8_t *pointer = LC_V_AdvanceCommit(m, &commit, LC_V_UNIX_PAGE_SIZE); + if (pointer) { + int mprotect_result = mprotect(pointer, commit, PROT_READ | PROT_WRITE); + LC_Assertf(mprotect_result == 0, "Failed to commit more memory using mmap"); + if (mprotect_result == 0) { + m->commit += commit; + return true; + } + } + return false; +} + +LC_FUNCTION void LC_VDeallocate(LC_VMemory *m) { + int result = munmap(m->data, m->reserve); + LC_Assertf(result == 0, "Failed to release virtual memory using munmap"); +} + #endif +#endif + +#if __clang__ + #pragma clang diagnostic pop +#endif + +#endif // LIB_COMPILER_IMPLEMENTATION + +/* +Copyright (c) 2024 Krzosa Karol + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ diff --git a/pkgs/libc/assert.lc b/pkgs/libc/assert.lc new file mode 100644 index 0000000..7d26c45 --- /dev/null +++ b/pkgs/libc/assert.lc @@ -0,0 +1,13 @@ +#`#include `; +@foreign assert :: proc(b: bool); @foreign + +#` +#if defined(_MSC_VER) + #define lc_assertion_debug_break() (__debugbreak(), 0) +#else + #define lc_assertion_debug_break() (__builtin_trap(), 0) +#endif +`; + + +debug_break :: proc(): int; @foreign(lc_assertion_debug_break) diff --git a/pkgs/libc/ctype.lc b/pkgs/libc/ctype.lc new file mode 100644 index 0000000..7d76404 --- /dev/null +++ b/pkgs/libc/ctype.lc @@ -0,0 +1,17 @@ +#`#include`; + +isalnum :: proc(c: int): int; @foreign +isalpha :: proc(c: int): int; @foreign +isblank :: proc(c: int): int; @foreign +iscntrl :: proc(c: int): int; @foreign +isdigit :: proc(c: int): int; @foreign +isgraph :: proc(c: int): int; @foreign +islower :: proc(c: int): int; @foreign +isprint :: proc(c: int): int; @foreign +ispunct :: proc(c: int): int; @foreign +isspace :: proc(c: int): int; @foreign +isupper :: proc(c: int): int; @foreign +isxdigit :: proc(c: int): int; @foreign + +tolower :: proc(c: int): int; @foreign +toupper :: proc(c: int): int; @foreign \ No newline at end of file diff --git a/pkgs/libc/errno.lc b/pkgs/libc/errno.lc new file mode 100644 index 0000000..3b706fd --- /dev/null +++ b/pkgs/libc/errno.lc @@ -0,0 +1,2 @@ +#`#include`; +errno: int; @foreign \ No newline at end of file diff --git a/pkgs/libc/math.lc b/pkgs/libc/math.lc new file mode 100644 index 0000000..1038436 --- /dev/null +++ b/pkgs/libc/math.lc @@ -0,0 +1,122 @@ +#`#include `; + +acos :: proc(x: double): double; @foreign +acosf :: proc(x: float): float; @foreign +asin :: proc(x: double): double; @foreign +asinf :: proc(x: float): float; @foreign +atan :: proc(x: double): double; @foreign +atanf :: proc(x: float): float; @foreign +atan2 :: proc(y: double, x: double): double; @foreign +atan2f :: proc(y: float, x: float): float; @foreign +cos :: proc(x: double): double; @foreign +cosf :: proc(x: float): float; @foreign +sin :: proc(x: double): double; @foreign +sinf :: proc(x: float): float; @foreign +tan :: proc(x: double): double; @foreign +tanf :: proc(x: float): float; @foreign + +acosh :: proc(x: double): double; @foreign +acoshf :: proc(x: float): float; @foreign +asinh :: proc(x: double): double; @foreign +asinhf :: proc(x: float): float; @foreign +atanh :: proc(x: double): double; @foreign +atanhf :: proc(x: float): float; @foreign +cosh :: proc(x: double): double; @foreign +coshf :: proc(x: float): float; @foreign +sinh :: proc(x: double): double; @foreign +sinhf :: proc(x: float): float; @foreign +tanh :: proc(x: double): double; @foreign +tanhf :: proc(x: float): float; @foreign + +exp :: proc(x: double): double; @foreign +expf :: proc(x: float): float; @foreign +exp2 :: proc(x: double): double; @foreign +exp2f :: proc(x: float): float; @foreign +expm1 :: proc(x: double): double; @foreign +expm1f :: proc(x: float): float; @foreign +frexp :: proc(value: double, exp: *int): double; @foreign +frexpf :: proc(value: float, exp: *int): float; @foreign +ilogb :: proc(x: double): int; @foreign +ilogbf :: proc(x: float): int; @foreign +ldexp :: proc(x: double, exp: int): double; @foreign +ldexpf :: proc(x: float, exp: int): float; @foreign +log :: proc(x: double): double; @foreign +logf :: proc(x: float): float; @foreign +log10 :: proc(x: double): double; @foreign +log10f :: proc(x: float): float; @foreign +log1p :: proc(x: double): double; @foreign +log1pf :: proc(x: float): float; @foreign +log2 :: proc(x: double): double; @foreign +log2f :: proc(x: float): float; @foreign +logb :: proc(x: double): double; @foreign +logbf :: proc(x: float): float; @foreign +modf :: proc(value: double, iptr: *double): double; @foreign +modff :: proc(value: float, iptr: *float): float; @foreign +scalbn :: proc(x: double, n: int): double; @foreign +scalbnf :: proc(x: float, n: int): float; @foreign +scalbln :: proc(x: double, n: long): double; @foreign +scalblnf :: proc(x: float, n: long): float; @foreign + +cbrt :: proc(x: double): double; @foreign +cbrtf :: proc(x: float): float; @foreign +fabs :: proc(x: double): double; @foreign +fabsf :: proc(x: float): float; @foreign +hypot :: proc(x: double, y: double): double; @foreign +hypotf :: proc(x: float, y: float): float; @foreign +pow :: proc(x: double, y: double): double; @foreign +powf :: proc(x: float, y: float): float; @foreign +sqrt :: proc(x: double): double; @foreign +sqrtf :: proc(x: float): float; @foreign + +erf :: proc(x: double): double; @foreign +erff :: proc(x: float): float; @foreign +erfc :: proc(x: double): double; @foreign +erfcf :: proc(x: float): float; @foreign +lgamma :: proc(x: double): double; @foreign +lgammaf :: proc(x: float): float; @foreign +tgamma :: proc(x: double): double; @foreign +tgammaf :: proc(x: float): float; @foreign + +ceil :: proc(x: double): double; @foreign +ceilf :: proc(x: float): float; @foreign +floor :: proc(x: double): double; @foreign +floorf :: proc(x: float): float; @foreign +nearbyint :: proc(x: double): double; @foreign +nearbyintf :: proc(x: float): float; @foreign +rint :: proc(x: double): double; @foreign +rintf :: proc(x: float): float; @foreign +lrint :: proc(x: double): long; @foreign +lrintf :: proc(x: float): long; @foreign +llrint :: proc(x: double): llong; @foreign +llrintf :: proc(x: float): llong; @foreign +round :: proc(x: double): double; @foreign +roundf :: proc(x: float): float; @foreign +lround :: proc(x: double): long; @foreign +lroundf :: proc(x: float): long; @foreign +llround :: proc(x: double): llong; @foreign +llroundf :: proc(x: float): llong; @foreign +trunc :: proc(x: double): double; @foreign +truncf :: proc(x: float): float; @foreign + +fmod :: proc(x: double, y: double): double; @foreign +fmodf :: proc(x: float, y: float): float; @foreign +remainder :: proc(x: double, y: double): double; @foreign +remainderf :: proc(x: float, y: float): float; @foreign +remquo :: proc(x: double, y: double, quo: *int): double; @foreign +remquof :: proc(x: float, y: float, quo: *int): float; @foreign + +copysign :: proc(x: double, y: double): double; @foreign +copysignf :: proc(x: float, y: float): float; @foreign +nan :: proc(tagp: *char): double; @foreign +nanf :: proc(tagp: *char): float; @foreign +nextafter :: proc(x: double, y: double): double; @foreign +nextafterf :: proc(x: float, y: float): float; @foreign + +fdim :: proc(x: double, y: double): double; @foreign +fdimf :: proc(x: float, y: float): float; @foreign +fmax :: proc(x: double, y: double): double; @foreign +fmaxf :: proc(x: float, y: float): float; @foreign +fmin :: proc(x: double, y: double): double; @foreign +fminf :: proc(x: float, y: float): float; @foreign +fma :: proc(x: double, y: double, z: double): double; @foreign +fmaf :: proc(x: float, y: float, z: float): float; @foreign \ No newline at end of file diff --git a/pkgs/libc/size_t.lc b/pkgs/libc/size_t.lc new file mode 100644 index 0000000..279b937 --- /dev/null +++ b/pkgs/libc/size_t.lc @@ -0,0 +1,3 @@ +import std_types "std_types"; + +size_t :: typedef std_types.usize; @foreign @weak \ No newline at end of file diff --git a/pkgs/libc/stdarg.lc b/pkgs/libc/stdarg.lc new file mode 100644 index 0000000..d2c23ce --- /dev/null +++ b/pkgs/libc/stdarg.lc @@ -0,0 +1,12 @@ +#` +#include +#define lc_va_arg_any(va) va_arg(va, LC_Any) +`; + +va_list :: struct { a: ullong; } @foreign +va_start :: proc(args: va_list, arg: *void); @foreign +va_end :: proc(args: va_list); @foreign +va_copy :: proc(args: va_list, src: va_list); @foreign +// va_arg :: proc(args: va_list, arg: *void); @foreign + +va_arg_any :: proc(args: va_list): Any; @foreign(lc_va_arg_any) diff --git a/pkgs/libc/stdio.lc b/pkgs/libc/stdio.lc new file mode 100644 index 0000000..70f455f --- /dev/null +++ b/pkgs/libc/stdio.lc @@ -0,0 +1,61 @@ +#`#include`; + +SEEK_SET :: 0; +SEEK_CUR :: 1; +SEEK_END :: 2; + +FILE :: struct {a: int;} @foreign +fpos_t :: typedef long; @foreign + +stderr: *FILE; @foreign +stdin: *FILE; @foreign +stdout: *FILE; @foreign + +remove :: proc(filename: *char): int; @foreign +rename :: proc(old: *char, new: *char): int; @foreign +tmpfile :: proc(): *FILE; @foreign +tmpnam :: proc(s: *char): *char; @foreign + +fclose :: proc(stream: *FILE): int; @foreign +fflush :: proc(stream: *FILE): int; @foreign +fopen :: proc(filename: *char, mode: *char): *FILE; @foreign +freopen :: proc(filename: *char, mode: *char, stream: *FILE): *FILE; @foreign +setbuf :: proc(stream: *FILE, buf: *char); @foreign +setvbuf :: proc(stream: *FILE, buf: *char, mode: int, size: size_t): int; @foreign + +fprintf :: proc(stream: *FILE, format: *char, ...): int; @foreign +fscanf :: proc(stream: *FILE, format: *char, ...): int; @foreign +printf :: proc(format: *char, ...): int; @foreign +scanf :: proc(format: *char, ...): int; @foreign +snprintf :: proc(s: *char, n: size_t, format: *char, ...): int; @foreign +sscanf :: proc(s: *char, format: *char, ...): int; @foreign +vfprintf :: proc(stream: *FILE, format: *char, arg: *va_list): int; @foreign +vfscanf :: proc(stream: *FILE, format: *char, arg: *va_list): int; @foreign +vprintf :: proc(format: *char, arg: *va_list): int; @foreign +vscanf :: proc(format: *char, arg: *va_list): int; @foreign +vsnprintf :: proc(s: *char, n: size_t, format: *char, arg: *va_list): int; @foreign +vsprintf :: proc(s: *char, format: *char, arg: *va_list): int; @foreign +vsscanf :: proc(s: *char, format: *char, arg: *va_list): int; @foreign + +fgetc :: proc(stream: *FILE): int; @foreign +fgets :: proc(s: *char, n: int, stream: *FILE): *char; @foreign +fputc :: proc(s: *char, stream: *FILE): int; @foreign +getc :: proc(stream: *FILE): int; @foreign +getchar :: proc(): int; @foreign +putc :: proc(c: int, stream: *FILE): int; @foreign +putchar :: proc(c: int): int; @foreign +puts :: proc(s: *char): int; @foreign +ungetc :: proc(c: int, stream: *FILE): int; @foreign +fread :: proc(ptr: *void, size: size_t, nmemb: size_t, stream: *FILE): size_t; @foreign +fwrite :: proc(ptr: *void, size: size_t, nmemb: size_t, stream: *FILE): size_t; @foreign + +fgetpos :: proc(stream: *FILE, pos: *fpos_t): int; @foreign +fseek :: proc(stream: *FILE, offset: long, whence: int): int; @foreign +fsetpos :: proc(stream: *FILE, pos: *fpos_t): int; @foreign +ftell :: proc(stream: *FILE): long; @foreign +rewind :: proc(stream: *FILE); @foreign + +clearerr :: proc(stream: *FILE); @foreign +feof :: proc(stream: *FILE): int; @foreign +ferror :: proc(stream: *FILE): int; @foreign +perror :: proc(s: *char); @foreign \ No newline at end of file diff --git a/pkgs/libc/stdlib.lc b/pkgs/libc/stdlib.lc new file mode 100644 index 0000000..13ee76f --- /dev/null +++ b/pkgs/libc/stdlib.lc @@ -0,0 +1,48 @@ +#`#include`; + +wchar_t :: typedef std_types.u16; @foreign +div_t :: struct { quot: int; rem: int; } @foreign +ldiv_t :: struct { quot: long; rem: long; } @foreign +lldiv_t :: struct { quot: llong; rem: llong; } @foreign + +atof :: proc(nptr: *char): double; @foreign +atoi :: proc(nptr: *char): int; @foreign +atol :: proc(nptr: *char): long; @foreign +atoll :: proc(nptr: *char): llong; @foreign +strtod :: proc(nptr: *char, endptr: **char): double; @foreign +strtof :: proc(nptr: *char, endptr: **char): float; @foreign +strtol :: proc(nptr: *char, endptr: **char, base: int): long; @foreign +strtoll :: proc(nptr: *char, endptr: **char, base: int): llong; @foreign +strtoul :: proc(nptr: *char, endptr: **char, base: int): ulong; @foreign +strtoull :: proc(nptr: *char, endptr: **char, base: int): ullong; @foreign + +rand :: proc(): int; @foreign +srand :: proc(seed: uint); @foreign + +calloc :: proc(nmemb: size_t, size: size_t): *void; @foreign +free :: proc(ptr: *void); @foreign +malloc :: proc(size: size_t): *void; @foreign +realloc :: proc(ptr: *void, size: size_t): *void; @foreign + +abort :: proc(); @foreign +atexit :: proc(func: proc()): int; @foreign +at_quick_exit :: proc(func: proc()): int; @foreign +exit :: proc(status: int); @foreign +_Exit :: proc(status: int); @foreign +getenv :: proc(name: *char): *char; @foreign +quick_exit :: proc(status: int); @foreign +system :: proc(cmd: *char): int; @foreign + +abs :: proc(j: int): int; @foreign +labs :: proc(j: long): long; @foreign +llabs :: proc(j: llong): llong; @foreign +div :: proc(numer: int, denom: int): div_t; @foreign +ldiv :: proc(numer: long, denom: long): ldiv_t; @foreign +lldiv :: proc(numer: llong, denom: llong): lldiv_t; @foreign + +mblen :: proc(s: *char, n: size_t): int; @foreign +mbtowc :: proc(pwc: *wchar_t, s: *char, n: size_t): int; @foreign +wctomb :: proc(s: *char, wc: wchar_t): int; @foreign + +mbstowcs :: proc(pwcs: *wchar_t, s: *char, n: size_t): size_t; @foreign +wcstombs :: proc(s: *char, pwcs: *wchar_t, n: size_t): size_t; @foreign \ No newline at end of file diff --git a/pkgs/libc/string.lc b/pkgs/libc/string.lc new file mode 100644 index 0000000..d2ead25 --- /dev/null +++ b/pkgs/libc/string.lc @@ -0,0 +1,28 @@ +#`#include`; + + +memset :: proc(s: *void, value: int, n: size_t): *void; @foreign +memcpy :: proc(s1: *void, s2: *void, n: size_t): *void; @foreign +memmove :: proc(s1: *void, s2: *void, n: size_t): *void; @foreign +strcpy :: proc(s1: *char, s2: *char): *char; @foreign +strncpy :: proc(s1: *char, s2: *char, n: size_t): *char; @foreign + +strcat :: proc(s1: *char, s2: *char): *char; @foreign +strncat :: proc(s1: *char, s2: *char, n: size_t): *char; @foreign + +memcmp :: proc(s1: *void, s2: *void, n: size_t): int; @foreign +strcmp :: proc(s1: *char, s2: *char): int; @foreign +strcoll :: proc(s1: *char, s2: *char): int; @foreign +strncmp :: proc(s1: *char, s2: *char, n: size_t): int; @foreign +strxfrm :: proc(s1: *char, s2: *char, n: size_t): size_t; @foreign + +memchr :: proc(s : *void, c: int, n: size_t): *void; @foreign +strchr :: proc(s : *char, c: int): *char; @foreign +strcspn :: proc(s1: *char, s2: *char): size_t; @foreign +strpbrk :: proc(s1: *char, s2: *char): *char; @foreign +strrchr :: proc(s : *char, c: int): *char; @foreign +strcpn :: proc(s1: *char, s2: *char): *char; @foreign +strtok :: proc(s1: *char, s2: *char): *char; @foreign + +strerror :: proc(errnum: int): *char; @foreign +strlen :: proc(s: *char): size_t; @foreign \ No newline at end of file diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/LICENSE b/pkgs/raylib/raylib-5.0_win64_msvc16/LICENSE new file mode 100644 index 0000000..ca631da --- /dev/null +++ b/pkgs/raylib/raylib-5.0_win64_msvc16/LICENSE @@ -0,0 +1,16 @@ +Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) + +This software is provided "as-is", without any express or implied warranty. In no event +will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial +applications, and to alter it and redistribute it freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you + wrote the original software. If you use this software in a product, an acknowledgment + in the product documentation would be appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be misrepresented + as being the original software. + + 3. This notice may not be removed or altered from any source distribution. diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/include/raylib.h b/pkgs/raylib/raylib-5.0_win64_msvc16/include/raylib.h new file mode 100644 index 0000000..460919f --- /dev/null +++ b/pkgs/raylib/raylib-5.0_win64_msvc16/include/raylib.h @@ -0,0 +1,1662 @@ +/********************************************************************************************** +* +* raylib v5.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +* +* FEATURES: +* - NO external dependencies, all required libraries included with raylib +* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, +* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. +* - Written in plain C code (C99) in PascalCase/camelCase notation +* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) +* - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] +* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +* - Flexible Materials system, supporting classic maps and PBR maps +* - Animated 3D models supported (skeletal bones animation) (IQM) +* - Shaders support, including Model shaders and Postprocessing shaders +* - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] +* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +* - VR stereo rendering with configurable HMD device parameters +* - Bindings to multiple programming languages available! +* +* NOTES: +* - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] +* - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) +* - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) +* - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) +* +* DEPENDENCIES (included): +* [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) +* [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) +* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management +* +* OPTIONAL DEPENDENCIES (included): +* [rcore] msf_gif (Miles Fogle) for GIF recording +* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm +* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm +* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) +* [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms +* [rtext] stb_truetype (Sean Barret) for ttf fonts loading +* [rtext] stb_rect_pack (Sean Barret) for rectangles packing +* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation +* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) +* [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) +* [raudio] dr_wav (David Reid) for WAV audio file loading +* [raudio] dr_flac (David Reid) for FLAC audio file loading +* [raudio] dr_mp3 (David Reid) for MP3 audio file loading +* [raudio] stb_vorbis (Sean Barret) for OGG audio loading +* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +* +* +* LICENSE: zlib/libpng +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYLIB_H +#define RAYLIB_H + +#include // Required for: va_list - Only used by TraceLogCallback + +#define RAYLIB_VERSION_MAJOR 5 +#define RAYLIB_VERSION_MINOR 0 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_VERSION "5.0" + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #if defined(__TINYC__) + #define __declspec(x) __attribute__((x)) + #endif + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +//---------------------------------------------------------------------------------- +// Some basic Defines +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Allow custom memory allocators +// NOTE: Require recompiling raylib sources +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(ptr,sz) realloc(ptr,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(ptr) free(ptr) +#endif + +// NOTE: MSVC C++ compiler does not support compound literals (C99 feature) +// Plain structures in C++ (without constructors) can be initialized with { } +// This is called aggregate initialization (C++11 feature) +#if defined(__cplusplus) + #define CLITERAL(type) type +#else + #define CLITERAL(type) (type) +#endif + +// Some compilers (mostly macos clang) default to C++98, +// where aggregate initialization can't be used +// So, give a more clear error stating how to fix this +#if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L) + #error "C++11 or later is required. Add -std=c++11" +#endif + +// NOTE: We set some defines with some data types declared by raylib +// Other modules (raymath, rlgl) also require some of those types, so, +// to be able to use those other modules as standalone (not depending on raylib) +// this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE + +// Some Basic Colors +// NOTE: Custom raylib color palette for amazing visuals on WHITE background +#define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray +#define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray +#define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray +#define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow +#define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold +#define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange +#define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink +#define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red +#define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon +#define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green +#define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime +#define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green +#define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue +#define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue +#define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue +#define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple +#define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet +#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple +#define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige +#define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown +#define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown + +#define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White +#define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black +#define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta +#define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) + +//---------------------------------------------------------------------------------- +// Structures Definition +//---------------------------------------------------------------------------------- +// Boolean type +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) + typedef enum bool { false = 0, true = !false } bool; + #define RL_BOOL_TYPE +#endif + +// Vector2, 2 components +typedef struct Vector2 { + float x; // Vector x component + float y; // Vector y component +} Vector2; + +// Vector3, 3 components +typedef struct Vector3 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component +} Vector3; + +// Vector4, 4 components +typedef struct Vector4 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component + float w; // Vector w component +} Vector4; + +// Quaternion, 4 components (Vector4 alias) +typedef Vector4 Quaternion; + +// Matrix, 4x4 components, column major, OpenGL style, right-handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; + +// Color, 4 components, R8G8B8A8 (32bit) +typedef struct Color { + unsigned char r; // Color red value + unsigned char g; // Color green value + unsigned char b; // Color blue value + unsigned char a; // Color alpha value +} Color; + +// Rectangle, 4 components +typedef struct Rectangle { + float x; // Rectangle top-left corner position x + float y; // Rectangle top-left corner position y + float width; // Rectangle width + float height; // Rectangle height +} Rectangle; + +// Image, pixel data stored in CPU memory (RAM) +typedef struct Image { + void *data; // Image raw data + int width; // Image base width + int height; // Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Image; + +// Texture, tex data stored in GPU memory (VRAM) +typedef struct Texture { + unsigned int id; // OpenGL texture id + int width; // Texture base width + int height; // Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (PixelFormat type) +} Texture; + +// Texture2D, same as Texture +typedef Texture Texture2D; + +// TextureCubemap, same as Texture +typedef Texture TextureCubemap; + +// RenderTexture, fbo for texture rendering +typedef struct RenderTexture { + unsigned int id; // OpenGL framebuffer object id + Texture texture; // Color buffer attachment texture + Texture depth; // Depth buffer attachment texture +} RenderTexture; + +// RenderTexture2D, same as RenderTexture +typedef RenderTexture RenderTexture2D; + +// NPatchInfo, n-patch layout info +typedef struct NPatchInfo { + Rectangle source; // Texture source rectangle + int left; // Left border offset + int top; // Top border offset + int right; // Right border offset + int bottom; // Bottom border offset + int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 +} NPatchInfo; + +// GlyphInfo, font characters glyphs info +typedef struct GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + Image image; // Character image data +} GlyphInfo; + +// Font, font texture and GlyphInfo array data +typedef struct Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + Texture2D texture; // Texture atlas containing the glyphs + Rectangle *recs; // Rectangles in texture for the glyphs + GlyphInfo *glyphs; // Glyphs info data +} Font; + +// Camera, defines position/orientation in 3d space +typedef struct Camera3D { + Vector3 position; // Camera position + Vector3 target; // Camera target it looks-at + Vector3 up; // Camera up vector (rotation over its axis) + float fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic + int projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC +} Camera3D; + +typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D + +// Camera2D, defines position/orientation in 2d space +typedef struct Camera2D { + Vector2 offset; // Camera offset (displacement from target) + Vector2 target; // Camera target (rotation and zoom origin) + float rotation; // Camera rotation in degrees + float zoom; // Camera zoom (scaling), should be 1.0f by default +} Camera2D; + +// Mesh, vertex data and vao/vbo +typedef struct Mesh { + int vertexCount; // Number of vertices stored in arrays + int triangleCount; // Number of triangles stored (indexed or not) + + // Vertex attributes data + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + float *texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) + float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) + + // Animation vertex data + float *animVertices; // Animated vertex positions (after bones transformations) + float *animNormals; // Animated normals (after bones transformations) + unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) + float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) + + // OpenGL identifiers + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) +} Mesh; + +// Shader +typedef struct Shader { + unsigned int id; // Shader program id + int *locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS) +} Shader; + +// MaterialMap +typedef struct MaterialMap { + Texture2D texture; // Material map texture + Color color; // Material map color + float value; // Material map value +} MaterialMap; + +// Material, includes shader and maps +typedef struct Material { + Shader shader; // Material shader + MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS) + float params[4]; // Material generic parameters (if required) +} Material; + +// Transform, vertex transformation data +typedef struct Transform { + Vector3 translation; // Translation + Quaternion rotation; // Rotation + Vector3 scale; // Scale +} Transform; + +// Bone, skeletal animation bone +typedef struct BoneInfo { + char name[32]; // Bone name + int parent; // Bone parent +} BoneInfo; + +// Model, meshes, materials and animation data +typedef struct Model { + Matrix transform; // Local transform matrix + + int meshCount; // Number of meshes + int materialCount; // Number of materials + Mesh *meshes; // Meshes array + Material *materials; // Materials array + int *meshMaterial; // Mesh material number + + // Animation data + int boneCount; // Number of bones + BoneInfo *bones; // Bones information (skeleton) + Transform *bindPose; // Bones base transformation (pose) +} Model; + +// ModelAnimation +typedef struct ModelAnimation { + int boneCount; // Number of bones + int frameCount; // Number of animation frames + BoneInfo *bones; // Bones information (skeleton) + Transform **framePoses; // Poses array by frame + char name[32]; // Animation name +} ModelAnimation; + +// Ray, ray for raycasting +typedef struct Ray { + Vector3 position; // Ray position (origin) + Vector3 direction; // Ray direction +} Ray; + +// RayCollision, ray hit information +typedef struct RayCollision { + bool hit; // Did the ray hit something? + float distance; // Distance to the nearest hit + Vector3 point; // Point of the nearest hit + Vector3 normal; // Surface normal of hit +} RayCollision; + +// BoundingBox +typedef struct BoundingBox { + Vector3 min; // Minimum vertex box-corner + Vector3 max; // Maximum vertex box-corner +} BoundingBox; + +// Wave, audio wave data +typedef struct Wave { + unsigned int frameCount; // Total number of frames (considering channels) + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) + void *data; // Buffer data pointer +} Wave; + +// Opaque structs declaration +// NOTE: Actual structs are defined internally in raudio module +typedef struct rAudioBuffer rAudioBuffer; +typedef struct rAudioProcessor rAudioProcessor; + +// AudioStream, custom audio stream +typedef struct AudioStream { + rAudioBuffer *buffer; // Pointer to internal data used by the audio system + rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects + + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) +} AudioStream; + +// Sound +typedef struct Sound { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) +} Sound; + +// Music, audio stream, anything longer than ~10 seconds should be streamed +typedef struct Music { + AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) + bool looping; // Music looping enable + + int ctxType; // LC_Type of music context (audio filetype) + void *ctxData; // Audio context data, depends on type +} Music; + +// VrDeviceInfo, Head-Mounted-Display device parameters +typedef struct VrDeviceInfo { + int hResolution; // Horizontal resolution in pixels + int vResolution; // Vertical resolution in pixels + float hScreenSize; // Horizontal size in meters + float vScreenSize; // Vertical size in meters + float vScreenCenter; // Screen center in meters + float eyeToScreenDistance; // Distance between eye and display in meters + float lensSeparationDistance; // Lens separation distance in meters + float interpupillaryDistance; // IPD (distance between pupils) in meters + float lensDistortionValues[4]; // Lens distortion constant parameters + float chromaAbCorrection[4]; // Chromatic aberration correction parameters +} VrDeviceInfo; + +// VrStereoConfig, VR stereo rendering configuration for simulator +typedef struct VrStereoConfig { + Matrix projection[2]; // VR projection matrices (per eye) + Matrix viewOffset[2]; // VR view offset matrices (per eye) + float leftLensCenter[2]; // VR left lens center + float rightLensCenter[2]; // VR right lens center + float leftScreenCenter[2]; // VR left screen center + float rightScreenCenter[2]; // VR right screen center + float scale[2]; // VR distortion scale + float scaleIn[2]; // VR distortion scale in +} VrStereoConfig; + +// File path list +typedef struct FilePathList { + unsigned int capacity; // Filepaths max entries + unsigned int count; // Filepaths entries count + char **paths; // Filepaths entries +} FilePathList; + +// Automation event +typedef struct AutomationEvent { + unsigned int frame; // Event frame + unsigned int type; // Event type (AutomationEventType) + int params[4]; // Event parameters (if required) +} AutomationEvent; + +// Automation event list +typedef struct AutomationEventList { + unsigned int capacity; // Events max entries (MAX_AUTOMATION_EVENTS) + unsigned int count; // Events entries count + AutomationEvent *events; // Events entries +} AutomationEventList; + +//---------------------------------------------------------------------------------- +// Enumerators Definition +//---------------------------------------------------------------------------------- +// System/Window config flags +// NOTE: Every bit registers one state (use it with bit masks) +// By default all flags are set to 0 +typedef enum { + FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU + FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen + FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window + FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons) + FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window + FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify) + FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor) + FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused + FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top + FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized + FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer + FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI + FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED + FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode + FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X + FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D) +} ConfigFlags; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + LOG_ALL = 0, // Display all logs + LOG_TRACE, // Trace logging, intended for internal use only + LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + LOG_INFO, // Info logging, used for program execution info + LOG_WARNING, // Warning logging, used on recoverable failures + LOG_ERROR, // Error logging, used on unrecoverable failures + LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + LOG_NONE // Disable logging +} TraceLogLevel; + +// Keyboard keys (US keyboard layout) +// NOTE: Use GetKeyPressed() to allow redefining +// required keys for alternative layouts +typedef enum { + KEY_NULL = 0, // Key: NULL, used for no key pressed + // Alphanumeric keys + KEY_APOSTROPHE = 39, // Key: ' + KEY_COMMA = 44, // Key: , + KEY_MINUS = 45, // Key: - + KEY_PERIOD = 46, // Key: . + KEY_SLASH = 47, // Key: / + KEY_ZERO = 48, // Key: 0 + KEY_ONE = 49, // Key: 1 + KEY_TWO = 50, // Key: 2 + KEY_THREE = 51, // Key: 3 + KEY_FOUR = 52, // Key: 4 + KEY_FIVE = 53, // Key: 5 + KEY_SIX = 54, // Key: 6 + KEY_SEVEN = 55, // Key: 7 + KEY_EIGHT = 56, // Key: 8 + KEY_NINE = 57, // Key: 9 + KEY_SEMICOLON = 59, // Key: ; + KEY_EQUAL = 61, // Key: = + KEY_A = 65, // Key: A | a + KEY_B = 66, // Key: B | b + KEY_C = 67, // Key: C | c + KEY_D = 68, // Key: D | d + KEY_E = 69, // Key: E | e + KEY_F = 70, // Key: F | f + KEY_G = 71, // Key: G | g + KEY_H = 72, // Key: H | h + KEY_I = 73, // Key: I | i + KEY_J = 74, // Key: J | j + KEY_K = 75, // Key: K | k + KEY_L = 76, // Key: L | l + KEY_M = 77, // Key: M | m + KEY_N = 78, // Key: N | n + KEY_O = 79, // Key: O | o + KEY_P = 80, // Key: P | p + KEY_Q = 81, // Key: Q | q + KEY_R = 82, // Key: R | r + KEY_S = 83, // Key: S | s + KEY_T = 84, // Key: T | t + KEY_U = 85, // Key: U | u + KEY_V = 86, // Key: V | v + KEY_W = 87, // Key: W | w + KEY_X = 88, // Key: X | x + KEY_Y = 89, // Key: Y | y + KEY_Z = 90, // Key: Z | z + KEY_LEFT_BRACKET = 91, // Key: [ + KEY_BACKSLASH = 92, // Key: '\' + KEY_RIGHT_BRACKET = 93, // Key: ] + KEY_GRAVE = 96, // Key: ` + // Function keys + KEY_SPACE = 32, // Key: Space + KEY_ESCAPE = 256, // Key: Esc + KEY_ENTER = 257, // Key: Enter + KEY_TAB = 258, // Key: Tab + KEY_BACKSPACE = 259, // Key: Backspace + KEY_INSERT = 260, // Key: Ins + KEY_DELETE = 261, // Key: Del + KEY_RIGHT = 262, // Key: Cursor right + KEY_LEFT = 263, // Key: Cursor left + KEY_DOWN = 264, // Key: Cursor down + KEY_UP = 265, // Key: Cursor up + KEY_PAGE_UP = 266, // Key: Page up + KEY_PAGE_DOWN = 267, // Key: Page down + KEY_HOME = 268, // Key: Home + KEY_END = 269, // Key: End + KEY_CAPS_LOCK = 280, // Key: Caps lock + KEY_SCROLL_LOCK = 281, // Key: Scroll down + KEY_NUM_LOCK = 282, // Key: Num lock + KEY_PRINT_SCREEN = 283, // Key: Print screen + KEY_PAUSE = 284, // Key: Pause + KEY_F1 = 290, // Key: F1 + KEY_F2 = 291, // Key: F2 + KEY_F3 = 292, // Key: F3 + KEY_F4 = 293, // Key: F4 + KEY_F5 = 294, // Key: F5 + KEY_F6 = 295, // Key: F6 + KEY_F7 = 296, // Key: F7 + KEY_F8 = 297, // Key: F8 + KEY_F9 = 298, // Key: F9 + KEY_F10 = 299, // Key: F10 + KEY_F11 = 300, // Key: F11 + KEY_F12 = 301, // Key: F12 + KEY_LEFT_SHIFT = 340, // Key: Shift left + KEY_LEFT_CONTROL = 341, // Key: Control left + KEY_LEFT_ALT = 342, // Key: Alt left + KEY_LEFT_SUPER = 343, // Key: Super left + KEY_RIGHT_SHIFT = 344, // Key: Shift right + KEY_RIGHT_CONTROL = 345, // Key: Control right + KEY_RIGHT_ALT = 346, // Key: Alt right + KEY_RIGHT_SUPER = 347, // Key: Super right + KEY_KB_MENU = 348, // Key: KB menu + // Keypad keys + KEY_KP_0 = 320, // Key: Keypad 0 + KEY_KP_1 = 321, // Key: Keypad 1 + KEY_KP_2 = 322, // Key: Keypad 2 + KEY_KP_3 = 323, // Key: Keypad 3 + KEY_KP_4 = 324, // Key: Keypad 4 + KEY_KP_5 = 325, // Key: Keypad 5 + KEY_KP_6 = 326, // Key: Keypad 6 + KEY_KP_7 = 327, // Key: Keypad 7 + KEY_KP_8 = 328, // Key: Keypad 8 + KEY_KP_9 = 329, // Key: Keypad 9 + KEY_KP_DECIMAL = 330, // Key: Keypad . + KEY_KP_DIVIDE = 331, // Key: Keypad / + KEY_KP_MULTIPLY = 332, // Key: Keypad * + KEY_KP_SUBTRACT = 333, // Key: Keypad - + KEY_KP_ADD = 334, // Key: Keypad + + KEY_KP_ENTER = 335, // Key: Keypad Enter + KEY_KP_EQUAL = 336, // Key: Keypad = + // Android key buttons + KEY_BACK = 4, // Key: Android back button + KEY_MENU = 82, // Key: Android menu button + KEY_VOLUME_UP = 24, // Key: Android volume up button + KEY_VOLUME_DOWN = 25 // Key: Android volume down button +} KeyboardKey; + +// Add backwards compatibility support for deprecated names +#define MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT +#define MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT +#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE + +// Mouse buttons +typedef enum { + MOUSE_BUTTON_LEFT = 0, // Mouse button left + MOUSE_BUTTON_RIGHT = 1, // Mouse button right + MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel) + MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device) + MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device) + MOUSE_BUTTON_FORWARD = 5, // Mouse button forward (advanced mouse device) + MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device) +} MouseButton; + +// Mouse cursor +typedef enum { + MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape + MOUSE_CURSOR_ARROW = 1, // Arrow shape + MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape + MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape + MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor + MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape + MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_ALL = 9, // The omnidirectional resize/move cursor shape + MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape +} MouseCursor; + +// Gamepad buttons +typedef enum { + GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking + GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button + GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button + GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button + GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button + GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) + GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X) + GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) + GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) + GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button + GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button + GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select) + GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) + GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start) + GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left + GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right +} GamepadButton; + +// Gamepad axis +typedef enum { + GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis + GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis + GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis + GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis + GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1] + GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1] +} GamepadAxis; + +// Material map index +typedef enum { + MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE) + MATERIAL_MAP_METALNESS, // Metalness material (same as: MATERIAL_MAP_SPECULAR) + MATERIAL_MAP_NORMAL, // Normal material + MATERIAL_MAP_ROUGHNESS, // Roughness material + MATERIAL_MAP_OCCLUSION, // Ambient occlusion material + MATERIAL_MAP_EMISSION, // Emission material + MATERIAL_MAP_HEIGHT, // Heightmap material + MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_BRDF // Brdf material +} MaterialMapIndex; + +#define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO +#define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS + +// Shader location index +typedef enum { + SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) + SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) + SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} ShaderLocationIndex; + +#define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO +#define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + SHADER_UNIFORM_INT, // Shader uniform type: int + SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} ShaderUniformDataType; + +// Shader attribute data types +typedef enum { + SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} ShaderAttributeDataType; + +// Pixel formats +// NOTE: Support depends on OpenGL version and platform +typedef enum { + PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} PixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + TEXTURE_FILTER_BILINEAR, // Linear filtering + TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} TextureFilter; + +// Texture parameters: wrap mode +typedef enum { + TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode + TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode + TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode + TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode +} TextureWrap; + +// Cubemap layouts +typedef enum { + CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type + CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces + CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by a horizontal line with faces + CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces + CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces + CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirrectangular map) +} CubemapLayout; + +// Font type, defines generation method +typedef enum { + FONT_DEFAULT = 0, // Default font generation, anti-aliased + FONT_BITMAP, // Bitmap font generation, no anti-aliasing + FONT_SDF // SDF font generation, requires external shader +} FontType; + +// Color blending modes (pre-defined) +typedef enum { + BLEND_ALPHA = 0, // Blend textures considering alpha (default) + BLEND_ADDITIVE, // Blend textures adding colors + BLEND_MULTIPLIED, // Blend textures multiplying colors + BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + BLEND_CUSTOM_SEPARATE // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate()) +} BlendMode; + +// Gesture +// NOTE: Provided as bit-wise flags to enable only desired gestures +typedef enum { + GESTURE_NONE = 0, // No gesture + GESTURE_TAP = 1, // Tap gesture + GESTURE_DOUBLETAP = 2, // Double tap gesture + GESTURE_HOLD = 4, // Hold gesture + GESTURE_DRAG = 8, // Drag gesture + GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture + GESTURE_SWIPE_LEFT = 32, // Swipe left gesture + GESTURE_SWIPE_UP = 64, // Swipe up gesture + GESTURE_SWIPE_DOWN = 128, // Swipe down gesture + GESTURE_PINCH_IN = 256, // Pinch in gesture + GESTURE_PINCH_OUT = 512 // Pinch out gesture +} Gesture; + +// Camera system modes +typedef enum { + CAMERA_CUSTOM = 0, // Custom camera + CAMERA_FREE, // Free camera + CAMERA_ORBITAL, // Orbital camera + CAMERA_FIRST_PERSON, // First person camera + CAMERA_THIRD_PERSON // Third person camera +} CameraMode; + +// Camera projection +typedef enum { + CAMERA_PERSPECTIVE = 0, // Perspective projection + CAMERA_ORTHOGRAPHIC // Orthographic projection +} CameraProjection; + +// N-patch layout +typedef enum { + NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles + NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles + NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles +} NPatchLayout; + +// Callbacks to hook some internal functions +// WARNING: These callbacks are intended for advance users +typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages +typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data +typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize); // FileIO: Save binary data +typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +//------------------------------------------------------------------------------------ +// Global Variables Definition +//------------------------------------------------------------------------------------ +// It's lonely here... + +//------------------------------------------------------------------------------------ +// Window and Graphics Device Functions (Module: core) +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +// Window-related functions +RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI void CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool WindowShouldClose(void); // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked) +RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void ToggleBorderlessWindowed(void); // Toggle window state: borderless windowed (only PLATFORM_DESKTOP) +RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void SetWindowIcon(Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowIcons(Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB) +RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window +RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowMaxSize(int width, int height); // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE) +RLAPI void SetWindowSize(int width, int height); // Set window dimensions +RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void SetWindowFocused(void); // Set window focused (only PLATFORM_DESKTOP) +RLAPI void *GetWindowHandle(void); // Get native window handle +RLAPI int GetScreenWidth(void); // Get current screen width +RLAPI int GetScreenHeight(void); // Get current screen height +RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int GetMonitorCount(void); // Get number of connected monitors +RLAPI int GetCurrentMonitor(void); // Get current connected monitor +RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor) +RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor) +RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres +RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres +RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate +RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor +RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor +RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the specified monitor +RLAPI void SetClipboardText(const char *text); // Set clipboard text content +RLAPI const char *GetClipboardText(void); // Get clipboard text content +RLAPI void EnableEventWaiting(void); // Enable waiting for events on EndDrawing(), no automatic event polling +RLAPI void DisableEventWaiting(void); // Disable waiting for events on EndDrawing(), automatic events polling + +// Cursor-related functions +RLAPI void ShowCursor(void); // Shows cursor +RLAPI void HideCursor(void); // Hides cursor +RLAPI bool IsCursorHidden(void); // Check if cursor is not visible +RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) +RLAPI void DisableCursor(void); // Disables cursor (lock cursor) +RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the screen + +// Drawing-related functions +RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) +RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing +RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering) +RLAPI void BeginMode2D(Camera2D camera); // Begin 2D mode with custom camera (2D) +RLAPI void EndMode2D(void); // Ends 2D mode with custom camera +RLAPI void BeginMode3D(Camera3D camera); // Begin 3D mode with custom camera (3D) +RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode +RLAPI void BeginTextureMode(RenderTexture2D target); // Begin drawing to render texture +RLAPI void EndTextureMode(void); // Ends drawing to render texture +RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing +RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) +RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom) +RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) +RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) +RLAPI void EndScissorMode(void); // End scissor mode +RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator) +RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator) + +// VR stereo config functions for VR simulator +RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters +RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config + +// Shader management functions +// NOTE: Shader functionality is not available on OpenGL 1.1 +RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations +RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations +RLAPI bool IsShaderReady(Shader shader); // Check if a shader is ready +RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location +RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location +RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value +RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector +RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4) +RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d) +RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) + +// Screen-space-related functions +RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from mouse position +RLAPI Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix) +RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix +RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position +RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position +RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position +RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position + +// Timing-related functions +RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) +RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() +RLAPI int GetFPS(void); // Get current FPS + +// Custom frame control functions +// NOTE: Those functions are intended for advance users that want full control over the frame processing +// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() +// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL +RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) +RLAPI void PollInputEvents(void); // Register all input events +RLAPI void WaitTime(double seconds); // Wait for some time (halt program execution) + +// Random values generation functions +RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated +RLAPI void UnloadRandomSequence(int *sequence); // Unload random values sequence + +// Misc. functions +RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) +RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) + +// NOTE: Following functions implemented in module [utils] +//------------------------------------------------------------------ +RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator +RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator +RLAPI void MemFree(void *ptr); // Internal memory free + +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// Files management functions +RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read) +RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success +RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success +RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() +RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success +//------------------------------------------------------------------ + +// File system functions +RLAPI bool FileExists(const char *fileName); // Check if file exists +RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string) +RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success +RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory +RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths +RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan +RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths +RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window +RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths +RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths +RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) + +// Compression/Encoding functionality +RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree() +RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree() +RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be MemFree() +RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be MemFree() + +// Automation events functionality +RLAPI AutomationEventList LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS +RLAPI void UnloadAutomationEventList(AutomationEventList *list); // Unload automation events list from file +RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName); // Export automation events list as text file +RLAPI void SetAutomationEventList(AutomationEventList *list); // Set automation event list to record to +RLAPI void SetAutomationEventBaseFrame(int frame); // Set automation event internal base frame to start recording +RLAPI void StartAutomationEventRecording(void); // Start recording automation events (AutomationEventList must be set) +RLAPI void StopAutomationEventRecording(void); // Stop recording automation events +RLAPI void PlayAutomationEvent(AutomationEvent event); // Play a recorded automation event + +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ + +// Input-related functions: keyboard +RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool IsKeyPressedRepeat(int key); // Check if a key has been pressed again (Only PLATFORM_DESKTOP) +RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty +RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) + +// Input-related functions: gamepads +RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) + +// Input-related functions: mouse +RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int GetMouseX(void); // Get mouse position X +RLAPI int GetMouseY(void); // Get mouse position Y +RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger +RLAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y +RLAPI void SetMouseCursor(int cursor); // Set mouse cursor + +// Input-related functions: touch +RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) +RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) +RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) +RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index +RLAPI int GetTouchPointCount(void); // Get number of touch points + +//------------------------------------------------------------------------------------ +// Gestures and Touch Handling Functions (Module: rgestures) +//------------------------------------------------------------------------------------ +RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +RLAPI bool IsGestureDetected(unsigned int gesture); // Check if a gesture have been detected +RLAPI int GetGestureDetected(void); // Get latest detected gesture +RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds +RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector +RLAPI float GetGestureDragAngle(void); // Get gesture drag angle +RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta +RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle + +//------------------------------------------------------------------------------------ +// Camera System Functions (Module: rcamera) +//------------------------------------------------------------------------------------ +RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode +RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation + +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ +// Set texture and rectangle to be used on shapes drawing +// NOTE: It can be useful when using basic shapes and one single font, +// defining a font char white rectangle would allow drawing everything in a single draw call +RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing + +// Basic shapes drawing functions +RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel +RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) +RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (using gl lines) +RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line (using triangles/quads) +RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence (using gl lines) +RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw line segment cubic-bezier in-out interpolation +RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle +RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color); // Draw circle outline (Vector version) +RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// Splines drawing functions +RLAPI void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Linear, minimum 2 points +RLAPI void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: B-Spline, minimum 4 points +RLAPI void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Catmull-Rom, minimum 4 points +RLAPI void DrawSplineBezierQuadratic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...] +RLAPI void DrawSplineBezierCubic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...] +RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color); // Draw spline segment: Linear, 2 points +RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points +RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points +RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point +RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points + +// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] +RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t); // Get (evaluate) spline point: Linear +RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: B-Spline +RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: Catmull-Rom +RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t); // Get (evaluate) spline point: Quadratic Bezier +RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t); // Get (evaluate) spline point: Cubic Bezier + +// Basic shapes collision detection functions +RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices +RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference +RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] +RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision + +//------------------------------------------------------------------------------------ +// Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ + +// Image loading functions +// NOTE: These functions do not require GPU access +RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +RLAPI Image LoadImageSvg(const char *fileNameOrString, int width, int height); // Load image from SVG file data or string with specified size +RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' +RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data +RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) +RLAPI bool IsImageReady(Image image); // Check if an image is ready +RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) +RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success +RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize); // Export image to memory buffer +RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// Image generation functions +RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +RLAPI Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end); // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient +RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +RLAPI Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer); // Generate image: square gradient +RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells +RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data + +// Image manipulation functions +RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece +RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) +RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format +RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) +RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value +RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color +RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image +RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel +RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation +RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color +RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image +RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +RLAPI void ImageFlipVertical(Image *image); // Flip image vertically +RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally +RLAPI void ImageRotate(Image *image, int degrees); // Rotate image by input angle in degrees (-359 to 359) +RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg +RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg +RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint +RLAPI void ImageColorInvert(Image *image); // Modify image color: invert +RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale +RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color +RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit) +RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit) +RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors() +RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette() +RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle +RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position + +// Image drawing functions +// NOTE: Image software-rendering functions (CPU) +RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color +RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image +RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) +RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image +RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) +RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image +RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) +RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image +RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) +RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) +RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image +RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image +RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) +RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) +RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) + +// Texture loading functions +// NOTE: These functions require GPU access +RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data +RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported +RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +RLAPI bool IsTextureReady(Texture2D texture); // Check if a texture is ready +RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) +RLAPI bool IsRenderTextureReady(RenderTexture2D target); // Check if a render texture is ready +RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data +RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data + +// Texture configuration functions +RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture +RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode +RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode + +// Texture drawing functions +RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely + +// Color/pixel related functions +RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color +RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1] +RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] +RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] +RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] +RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color +RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f +RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f +RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint +RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value +RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format +RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer +RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format + +//------------------------------------------------------------------------------------ +// Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ + +// Font loading/unloading functions +RLAPI Font GetFontDefault(void); // Get the default Font +RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set +RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool IsFontReady(Font font); // Check if a font is ready +RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use +RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) +RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// Text drawing functions +RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// Text font info functions +RLAPI void SetTextLineSpacing(int spacing); // Set vertical line spacing when drawing with line-breaks +RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// Text codepoints management functions (unicode characters) +RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array +RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array +RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter +RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory +RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string +RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) + +// Text strings management functions (no UTF-8 strings, only byte chars) +// NOTE: Some strings allocate memory internally for returned strings, just be careful! +RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending +RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) +RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string +RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) +RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) +RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string +RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string +RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string +RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) + +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Basic geometric 3D shapes drawing functions +RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line +RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space +RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points +RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube +RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires +RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) +RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos +RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos +RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos +RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos +RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ +RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line +RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) + +//------------------------------------------------------------------------------------ +// Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ + +// Model management functions +RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) +RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) +RLAPI bool IsModelReady(Model model); // Check if a model is ready +RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) +RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) + +// Model drawing functions +RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters +RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) +RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters +RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) +RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture +RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source +RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation + +// Mesh management functions +RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids +RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index +RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU +RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform +RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms +RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success +RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits +RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents + +// Mesh generation functions +RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh +RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh +RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh +RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data +RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data + +// Material loading/unloading functions +RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +RLAPI bool IsMaterialReady(Material material); // Check if a material is ready +RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) +RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh + +// Model animations loading/unloading functions +RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount); // Load model animations from file +RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose +RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount); // Unload animation array data +RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// Collision detection functions +RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// Audio device management functions +RLAPI void InitAudioDevice(void); // Initialize audio device and context +RLAPI void CloseAudioDevice(void); // Close the audio device and context +RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void SetMasterVolume(float volume); // Set master volume (listener) +RLAPI float GetMasterVolume(void); // Get master volume (listener) + +// Wave/Sound loading/unloading functions +RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI bool IsWaveReady(Wave wave); // Checks if wave data is ready +RLAPI Sound LoadSound(const char *fileName); // Load sound from file +RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data +RLAPI Sound LoadSoundAlias(Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data +RLAPI bool IsSoundReady(Sound sound); // Checks if a sound is ready +RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data +RLAPI void UnloadWave(Wave wave); // Unload wave data +RLAPI void UnloadSound(Sound sound); // Unload sound +RLAPI void UnloadSoundAlias(Sound alias); // Unload a sound alias (does not deallocate sample data) +RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success +RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success + +// Wave/Sound management functions +RLAPI void PlaySound(Sound sound); // Play a sound +RLAPI void StopSound(Sound sound); // Stop playing a sound +RLAPI void PauseSound(Sound sound); // Pause a sound +RLAPI void ResumeSound(Sound sound); // Resume a paused sound +RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing +RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center) +RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave +RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range +RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array +RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples() + +// Music management functions +RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file +RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data +RLAPI bool IsMusicReady(Music music); // Checks if a music stream is ready +RLAPI void UnloadMusicStream(Music music); // Unload music stream +RLAPI void PlayMusicStream(Music music); // Start music playing +RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing +RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming +RLAPI void StopMusicStream(Music music); // Stop music playing +RLAPI void PauseMusicStream(Music music); // Pause music playing +RLAPI void ResumeMusicStream(Music music); // Resume playing paused music +RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds) +RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) +RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) +RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center) +RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) +RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) + +// AudioStream management functions +RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) +RLAPI bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready +RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory +RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data +RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream +RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream +RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream +RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing +RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream +RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) +RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams +RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data + +RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as s +RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream + +RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as s +RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) +} +#endif + +#endif // RAYLIB_H diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/include/raymath.h b/pkgs/raylib/raylib-5.0_win64_msvc16/include/raymath.h new file mode 100644 index 0000000..40a8a84 --- /dev/null +++ b/pkgs/raylib/raylib-5.0_win64_msvc16/include/raymath.h @@ -0,0 +1,2190 @@ +/********************************************************************************************** +* +* raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions +* +* CONVENTIONS: +* - Matrix structure is defined as row-major (memory layout) but parameters naming AND all +* math operations performed by the library consider the structure as it was column-major +* It is like transposed versions of the matrices are used for all the maths +* It benefits some functions making them cache-friendly and also avoids matrix +* transpositions sometimes required by OpenGL +* Example: In memory order, row0 is [m0 m4 m8 m12] but in semantic math row0 is [m0 m1 m2 m3] +* - Functions are always self-contained, no function use another raymath function inside, +* required code is directly re-implemented inside +* - Functions input parameters are always received by value (2 unavoidable exceptions) +* - Functions use always a "result" variable for return +* - Functions are always defined inline +* - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience) +* - No compound literals used to make sure libray is compatible with C++ +* +* CONFIGURATION: +* #define RAYMATH_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYMATH_STATIC_INLINE +* Define static inline functions code, so #include header suffices for use. +* This may use up lots of memory. +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RAYMATH_H +#define RAYMATH_H + +#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE) + #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" +#endif + +// Function specifiers definition +#if defined(RAYMATH_IMPLEMENTATION) + #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) + #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). + #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) + #define RMAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RMAPI extern inline // Provide external definition + #endif +#elif defined(RAYMATH_STATIC_INLINE) + #define RMAPI static inline // Functions may be inlined, no external out-of-line definition +#else + #if defined(__TINYC__) + #define RMAPI static inline // plain inline not supported by tinycc (See issue #435) + #else + #define RMAPI inline // Functions may be inlined or external definition used + #endif +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif + +#ifndef EPSILON + #define EPSILON 0.000001f +#endif + +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif + +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +// Get float vector for Matrix +#ifndef MatrixToFloat + #define MatrixToFloat(mat) (MatrixToFloatV(mat).v) +#endif + +// Get float vector for Vector3 +#ifndef Vector3ToFloat + #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if !defined(RL_VECTOR2_TYPE) +// Vector2 type +typedef struct Vector2 { + float x; + float y; +} Vector2; +#define RL_VECTOR2_TYPE +#endif + +#if !defined(RL_VECTOR3_TYPE) +// Vector3 type +typedef struct Vector3 { + float x; + float y; + float z; +} Vector3; +#define RL_VECTOR3_TYPE +#endif + +#if !defined(RL_VECTOR4_TYPE) +// Vector4 type +typedef struct Vector4 { + float x; + float y; + float z; + float w; +} Vector4; +#define RL_VECTOR4_TYPE +#endif + +#if !defined(RL_QUATERNION_TYPE) +// Quaternion type +typedef Vector4 Quaternion; +#define RL_QUATERNION_TYPE +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix type (OpenGL style 4x4 - right handed, column major) +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// NOTE: Helper types to be used instead of array return types for *ToFloat functions +typedef struct float3 { + float v[3]; +} float3; + +typedef struct float16 { + float v[16]; +} float16; + +#include // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Utils math +//---------------------------------------------------------------------------------- + +// Clamp float value +RMAPI float Clamp(float value, float min, float max) +{ + float result = (value < min)? min : value; + + if (result > max) result = max; + + return result; +} + +// Calculate linear interpolation between two floats +RMAPI float Lerp(float start, float end, float amount) +{ + float result = start + amount*(end - start); + + return result; +} + +// Normalize input value within input range +RMAPI float Normalize(float value, float start, float end) +{ + float result = (value - start)/(end - start); + + return result; +} + +// Remap input value within input range to output range +RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) +{ + float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart; + + return result; +} + +// Wrap input value from min to max +RMAPI float Wrap(float value, float min, float max) +{ + float result = value - (max - min)*floorf((value - min)/(max - min)); + + return result; +} + +// Check whether two given floats are almost equal +RMAPI int FloatEquals(float x, float y) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y)))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector2 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector2 Vector2Zero(void) +{ + Vector2 result = { 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector2 Vector2One(void) +{ + Vector2 result = { 1.0f, 1.0f }; + + return result; +} + +// Add two vectors (v1 + v2) +RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x + v2.x, v1.y + v2.y }; + + return result; +} + +// Add vector and float value +RMAPI Vector2 Vector2AddValue(Vector2 v, float add) +{ + Vector2 result = { v.x + add, v.y + add }; + + return result; +} + +// Subtract two vectors (v1 - v2) +RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x - v2.x, v1.y - v2.y }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub) +{ + Vector2 result = { v.x - sub, v.y - sub }; + + return result; +} + +// Calculate vector length +RMAPI float Vector2Length(Vector2 v) +{ + float result = sqrtf((v.x*v.x) + (v.y*v.y)); + + return result; +} + +// Calculate vector square length +RMAPI float Vector2LengthSqr(Vector2 v) +{ + float result = (v.x*v.x) + (v.y*v.y); + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector2Distance(Vector2 v1, Vector2 v2) +{ + float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2) +{ + float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); + + return result; +} + +// Calculate angle between two vectors +// NOTE: Angle is calculated from origin point (0, 0) +RMAPI float Vector2Angle(Vector2 v1, Vector2 v2) +{ + float result = 0.0f; + + float dot = v1.x*v2.x + v1.y*v2.y; + float det = v1.x*v2.y - v1.y*v2.x; + + result = atan2f(det, dot); + + return result; +} + +// Calculate angle defined by a two vectors line +// NOTE: Parameters need to be normalized +// Current implementation should be aligned with glm::angle +RMAPI float Vector2LineAngle(Vector2 start, Vector2 end) +{ + float result = 0.0f; + + // TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior + result = -atan2f(end.y - start.y, end.x - start.x); + + return result; +} + +// Scale vector (multiply by value) +RMAPI Vector2 Vector2Scale(Vector2 v, float scale) +{ + Vector2 result = { v.x*scale, v.y*scale }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x*v2.x, v1.y*v2.y }; + + return result; +} + +// Negate vector +RMAPI Vector2 Vector2Negate(Vector2 v) +{ + Vector2 result = { -v.x, -v.y }; + + return result; +} + +// Divide vector by vector +RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2) +{ + Vector2 result = { v1.x/v2.x, v1.y/v2.y }; + + return result; +} + +// Normalize provided vector +RMAPI Vector2 Vector2Normalize(Vector2 v) +{ + Vector2 result = { 0 }; + float length = sqrtf((v.x*v.x) + (v.y*v.y)); + + if (length > 0) + { + float ilength = 1.0f/length; + result.x = v.x*ilength; + result.y = v.y*ilength; + } + + return result; +} + +// Transforms a Vector2 by a given Matrix +RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat) +{ + Vector2 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = 0; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount) +{ + Vector2 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal) +{ + Vector2 result = { 0 }; + + float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + + return result; +} + +// Rotate vector by angle +RMAPI Vector2 Vector2Rotate(Vector2 v, float angle) +{ + Vector2 result = { 0 }; + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.x = v.x*cosres - v.y*sinres; + result.y = v.x*sinres + v.y*cosres; + + return result; +} + +// Move Vector towards target +RMAPI Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) +{ + Vector2 result = { 0 }; + + float dx = target.x - v.x; + float dy = target.y - v.y; + float value = (dx*dx) + (dy*dy); + + if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target; + + float dist = sqrtf(value); + + result.x = v.x + dx/dist*maxDistance; + result.y = v.y + dy/dist*maxDistance; + + return result; +} + +// Invert the given vector +RMAPI Vector2 Vector2Invert(Vector2 v) +{ + Vector2 result = { 1.0f/v.x, 1.0f/v.y }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max) +{ + Vector2 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + + return result; +} + +// Clamp the magnitude of the vector between two min and max values +RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max) +{ + Vector2 result = v; + + float length = (v.x*v.x) + (v.y*v.y); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector2Equals(Vector2 p, Vector2 q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))); + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vector3 math +//---------------------------------------------------------------------------------- + +// Vector with components value 0.0f +RMAPI Vector3 Vector3Zero(void) +{ + Vector3 result = { 0.0f, 0.0f, 0.0f }; + + return result; +} + +// Vector with components value 1.0f +RMAPI Vector3 Vector3One(void) +{ + Vector3 result = { 1.0f, 1.0f, 1.0f }; + + return result; +} + +// Add two vectors +RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; + + return result; +} + +// Add vector and float value +RMAPI Vector3 Vector3AddValue(Vector3 v, float add) +{ + Vector3 result = { v.x + add, v.y + add, v.z + add }; + + return result; +} + +// Subtract two vectors +RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; + + return result; +} + +// Subtract vector by float value +RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub) +{ + Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; + + return result; +} + +// Multiply vector by scalar +RMAPI Vector3 Vector3Scale(Vector3 v, float scalar) +{ + Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; + + return result; +} + +// Multiply vector by vector +RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; + + return result; +} + +// Calculate two vectors cross product +RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + + return result; +} + +// Calculate one vector perpendicular vector +RMAPI Vector3 Vector3Perpendicular(Vector3 v) +{ + Vector3 result = { 0 }; + + float min = (float) fabs(v.x); + Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; + + if (fabsf(v.y) < min) + { + min = (float) fabs(v.y); + Vector3 tmp = {0.0f, 1.0f, 0.0f}; + cardinalAxis = tmp; + } + + if (fabsf(v.z) < min) + { + Vector3 tmp = {0.0f, 0.0f, 1.0f}; + cardinalAxis = tmp; + } + + // Cross product between vectors + result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y; + result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z; + result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x; + + return result; +} + +// Calculate vector length +RMAPI float Vector3Length(const Vector3 v) +{ + float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + + return result; +} + +// Calculate vector square length +RMAPI float Vector3LengthSqr(const Vector3 v) +{ + float result = v.x*v.x + v.y*v.y + v.z*v.z; + + return result; +} + +// Calculate two vectors dot product +RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2) +{ + float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + + return result; +} + +// Calculate distance between two vectors +RMAPI float Vector3Distance(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = sqrtf(dx*dx + dy*dy + dz*dz); + + return result; +} + +// Calculate square distance between two vectors +RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = dx*dx + dy*dy + dz*dz; + + return result; +} + +// Calculate angle between two vectors +RMAPI float Vector3Angle(Vector3 v1, Vector3 v2) +{ + float result = 0.0f; + + Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z); + float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + result = atan2f(len, dot); + + return result; +} + +// Negate provided vector (invert direction) +RMAPI Vector3 Vector3Negate(Vector3 v) +{ + Vector3 result = { -v.x, -v.y, -v.z }; + + return result; +} + +// Divide vector by vector +RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2) +{ + Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; + + return result; +} + +// Normalize provided vector +RMAPI Vector3 Vector3Normalize(Vector3 v) +{ + Vector3 result = v; + + float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length != 0.0f) + { + float ilength = 1.0f/length; + + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + } + + return result; +} + +//Calculate the projection of the vector v1 on to v2 +RMAPI Vector3 Vector3Project(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); + + float mag = v1dv2/v2dv2; + + result.x = v2.x*mag; + result.y = v2.y*mag; + result.z = v2.z*mag; + + return result; +} + +//Calculate the rejection of the vector v1 on to v2 +RMAPI Vector3 Vector3Reject(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); + + float mag = v1dv2/v2dv2; + + result.x = v1.x - (v2.x*mag); + result.y = v1.y - (v2.y*mag); + result.z = v1.z - (v2.z*mag); + + return result; +} + +// Orthonormalize provided vectors +// Makes vectors normalized and orthogonal to each other +// Gram-Schmidt function implementation +RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) +{ + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(*v1); + Vector3 v = *v1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + v1->x *= ilength; + v1->y *= ilength; + v1->z *= ilength; + + // Vector3CrossProduct(*v1, *v2) + Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x }; + + // Vector3Normalize(vn1); + v = vn1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vn1.x *= ilength; + vn1.y *= ilength; + vn1.z *= ilength; + + // Vector3CrossProduct(vn1, *v1) + Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x }; + + *v2 = vn2; +} + +// Transforms a Vector3 by a given Matrix +RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat) +{ + Vector3 result = { 0 }; + + float x = v.x; + float y = v.y; + float z = v.z; + + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; + + return result; +} + +// Transform a vector by quaternion rotation +RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q) +{ + Vector3 result = { 0 }; + + result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); + result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); + result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); + + return result; +} + +// Rotates a vector around an axis +RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle) +{ + // Using Euler-Rodrigues Formula + // Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula + + Vector3 result = v; + + // Vector3Normalize(axis); + float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f / length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + angle /= 2.0f; + float a = sinf(angle); + float b = axis.x*a; + float c = axis.y*a; + float d = axis.z*a; + a = cosf(angle); + Vector3 w = { b, c, d }; + + // Vector3CrossProduct(w, v) + Vector3 wv = { w.y*v.z - w.z*v.y, w.z*v.x - w.x*v.z, w.x*v.y - w.y*v.x }; + + // Vector3CrossProduct(w, wv) + Vector3 wwv = { w.y*wv.z - w.z*wv.y, w.z*wv.x - w.x*wv.z, w.x*wv.y - w.y*wv.x }; + + // Vector3Scale(wv, 2*a) + a *= 2; + wv.x *= a; + wv.y *= a; + wv.z *= a; + + // Vector3Scale(wwv, 2) + wwv.x *= 2; + wwv.y *= 2; + wwv.z *= 2; + + result.x += wv.x; + result.y += wv.y; + result.z += wv.z; + + result.x += wwv.x; + result.y += wwv.y; + result.z += wwv.z; + + return result; +} + +// Calculate linear interpolation between two vectors +RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount) +{ + Vector3 result = { 0 }; + + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + result.z = v1.z + amount*(v2.z - v1.z); + + return result; +} + +// Calculate reflected vector to normal +RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal) +{ + Vector3 result = { 0 }; + + // I is the original vector + // N is the normal of the incident plane + // R = I - (2*N*(DotProduct[I, N])) + + float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z); + + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + result.z = v.z - (2.0f*normal.z)*dotProduct; + + return result; +} + +// Get min value for each pair of components +RMAPI Vector3 Vector3Min(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + + return result; +} + +// Get max value for each pair of components +RMAPI Vector3 Vector3Max(Vector3 v1, Vector3 v2) +{ + Vector3 result = { 0 }; + + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + + return result; +} + +// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) +// NOTE: Assumes P is on the plane of the triangle +RMAPI Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) +{ + Vector3 result = { 0 }; + + Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // Vector3Subtract(b, a) + Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // Vector3Subtract(c, a) + Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // Vector3Subtract(p, a) + float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z); // Vector3DotProduct(v0, v0) + float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z); // Vector3DotProduct(v0, v1) + float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z); // Vector3DotProduct(v1, v1) + float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z); // Vector3DotProduct(v2, v0) + float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z); // Vector3DotProduct(v2, v1) + + float denom = d00*d11 - d01*d01; + + result.y = (d11*d20 - d01*d21)/denom; + result.z = (d00*d21 - d01*d20)/denom; + result.x = 1.0f - (result.z + result.y); + + return result; +} + +// Projects a Vector3 from screen space into object space +// NOTE: We are avoiding calling other raymath functions despite available +RMAPI Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view) +{ + Vector3 result = { 0 }; + + // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it + Matrix matViewProj = { // MatrixMultiply(view, projection); + view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12, + view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13, + view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14, + view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15, + view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12, + view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13, + view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14, + view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15, + view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12, + view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13, + view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14, + view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15, + view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12, + view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13, + view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14, + view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 }; + + // Calculate inverted matrix -> MatrixInvert(matViewProj); + // Cache the matrix values (speed optimization) + float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; + float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; + float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; + float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + Matrix matViewProjInv = { + (a11*b11 - a12*b10 + a13*b09)*invDet, + (-a01*b11 + a02*b10 - a03*b09)*invDet, + (a31*b05 - a32*b04 + a33*b03)*invDet, + (-a21*b05 + a22*b04 - a23*b03)*invDet, + (-a10*b11 + a12*b08 - a13*b07)*invDet, + (a00*b11 - a02*b08 + a03*b07)*invDet, + (-a30*b05 + a32*b02 - a33*b01)*invDet, + (a20*b05 - a22*b02 + a23*b01)*invDet, + (a10*b10 - a11*b08 + a13*b06)*invDet, + (-a00*b10 + a01*b08 - a03*b06)*invDet, + (a30*b04 - a31*b02 + a33*b00)*invDet, + (-a20*b04 + a21*b02 - a23*b00)*invDet, + (-a10*b09 + a11*b07 - a12*b06)*invDet, + (a00*b09 - a01*b07 + a02*b06)*invDet, + (-a30*b03 + a31*b01 - a32*b00)*invDet, + (a20*b03 - a21*b01 + a22*b00)*invDet }; + + // Create quaternion from source point + Quaternion quat = { source.x, source.y, source.z, 1.0f }; + + // Multiply quat point by unprojecte matrix + Quaternion qtransformed = { // QuaternionTransform(quat, matViewProjInv) + matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w, + matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w, + matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w, + matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w }; + + // Normalized world points in vectors + result.x = qtransformed.x/qtransformed.w; + result.y = qtransformed.y/qtransformed.w; + result.z = qtransformed.z/qtransformed.w; + + return result; +} + +// Get Vector3 as float array +RMAPI float3 Vector3ToFloatV(Vector3 v) +{ + float3 buffer = { 0 }; + + buffer.v[0] = v.x; + buffer.v[1] = v.y; + buffer.v[2] = v.z; + + return buffer; +} + +// Invert the given vector +RMAPI Vector3 Vector3Invert(Vector3 v) +{ + Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z }; + + return result; +} + +// Clamp the components of the vector between +// min and max values specified by the given vectors +RMAPI Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max) +{ + Vector3 result = { 0 }; + + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + result.z = fminf(max.z, fmaxf(min.z, v.z)); + + return result; +} + +// Clamp the magnitude of the vector between two values +RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max) +{ + Vector3 result = v; + + float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z); + if (length > 0.0f) + { + length = sqrtf(length); + + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + } + + return result; +} + +// Check whether two given vectors are almost equal +RMAPI int Vector3Equals(Vector3 p, Vector3 q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))); + + return result; +} + +// Compute the direction of a refracted ray +// v: normalized direction of the incoming ray +// n: normalized normal vector of the interface of two optical media +// r: ratio of the refractive index of the medium from where the ray comes +// to the refractive index of the medium on the other side of the surface +RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r) +{ + Vector3 result = { 0 }; + + float dot = v.x*n.x + v.y*n.y + v.z*n.z; + float d = 1.0f - r*r*(1.0f - dot*dot); + + if (d >= 0.0f) + { + d = sqrtf(d); + v.x = r*v.x - (r*dot + d)*n.x; + v.y = r*v.y - (r*dot + d)*n.y; + v.z = r*v.z - (r*dot + d)*n.z; + + result = v; + } + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix math +//---------------------------------------------------------------------------------- + +// Compute matrix determinant +RMAPI float MatrixDeterminant(Matrix mat) +{ + float result = 0.0f; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; + + return result; +} + +// Get the trace of the matrix (sum of the values along the diagonal) +RMAPI float MatrixTrace(Matrix mat) +{ + float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); + + return result; +} + +// Transposes provided matrix +RMAPI Matrix MatrixTranspose(Matrix mat) +{ + Matrix result = { 0 }; + + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; + + return result; +} + +// Invert provided matrix +RMAPI Matrix MatrixInvert(Matrix mat) +{ + Matrix result = { 0 }; + + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; + + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); + + result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; + result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; + result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; + result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; + result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; + result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; + result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; + result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; + result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; + result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; + result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; + result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; + result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; + result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; + result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; + result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; + + return result; +} + +// Get identity matrix +RMAPI Matrix MatrixIdentity(void) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Add two matrices +RMAPI Matrix MatrixAdd(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; + + return result; +} + +// Subtract two matrices (left - right) +RMAPI Matrix MatrixSubtract(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +RMAPI Matrix MatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +// Get translation matrix +RMAPI Matrix MatrixTranslate(float x, float y, float z) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Create rotation matrix from axis and angle +// NOTE: Angle should be provided in radians +RMAPI Matrix MatrixRotate(Vector3 axis, float angle) +{ + Matrix result = { 0 }; + + float x = axis.x, y = axis.y, z = axis.z; + + float lengthSquared = x*x + y*y + z*z; + + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float ilength = 1.0f/sqrtf(lengthSquared); + x *= ilength; + y *= ilength; + z *= ilength; + } + + float sinres = sinf(angle); + float cosres = cosf(angle); + float t = 1.0f - cosres; + + result.m0 = x*x*t + cosres; + result.m1 = y*x*t + z*sinres; + result.m2 = z*x*t - y*sinres; + result.m3 = 0.0f; + + result.m4 = x*y*t - z*sinres; + result.m5 = y*y*t + cosres; + result.m6 = z*y*t + x*sinres; + result.m7 = 0.0f; + + result.m8 = x*z*t + y*sinres; + result.m9 = y*z*t - x*sinres; + result.m10 = z*z*t + cosres; + result.m11 = 0.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = 0.0f; + result.m15 = 1.0f; + + return result; +} + +// Get x-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateX(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m5 = cosres; + result.m6 = sinres; + result.m9 = -sinres; + result.m10 = cosres; + + return result; +} + +// Get y-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateY(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m2 = -sinres; + result.m8 = sinres; + result.m10 = cosres; + + return result; +} + +// Get z-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZ(float angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosres = cosf(angle); + float sinres = sinf(angle); + + result.m0 = cosres; + result.m1 = sinres; + result.m4 = -sinres; + result.m5 = cosres; + + return result; +} + + +// Get xyz-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateXYZ(Vector3 angle) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float cosz = cosf(-angle.z); + float sinz = sinf(-angle.z); + float cosy = cosf(-angle.y); + float siny = sinf(-angle.y); + float cosx = cosf(-angle.x); + float sinx = sinf(-angle.x); + + result.m0 = cosz*cosy; + result.m1 = (cosz*siny*sinx) - (sinz*cosx); + result.m2 = (cosz*siny*cosx) + (sinz*sinx); + + result.m4 = sinz*cosy; + result.m5 = (sinz*siny*sinx) + (cosz*cosx); + result.m6 = (sinz*siny*cosx) - (cosz*sinx); + + result.m8 = -siny; + result.m9 = cosy*sinx; + result.m10= cosy*cosx; + + return result; +} + +// Get zyx-rotation matrix +// NOTE: Angle must be provided in radians +RMAPI Matrix MatrixRotateZYX(Vector3 angle) +{ + Matrix result = { 0 }; + + float cz = cosf(angle.z); + float sz = sinf(angle.z); + float cy = cosf(angle.y); + float sy = sinf(angle.y); + float cx = cosf(angle.x); + float sx = sinf(angle.x); + + result.m0 = cz*cy; + result.m4 = cz*sy*sx - cx*sz; + result.m8 = sz*sx + cz*cx*sy; + result.m12 = 0; + + result.m1 = cy*sz; + result.m5 = cz*cx + sz*sy*sx; + result.m9 = cx*sz*sy - cz*sx; + result.m13 = 0; + + result.m2 = -sy; + result.m6 = cy*sx; + result.m10 = cy*cx; + result.m14 = 0; + + result.m3 = 0; + result.m7 = 0; + result.m11 = 0; + result.m15 = 1; + + return result; +} + +// Get scaling matrix +RMAPI Matrix MatrixScale(float x, float y, float z) +{ + Matrix result = { x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Get perspective projection matrix +RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); + + result.m0 = ((float)near*2.0f)/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + + result.m4 = 0.0f; + result.m5 = ((float)near*2.0f)/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; + + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + result.m15 = 0.0f; + + return result; +} + +// Get perspective projection matrix +// NOTE: Fovy angle must be provided in radians +RMAPI Matrix MatrixPerspective(double fovY, double aspect, double nearPlane, double farPlane) +{ + Matrix result = { 0 }; + + double top = nearPlane*tan(fovY*0.5); + double bottom = -top; + double right = top*aspect; + double left = -right; + + // MatrixFrustum(-right, right, -top, top, near, far); + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); + + result.m0 = ((float)nearPlane*2.0f)/rl; + result.m5 = ((float)nearPlane*2.0f)/tb; + result.m8 = ((float)right + (float)left)/rl; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)farPlane + (float)nearPlane)/fn; + result.m11 = -1.0f; + result.m14 = -((float)farPlane*(float)nearPlane*2.0f)/fn; + + return result; +} + +// Get orthographic projection matrix +RMAPI Matrix MatrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane) +{ + Matrix result = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); + + result.m0 = 2.0f/rl; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + result.m4 = 0.0f; + result.m5 = 2.0f/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + result.m8 = 0.0f; + result.m9 = 0.0f; + result.m10 = -2.0f/fn; + result.m11 = 0.0f; + result.m12 = -((float)left + (float)right)/rl; + result.m13 = -((float)top + (float)bottom)/tb; + result.m14 = -((float)farPlane + (float)nearPlane)/fn; + result.m15 = 1.0f; + + return result; +} + +// Get camera look-at matrix (view matrix) +RMAPI Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up) +{ + Matrix result = { 0 }; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Subtract(eye, target) + Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; + + // Vector3Normalize(vz) + Vector3 v = vz; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vz.x *= ilength; + vz.y *= ilength; + vz.z *= ilength; + + // Vector3CrossProduct(up, vz) + Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x }; + + // Vector3Normalize(x) + v = vx; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vx.x *= ilength; + vx.y *= ilength; + vx.z *= ilength; + + // Vector3CrossProduct(vz, vx) + Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x }; + + result.m0 = vx.x; + result.m1 = vy.x; + result.m2 = vz.x; + result.m3 = 0.0f; + result.m4 = vx.y; + result.m5 = vy.y; + result.m6 = vz.y; + result.m7 = 0.0f; + result.m8 = vx.z; + result.m9 = vy.z; + result.m10 = vz.z; + result.m11 = 0.0f; + result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z); // Vector3DotProduct(vx, eye) + result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z); // Vector3DotProduct(vy, eye) + result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z); // Vector3DotProduct(vz, eye) + result.m15 = 1.0f; + + return result; +} + +// Get float array of matrix data +RMAPI float16 MatrixToFloatV(Matrix mat) +{ + float16 result = { 0 }; + + result.v[0] = mat.m0; + result.v[1] = mat.m1; + result.v[2] = mat.m2; + result.v[3] = mat.m3; + result.v[4] = mat.m4; + result.v[5] = mat.m5; + result.v[6] = mat.m6; + result.v[7] = mat.m7; + result.v[8] = mat.m8; + result.v[9] = mat.m9; + result.v[10] = mat.m10; + result.v[11] = mat.m11; + result.v[12] = mat.m12; + result.v[13] = mat.m13; + result.v[14] = mat.m14; + result.v[15] = mat.m15; + + return result; +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Quaternion math +//---------------------------------------------------------------------------------- + +// Add two quaternions +RMAPI Quaternion QuaternionAdd(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; + + return result; +} + +// Add quaternion and float value +RMAPI Quaternion QuaternionAddValue(Quaternion q, float add) +{ + Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; + + return result; +} + +// Subtract two quaternions +RMAPI Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2) +{ + Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; + + return result; +} + +// Subtract quaternion and float value +RMAPI Quaternion QuaternionSubtractValue(Quaternion q, float sub) +{ + Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; + + return result; +} + +// Get identity quaternion +RMAPI Quaternion QuaternionIdentity(void) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + return result; +} + +// Computes the length of a quaternion +RMAPI float QuaternionLength(Quaternion q) +{ + float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + + return result; +} + +// Normalize provided quaternion +RMAPI Quaternion QuaternionNormalize(Quaternion q) +{ + Quaternion result = { 0 }; + + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Invert provided quaternion +RMAPI Quaternion QuaternionInvert(Quaternion q) +{ + Quaternion result = q; + + float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w; + + if (lengthSq != 0.0f) + { + float invLength = 1.0f/lengthSq; + + result.x *= -invLength; + result.y *= -invLength; + result.z *= -invLength; + result.w *= invLength; + } + + return result; +} + +// Calculate two quaternion multiplication +RMAPI Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2) +{ + Quaternion result = { 0 }; + + float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; + float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; + + result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; + + return result; +} + +// Scale quaternion by float value +RMAPI Quaternion QuaternionScale(Quaternion q, float mul) +{ + Quaternion result = { 0 }; + + result.x = q.x*mul; + result.y = q.y*mul; + result.z = q.z*mul; + result.w = q.w*mul; + + return result; +} + +// Divide two quaternions +RMAPI Quaternion QuaternionDivide(Quaternion q1, Quaternion q2) +{ + Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w }; + + return result; +} + +// Calculate linear interpolation between two quaternions +RMAPI Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + return result; +} + +// Calculate slerp-optimized interpolation between two quaternions +RMAPI Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + + // QuaternionLerp(q1, q2, amount) + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); + + // QuaternionNormalize(q); + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Calculates spherical linear interpolation between two quaternions +RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount) +{ + Quaternion result = { 0 }; + +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; + + if (cosHalfTheta < 0) + { + q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w; + cosHalfTheta = -cosHalfTheta; + } + + if (fabsf(cosHalfTheta) >= 1.0f) result = q1; + else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount); + else + { + float halfTheta = acosf(cosHalfTheta); + float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); + + if (fabsf(sinHalfTheta) < EPSILON) + { + result.x = (q1.x*0.5f + q2.x*0.5f); + result.y = (q1.y*0.5f + q2.y*0.5f); + result.z = (q1.z*0.5f + q2.z*0.5f); + result.w = (q1.w*0.5f + q2.w*0.5f); + } + else + { + float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; + float ratioB = sinf(amount*halfTheta)/sinHalfTheta; + + result.x = (q1.x*ratioA + q2.x*ratioB); + result.y = (q1.y*ratioA + q2.y*ratioB); + result.z = (q1.z*ratioA + q2.z*ratioB); + result.w = (q1.w*ratioA + q2.w*ratioB); + } + } + + return result; +} + +// Calculate quaternion based on the rotation from one vector to another +RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to) +{ + Quaternion result = { 0 }; + + float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z); // Vector3DotProduct(from, to) + Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // Vector3CrossProduct(from, to) + + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0f + cos2Theta; + + // QuaternionNormalize(q); + // NOTE: Normalize to essentially nlerp the original and identity to 0.5 + Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + + return result; +} + +// Get a quaternion for a given rotation matrix +RMAPI Quaternion QuaternionFromMatrix(Matrix mat) +{ + Quaternion result = { 0 }; + + float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; + float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; + float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; + float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; + + int biggestIndex = 0; + float fourBiggestSquaredMinus1 = fourWSquaredMinus1; + if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourXSquaredMinus1; + biggestIndex = 1; + } + + if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourYSquaredMinus1; + biggestIndex = 2; + } + + if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourZSquaredMinus1; + biggestIndex = 3; + } + + float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f)*0.5f; + float mult = 0.25f / biggestVal; + + switch (biggestIndex) + { + case 0: + result.w = biggestVal; + result.x = (mat.m6 - mat.m9)*mult; + result.y = (mat.m8 - mat.m2)*mult; + result.z = (mat.m1 - mat.m4)*mult; + break; + case 1: + result.x = biggestVal; + result.w = (mat.m6 - mat.m9)*mult; + result.y = (mat.m1 + mat.m4)*mult; + result.z = (mat.m8 + mat.m2)*mult; + break; + case 2: + result.y = biggestVal; + result.w = (mat.m8 - mat.m2)*mult; + result.x = (mat.m1 + mat.m4)*mult; + result.z = (mat.m6 + mat.m9)*mult; + break; + case 3: + result.z = biggestVal; + result.w = (mat.m1 - mat.m4)*mult; + result.x = (mat.m8 + mat.m2)*mult; + result.y = (mat.m6 + mat.m9)*mult; + break; + } + + return result; +} + +// Get a matrix for a given quaternion +RMAPI Matrix QuaternionToMatrix(Quaternion q) +{ + Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + + float a2 = q.x*q.x; + float b2 = q.y*q.y; + float c2 = q.z*q.z; + float ac = q.x*q.z; + float ab = q.x*q.y; + float bc = q.y*q.z; + float ad = q.w*q.x; + float bd = q.w*q.y; + float cd = q.w*q.z; + + result.m0 = 1 - 2*(b2 + c2); + result.m1 = 2*(ab + cd); + result.m2 = 2*(ac - bd); + + result.m4 = 2*(ab - cd); + result.m5 = 1 - 2*(a2 + c2); + result.m6 = 2*(bc + ad); + + result.m8 = 2*(ac + bd); + result.m9 = 2*(bc - ad); + result.m10 = 1 - 2*(a2 + b2); + + return result; +} + +// Get rotation quaternion for an angle and axis +// NOTE: Angle must be provided in radians +RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle) +{ + Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + + float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + + if (axisLength != 0.0f) + { + angle *= 0.5f; + + float length = 0.0f; + float ilength = 0.0f; + + // Vector3Normalize(axis) + Vector3 v = axis; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + + float sinres = sinf(angle); + float cosres = cosf(angle); + + result.x = axis.x*sinres; + result.y = axis.y*sinres; + result.z = axis.z*sinres; + result.w = cosres; + + // QuaternionNormalize(q); + Quaternion q = result; + length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + } + + return result; +} + +// Get the rotation angle and axis for a given quaternion +RMAPI void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) +{ + if (fabsf(q.w) > 1.0f) + { + // QuaternionNormalize(q); + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; + + q.x = q.x*ilength; + q.y = q.y*ilength; + q.z = q.z*ilength; + q.w = q.w*ilength; + } + + Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; + float resAngle = 2.0f*acosf(q.w); + float den = sqrtf(1.0f - q.w*q.w); + + if (den > EPSILON) + { + resAxis.x = q.x/den; + resAxis.y = q.y/den; + resAxis.z = q.z/den; + } + else + { + // This occurs when the angle is zero. + // Not a problem: just set an arbitrary normalized axis. + resAxis.x = 1.0f; + } + + *outAxis = resAxis; + *outAngle = resAngle; +} + +// Get the quaternion equivalent to Euler angles +// NOTE: Rotation order is ZYX +RMAPI Quaternion QuaternionFromEuler(float pitch, float yaw, float roll) +{ + Quaternion result = { 0 }; + + float x0 = cosf(pitch*0.5f); + float x1 = sinf(pitch*0.5f); + float y0 = cosf(yaw*0.5f); + float y1 = sinf(yaw*0.5f); + float z0 = cosf(roll*0.5f); + float z1 = sinf(roll*0.5f); + + result.x = x1*y0*z0 - x0*y1*z1; + result.y = x0*y1*z0 + x1*y0*z1; + result.z = x0*y0*z1 - x1*y1*z0; + result.w = x0*y0*z0 + x1*y1*z1; + + return result; +} + +// Get the Euler angles equivalent to quaternion (roll, pitch, yaw) +// NOTE: Angles are returned in a Vector3 struct in radians +RMAPI Vector3 QuaternionToEuler(Quaternion q) +{ + Vector3 result = { 0 }; + + // Roll (x-axis rotation) + float x0 = 2.0f*(q.w*q.x + q.y*q.z); + float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); + result.x = atan2f(x0, x1); + + // Pitch (y-axis rotation) + float y0 = 2.0f*(q.w*q.y - q.z*q.x); + y0 = y0 > 1.0f ? 1.0f : y0; + y0 = y0 < -1.0f ? -1.0f : y0; + result.y = asinf(y0); + + // Yaw (z-axis rotation) + float z0 = 2.0f*(q.w*q.z + q.x*q.y); + float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); + result.z = atan2f(z0, z1); + + return result; +} + +// Transform a quaternion given a transformation matrix +RMAPI Quaternion QuaternionTransform(Quaternion q, Matrix mat) +{ + Quaternion result = { 0 }; + + result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; + result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; + result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; + result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; + + return result; +} + +// Check whether two given quaternions are almost equal +RMAPI int QuaternionEquals(Quaternion p, Quaternion q) +{ +#if !defined(EPSILON) + #define EPSILON 0.000001f +#endif + + int result = (((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))) || + (((fabsf(p.x + q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y + q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z + q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w + q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))); + + return result; +} + +#endif // RAYMATH_H diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/include/rlgl.h b/pkgs/raylib/raylib-5.0_win64_msvc16/include/rlgl.h new file mode 100644 index 0000000..de7055c --- /dev/null +++ b/pkgs/raylib/raylib-5.0_win64_msvc16/include/rlgl.h @@ -0,0 +1,4859 @@ +/********************************************************************************************** +* +* rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* DESCRIPTION: +* An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) +* that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...) +* +* ADDITIONAL NOTES: +* When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are +* initialized on rlglInit() to accumulate vertex data. +* +* When an internal state change is required all the stored vertex data is renderer in batch, +* additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch. +* +* Some resources are also loaded for convenience, here the complete list: +* - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data +* - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8 +* - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs) +* +* Internal buffer (and resources) must be manually unloaded calling rlglClose(). +* +* CONFIGURATION: +* #define GRAPHICS_API_OPENGL_11 +* #define GRAPHICS_API_OPENGL_21 +* #define GRAPHICS_API_OPENGL_33 +* #define GRAPHICS_API_OPENGL_43 +* #define GRAPHICS_API_OPENGL_ES2 +* #define GRAPHICS_API_OPENGL_ES3 +* Use selected OpenGL graphics backend, should be supported by platform +* Those preprocessor defines are only used on rlgl module, if OpenGL version is +* required by any other module, use rlGetVersion() to check it +* +* #define RLGL_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RLGL_RENDER_TEXTURES_HINT +* Enable framebuffer objects (fbo) support (enabled by default) +* Some GPUs could not support them despite the OpenGL version +* +* #define RLGL_SHOW_GL_DETAILS_INFO +* Show OpenGL extensions and capabilities detailed logs on init +* +* #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT +* Enable debug context (only available on OpenGL 4.3) +* +* rlgl capabilities could be customized just defining some internal +* values before library inclusion (default values listed): +* +* #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits +* #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +* #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +* #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +* +* #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack +* #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +* #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance +* #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance +* +* When loading a shader, the following vertex attributes and uniform +* location names are tried to be set automatically: +* +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +* +* DEPENDENCIES: +* - OpenGL libraries (depending on platform and OpenGL version selected) +* - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#ifndef RLGL_H +#define RLGL_H + +#define RLGL_VERSION "4.5" + +// Function specifiers in case library is build/used as a shared library (Windows) +// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif +#endif + +// Function specifiers definition +#ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif + +// Support TRACELOG macros +#ifndef TRACELOG + #define TRACELOG(level, ...) (void)0 + #define TRACELOGD(...) (void)0 +#endif + +// Allow custom memory allocators +#ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) +#endif +#ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) +#endif +#ifndef RL_REALLOC + #define RL_REALLOC(n,sz) realloc(n,sz) +#endif +#ifndef RL_FREE + #define RL_FREE(p) free(p) +#endif + +// Security check in case no GRAPHICS_API_OPENGL_* defined +#if !defined(GRAPHICS_API_OPENGL_11) && \ + !defined(GRAPHICS_API_OPENGL_21) && \ + !defined(GRAPHICS_API_OPENGL_33) && \ + !defined(GRAPHICS_API_OPENGL_43) && \ + !defined(GRAPHICS_API_OPENGL_ES2) && \ + !defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_33 +#endif + +// Security check in case multiple GRAPHICS_API_OPENGL_* defined +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_21) + #undef GRAPHICS_API_OPENGL_21 + #endif + #if defined(GRAPHICS_API_OPENGL_33) + #undef GRAPHICS_API_OPENGL_33 + #endif + #if defined(GRAPHICS_API_OPENGL_43) + #undef GRAPHICS_API_OPENGL_43 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + #undef GRAPHICS_API_OPENGL_ES2 + #endif +#endif + +// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality +// WARNING: Specific parts are checked with #if defines +#if defined(GRAPHICS_API_OPENGL_21) + #define GRAPHICS_API_OPENGL_33 +#endif + +// OpenGL 4.3 uses OpenGL 3.3 Core functionality +#if defined(GRAPHICS_API_OPENGL_43) + #define GRAPHICS_API_OPENGL_33 +#endif + +// OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more) +#if defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_ES2 +#endif + +// Support framebuffer objects by default +// NOTE: Some driver implementation do not support it, despite they should +#define RLGL_RENDER_TEXTURES_HINT + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- + +// Default internal render batch elements limits +#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // This is the maximum amount of elements (quads) per batch + // NOTE: Be careful with text, every letter maps to a quad + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + // We reduce memory sizes for embedded systems (RPI and HTML5) + // NOTE: On HTML5 (emscripten) this is allocated on heap, + // by default it's only 16MB!...just take care... + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048 + #endif +#endif +#ifndef RL_DEFAULT_BATCH_BUFFERS + #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +#endif +#ifndef RL_DEFAULT_BATCH_DRAWCALLS + #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +#endif +#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS + #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +#endif + +// Internal Matrix stack +#ifndef RL_MAX_MATRIX_STACK_SIZE + #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack +#endif + +// Shader limits +#ifndef RL_MAX_SHADER_LOCATIONS + #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +#endif + +// Projection matrix culling +#ifndef RL_CULL_DISTANCE_NEAR + #define RL_CULL_DISTANCE_NEAR 0.01 // Default near cull distance +#endif +#ifndef RL_CULL_DISTANCE_FAR + #define RL_CULL_DISTANCE_FAR 1000.0 // Default far cull distance +#endif + +// Texture parameters (equivalent to OpenGL defines) +#define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S +#define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T +#define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER +#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER + +#define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST +#define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR +#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier) +#define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier) + +#define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT +#define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE +#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT +#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT + +// Matrix modes (equivalent to OpenGL) +#define RL_MODELVIEW 0x1700 // GL_MODELVIEW +#define RL_PROJECTION 0x1701 // GL_PROJECTION +#define RL_TEXTURE 0x1702 // GL_TEXTURE + +// Primitive assembly draw modes +#define RL_LINES 0x0001 // GL_LINES +#define RL_TRIANGLES 0x0004 // GL_TRIANGLES +#define RL_QUADS 0x0007 // GL_QUADS + +// GL equivalent data types +#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE +#define RL_FLOAT 0x1406 // GL_FLOAT + +// GL buffer usage hint +#define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW +#define RL_STREAM_READ 0x88E1 // GL_STREAM_READ +#define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY +#define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW +#define RL_STATIC_READ 0x88E5 // GL_STATIC_READ +#define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY +#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW +#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ +#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY + +// GL Shader type +#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER +#define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER +#define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER + +// GL blending factors +#define RL_ZERO 0 // GL_ZERO +#define RL_ONE 1 // GL_ONE +#define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR +#define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR +#define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA +#define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA +#define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA +#define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA +#define RL_DST_COLOR 0x0306 // GL_DST_COLOR +#define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR +#define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE +#define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR +#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR +#define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA +#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA + +// GL blending functions/equations +#define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD +#define RL_MIN 0x8007 // GL_MIN +#define RL_MAX 0x8008 // GL_MAX +#define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT +#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT +#define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION +#define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION) +#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA +#define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB +#define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB +#define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA +#define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA +#define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR + + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE) + // Boolean type +typedef enum bool { false = 0, true = !false } bool; +#endif + +#if !defined(RL_MATRIX_TYPE) +// Matrix, 4x4 components, column major, OpenGL style, right handed +typedef struct Matrix { + float m0, m4, m8, m12; // Matrix first row (4 components) + float m1, m5, m9, m13; // Matrix second row (4 components) + float m2, m6, m10, m14; // Matrix third row (4 components) + float m3, m7, m11, m15; // Matrix fourth row (4 components) +} Matrix; +#define RL_MATRIX_TYPE +#endif + +// Dynamic vertex buffers (position + texcoords + colors + indices arrays) +typedef struct rlVertexBuffer { + int elementCount; // Number of elements in the buffer (QUADS) + + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#endif + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data) +} rlVertexBuffer; + +// Draw call type +// NOTE: Only texture changes register a new draw, other state-change-related elements are not +// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any +// of those state-change happens (this is done in core module) +typedef struct rlDrawCall { + int mode; // Drawing mode: LINES, TRIANGLES, QUADS + int vertexCount; // Number of vertex of the draw + int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES) + //unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId + //unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId + unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes + + //Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default + //Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default +} rlDrawCall; + +// rlRenderBatch type +typedef struct rlRenderBatch { + int bufferCount; // Number of vertex buffers (multi-buffering support) + int currentBuffer; // Current buffer tracking in case of multi-buffering + rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data + + rlDrawCall *draws; // Draw calls array, depends on textureId + int drawCounter; // Draw calls counter + float currentDepth; // Current depth value for next draw +} rlRenderBatch; + +// OpenGL version +typedef enum { + RL_OPENGL_11 = 1, // OpenGL 1.1 + RL_OPENGL_21, // OpenGL 2.1 (GLSL 120) + RL_OPENGL_33, // OpenGL 3.3 (GLSL 330) + RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330) + RL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100) + RL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es) +} rlGlVersion; + +// Trace log level +// NOTE: Organized by priority level +typedef enum { + RL_LOG_ALL = 0, // Display all logs + RL_LOG_TRACE, // Trace logging, intended for internal use only + RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + RL_LOG_INFO, // Info logging, used for program execution info + RL_LOG_WARNING, // Warning logging, used on recoverable failures + RL_LOG_ERROR, // Error logging, used on unrecoverable failures + RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + RL_LOG_NONE // Disable logging +} rlTraceLogLevel; + +// Texture pixel formats +// NOTE: Support depends on OpenGL version +typedef enum { + RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} rlPixelFormat; + +// Texture parameters: filter mode +// NOTE 1: Filtering considers mipmaps if available in the texture +// NOTE 2: Filter is accordingly set for minification and magnification +typedef enum { + RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + RL_TEXTURE_FILTER_BILINEAR, // Linear filtering + RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} rlTextureFilter; + +// Color blending modes (pre-defined) +typedef enum { + RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) + RL_BLEND_ADDITIVE, // Blend textures adding colors + RL_BLEND_MULTIPLIED, // Blend textures multiplying colors + RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) + RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate()) +} rlBlendMode; + +// Shader location point type +typedef enum { + RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) + RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) + RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} rlShaderLocationIndex; + +#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO +#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS + +// Shader uniform data type +typedef enum { + RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + RL_SHADER_UNIFORM_INT, // Shader uniform type: int + RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} rlShaderUniformDataType; + +// Shader attribute data types +typedef enum { + RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} rlShaderAttributeDataType; + +// Framebuffer attachment type +// NOTE: By default up to 8 color channels defined, but it can be more +typedef enum { + RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0 + RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7 + RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth + RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil +} rlFramebufferAttachType; + +// Framebuffer texture attachment type +typedef enum { + RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5, // Framebuffer texture attachment type: cubemap, -Z side + RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d + RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer +} rlFramebufferAttachTextureType; + +// Face culling mode +typedef enum { + RL_CULL_FACE_FRONT = 0, + RL_CULL_FACE_BACK +} rlCullMode; + +//------------------------------------------------------------------------------------ +// Functions Declaration - Matrix operations +//------------------------------------------------------------------------------------ + +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions +#endif + +RLAPI void rlMatrixMode(int mode); // Choose the current matrix to be transformed +RLAPI void rlPushMatrix(void); // Push the current matrix to stack +RLAPI void rlPopMatrix(void); // Pop latest inserted matrix from stack +RLAPI void rlLoadIdentity(void); // Reset current matrix to identity matrix +RLAPI void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix +RLAPI void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix +RLAPI void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix +RLAPI void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix +RLAPI void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void rlViewport(int x, int y, int width, int height); // Set the viewport area + +//------------------------------------------------------------------------------------ +// Functions Declaration - Vertex level operations +//------------------------------------------------------------------------------------ +RLAPI void rlBegin(int mode); // Initialize drawing mode (how to organize vertex) +RLAPI void rlEnd(void); // Finish vertex providing +RLAPI void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int +RLAPI void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float +RLAPI void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float +RLAPI void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float +RLAPI void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float +RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte +RLAPI void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float +RLAPI void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float + +//------------------------------------------------------------------------------------ +// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) +// NOTE: This functions are used to completely abstract raylib code from OpenGL layer, +// some of them are direct wrappers over OpenGL calls, some others are custom +//------------------------------------------------------------------------------------ + +// Vertex buffers state +RLAPI bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported) +RLAPI void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported) +RLAPI void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO) +RLAPI void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO) +RLAPI void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element) +RLAPI void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element) +RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index +RLAPI void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index +#if defined(GRAPHICS_API_OPENGL_11) +RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer +RLAPI void rlDisableStatePointer(int vertexAttribType); // Disable attribute state pointer +#endif + +// Textures state +RLAPI void rlActiveTextureSlot(int slot); // Select and active a texture slot +RLAPI void rlEnableTexture(unsigned int id); // Enable texture +RLAPI void rlDisableTexture(void); // Disable texture +RLAPI void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap +RLAPI void rlDisableTextureCubemap(void); // Disable texture cubemap +RLAPI void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap) +RLAPI void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap) + +// Shader state +RLAPI void rlEnableShader(unsigned int id); // Enable shader program +RLAPI void rlDisableShader(void); // Disable shader program + +// Framebuffer state +RLAPI void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo) +RLAPI void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer +RLAPI void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers +RLAPI void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask); // Blit active framebuffer to main framebuffer + +// General render state +RLAPI void rlEnableColorBlend(void); // Enable color blending +RLAPI void rlDisableColorBlend(void); // Disable color blending +RLAPI void rlEnableDepthTest(void); // Enable depth test +RLAPI void rlDisableDepthTest(void); // Disable depth test +RLAPI void rlEnableDepthMask(void); // Enable depth write +RLAPI void rlDisableDepthMask(void); // Disable depth write +RLAPI void rlEnableBackfaceCulling(void); // Enable backface culling +RLAPI void rlDisableBackfaceCulling(void); // Disable backface culling +RLAPI void rlSetCullFace(int mode); // Set face culling mode +RLAPI void rlEnableScissorTest(void); // Enable scissor test +RLAPI void rlDisableScissorTest(void); // Disable scissor test +RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test +RLAPI void rlEnableWireMode(void); // Enable wire mode +RLAPI void rlEnablePointMode(void); // Enable point mode +RLAPI void rlDisableWireMode(void); // Disable wire mode ( and point ) maybe rename +RLAPI void rlSetLineWidth(float width); // Set the line drawing width +RLAPI float rlGetLineWidth(void); // Get the line drawing width +RLAPI void rlEnableSmoothLines(void); // Enable line aliasing +RLAPI void rlDisableSmoothLines(void); // Disable line aliasing +RLAPI void rlEnableStereoRender(void); // Enable stereo rendering +RLAPI void rlDisableStereoRender(void); // Disable stereo rendering +RLAPI bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled + +RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color +RLAPI void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth) +RLAPI void rlCheckErrors(void); // Check and log OpenGL error codes +RLAPI void rlSetBlendMode(int mode); // Set blending mode +RLAPI void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors) +RLAPI void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors) + +//------------------------------------------------------------------------------------ +// Functions Declaration - rlgl functionality +//------------------------------------------------------------------------------------ +// rlgl initialization functions +RLAPI void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states) +RLAPI void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures) +RLAPI void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required) +RLAPI int rlGetVersion(void); // Get current OpenGL version +RLAPI void rlSetFramebufferWidth(int width); // Set current framebuffer width +RLAPI int rlGetFramebufferWidth(void); // Get default framebuffer width +RLAPI void rlSetFramebufferHeight(int height); // Set current framebuffer height +RLAPI int rlGetFramebufferHeight(void); // Get default framebuffer height + +RLAPI unsigned int rlGetTextureIdDefault(void); // Get default texture id +RLAPI unsigned int rlGetShaderIdDefault(void); // Get default shader id +RLAPI int *rlGetShaderLocsDefault(void); // Get default shader locations + +// Render batch management +// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode +// but this render batch API is exposed in case of custom batches are required +RLAPI rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system +RLAPI void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system +RLAPI void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset) +RLAPI void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal) +RLAPI void rlDrawRenderBatchActive(void); // Update and draw internal render batch +RLAPI bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex + +RLAPI void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits + +//------------------------------------------------------------------------------------------------------------------------ + +// Vertex buffers management +RLAPI unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported +RLAPI unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer attribute +RLAPI unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load a new attributes element buffer +RLAPI void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update GPU buffer with new data +RLAPI void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements with new data +RLAPI void rlUnloadVertexArray(unsigned int vaoId); +RLAPI void rlUnloadVertexBuffer(unsigned int vboId); +RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer); +RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor); +RLAPI void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value +RLAPI void rlDrawVertexArray(int offset, int count); +RLAPI void rlDrawVertexArrayElements(int offset, int count, const void *buffer); +RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances); +RLAPI void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); + +// Textures management +RLAPI unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU +RLAPI unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo) +RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size, int format); // Load texture cubemap +RLAPI void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data +RLAPI void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats +RLAPI const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format +RLAPI void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory +RLAPI void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture +RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data +RLAPI unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer) + +// Framebuffer management (fbo) +RLAPI unsigned int rlLoadFramebuffer(int width, int height); // Load an empty framebuffer +RLAPI void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer +RLAPI bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete +RLAPI void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU + +// Shaders management +RLAPI unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings +RLAPI unsigned int rlCompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER) +RLAPI unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program +RLAPI void rlUnloadShaderProgram(unsigned int id); // Unload shader program +RLAPI int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform +RLAPI int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute +RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform +RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix +RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler +RLAPI void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations) + +// Compute shader management +RLAPI unsigned int rlLoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program +RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline) + +// Shader buffer storage object management (ssbo) +RLAPI unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO) +RLAPI void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO) +RLAPI void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data +RLAPI void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer +RLAPI void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU) +RLAPI void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers +RLAPI unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size + +// Buffer management +RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture + +// Matrix state management +RLAPI Matrix rlGetMatrixModelview(void); // Get internal modelview matrix +RLAPI Matrix rlGetMatrixProjection(void); // Get internal projection matrix +RLAPI Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix +RLAPI Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye) +RLAPI void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) +RLAPI void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) +RLAPI void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering +RLAPI void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering + +// Quick and dirty cube/quad buffers load->draw->unload +RLAPI void rlLoadDrawCube(void); // Load and draw a cube +RLAPI void rlLoadDrawQuad(void); // Load and draw a quad + +#if defined(__cplusplus) +} +#endif + +#endif // RLGL_H + +/*********************************************************************************** +* +* RLGL IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RLGL_IMPLEMENTATION) + +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(__APPLE__) + #include // OpenGL 1.1 library for OSX + #include // OpenGL extensions library + #else + // APIENTRY for OpenGL function pointer declarations is required + #if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #endif + // WINGDIAPI definition. Some Windows OpenGL headers need it + #if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #endif + + #include // OpenGL 1.1 library + #endif +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + #define GLAD_MALLOC RL_MALLOC + #define GLAD_FREE RL_FREE + + #define GLAD_GL_IMPLEMENTATION + #include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers +#endif + +#if defined(GRAPHICS_API_OPENGL_ES3) + #include // OpenGL ES 3.0 library + #define GL_GLEXT_PROTOTYPES + #include // OpenGL ES 2.0 extensions library +#elif defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP, + // in that case, functions are loaded from a custom glad for OpenGL ES 2.0 + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + #define GLAD_GLES2_IMPLEMENTATION + #include "external/glad_gles2.h" + #else + #define GL_GLEXT_PROTOTYPES + //#include // EGL library -> not required, platform layer + #include // OpenGL ES 2.0 library + #include // OpenGL ES 2.0 extensions library + #endif + + // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi + // provided headers (despite being defined in official Khronos GLES2 headers) + #if defined(PLATFORM_DRM) + typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); + #endif +#endif + +#include // Required for: malloc(), free() +#include // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading] +#include // Required for: sqrtf(), sinf(), cosf(), floor(), log() + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef PI + #define PI 3.14159265358979323846f +#endif +#ifndef DEG2RAD + #define DEG2RAD (PI/180.0f) +#endif +#ifndef RAD2DEG + #define RAD2DEG (180.0f/PI) +#endif + +#ifndef GL_SHADING_LANGUAGE_VERSION + #define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#endif + +#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#endif +#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT + #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 +#endif +#ifndef GL_ETC1_RGB8_OES + #define GL_ETC1_RGB8_OES 0x8D64 +#endif +#ifndef GL_COMPRESSED_RGB8_ETC2 + #define GL_COMPRESSED_RGB8_ETC2 0x9274 +#endif +#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC + #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 +#endif +#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 +#endif +#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG + #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR + #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 +#endif +#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR + #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 +#endif + +#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF +#endif +#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + #define GL_UNSIGNED_SHORT_5_6_5 0x8363 + #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 + #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + #define GL_LUMINANCE 0x1909 + #define GL_LUMINANCE_ALPHA 0x190A +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + #define glClearDepth glClearDepthf + #if !defined(GRAPHICS_API_OPENGL_ES3) + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER + #endif +#endif + +// Default shader vertex attribute names to set location points +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION + #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL + #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR + #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +#endif +#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +#endif + +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW + #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION + #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL + #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +#endif +#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR + #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +#endif +#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +typedef struct rlglData { + rlRenderBatch *currentBatch; // Current render batch + rlRenderBatch defaultBatch; // Default internal render batch + + struct { + int vertexCounter; // Current active render batch vertex counter (generic, used for all batches) + float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*()) + float normalx, normaly, normalz; // Current active normal (added on glVertex*()) + unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*()) + + int currentMatrixMode; // Current matrix mode + Matrix *currentMatrix; // Current matrix pointer + Matrix modelview; // Default modelview matrix + Matrix projection; // Default projection matrix + Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate, rlScale + bool transformRequired; // Require transform matrix application to current draw-call vertex (if required) + Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop + int stackCounter; // Matrix stack counter + + unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader) + unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]; // Active texture ids to be enabled on batch drawing (0 active by default) + unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program) + unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program) + unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture + int *defaultShaderLocs; // Default shader locations pointer to be used on rendering + unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId) + int *currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs) + + bool stereoRender; // Stereo rendering flag + Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices + Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices + + // Blending variables + int currentBlendMode; // Blending mode active + int glBlendSrcFactor; // Blending source factor + int glBlendDstFactor; // Blending destination factor + int glBlendEquation; // Blending equation + int glBlendSrcFactorRGB; // Blending source RGB factor + int glBlendDestFactorRGB; // Blending destination RGB factor + int glBlendSrcFactorAlpha; // Blending source alpha factor + int glBlendDestFactorAlpha; // Blending destination alpha factor + int glBlendEquationRGB; // Blending equation for RGB + int glBlendEquationAlpha; // Blending equation for alpha + bool glCustomBlendModeModified; // Custom blending factor and equation modification status + + int framebufferWidth; // Current framebuffer width + int framebufferHeight; // Current framebuffer height + + } State; // Renderer state + struct { + bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object) + bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays) + bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot) + bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture) + bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture) + bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float) + bool texFloat16; // half float textures support (16 bit per channel) (GL_OES_texture_half_float) + bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc) + bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1) + bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility) + bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc) + bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr) + bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp) + bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic) + bool computeShader; // Compute shaders support (GL_ARB_compute_shader) + bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object) + + float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f) + int maxDepthBits; // Maximum bits for depth component + + } ExtSupported; // Extensions supported flags +} rlglData; + +typedef void *(*rlglLoadProc)(const char *name); // OpenGL extension functions loader signature (same as GLADloadproc) + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static rlglData RLGL = { 0 }; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +#if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3) +// NOTE: VAO functionality is exposed through extensions (OES) +static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL; +static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL; +static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL; + +// NOTE: Instancing functionality could also be available through extension +static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL; +static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL; +static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL; +#endif + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static void rlLoadShaderDefault(void); // Load default shader +static void rlUnloadShaderDefault(void); // Unload default shader +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +static const char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name +#endif // RLGL_SHOW_GL_DETAILS_INFO +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +static int rlGetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture) + +// Auxiliar matrix math functions +static Matrix rlMatrixIdentity(void); // Get identity matrix +static Matrix rlMatrixMultiply(Matrix left, Matrix right); // Multiply two matrices + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Matrix operations +//---------------------------------------------------------------------------------- + +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlMatrixMode(int mode) +{ + switch (mode) + { + case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break; + case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break; + case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break; + default: break; + } +} + +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + glFrustum(left, right, bottom, top, znear, zfar); +} + +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + glOrtho(left, right, bottom, top, znear, zfar); +} + +void rlPushMatrix(void) { glPushMatrix(); } +void rlPopMatrix(void) { glPopMatrix(); } +void rlLoadIdentity(void) { glLoadIdentity(); } +void rlTranslatef(float x, float y, float z) { glTranslatef(x, y, z); } +void rlRotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); } +void rlScalef(float x, float y, float z) { glScalef(x, y, z); } +void rlMultMatrixf(const float *matf) { glMultMatrixf(matf); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Choose the current matrix to be transformed +void rlMatrixMode(int mode) +{ + if (mode == RL_PROJECTION) RLGL.State.currentMatrix = &RLGL.State.projection; + else if (mode == RL_MODELVIEW) RLGL.State.currentMatrix = &RLGL.State.modelview; + //else if (mode == RL_TEXTURE) // Not supported + + RLGL.State.currentMatrixMode = mode; +} + +// Push the current matrix into RLGL.State.stack +void rlPushMatrix(void) +{ + if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)"); + + if (RLGL.State.currentMatrixMode == RL_MODELVIEW) + { + RLGL.State.transformRequired = true; + RLGL.State.currentMatrix = &RLGL.State.transform; + } + + RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix; + RLGL.State.stackCounter++; +} + +// Pop lattest inserted matrix from RLGL.State.stack +void rlPopMatrix(void) +{ + if (RLGL.State.stackCounter > 0) + { + Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1]; + *RLGL.State.currentMatrix = mat; + RLGL.State.stackCounter--; + } + + if ((RLGL.State.stackCounter == 0) && (RLGL.State.currentMatrixMode == RL_MODELVIEW)) + { + RLGL.State.currentMatrix = &RLGL.State.modelview; + RLGL.State.transformRequired = false; + } +} + +// Reset current matrix to identity matrix +void rlLoadIdentity(void) +{ + *RLGL.State.currentMatrix = rlMatrixIdentity(); +} + +// Multiply the current matrix by a translation matrix +void rlTranslatef(float x, float y, float z) +{ + Matrix matTranslation = { + 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a rotation matrix +// NOTE: The provided angle must be in degrees +void rlRotatef(float angle, float x, float y, float z) +{ + Matrix matRotation = rlMatrixIdentity(); + + // Axis vector (x, y, z) normalization + float lengthSquared = x*x + y*y + z*z; + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float inverseLength = 1.0f/sqrtf(lengthSquared); + x *= inverseLength; + y *= inverseLength; + z *= inverseLength; + } + + // Rotation matrix generation + float sinres = sinf(DEG2RAD*angle); + float cosres = cosf(DEG2RAD*angle); + float t = 1.0f - cosres; + + matRotation.m0 = x*x*t + cosres; + matRotation.m1 = y*x*t + z*sinres; + matRotation.m2 = z*x*t - y*sinres; + matRotation.m3 = 0.0f; + + matRotation.m4 = x*y*t - z*sinres; + matRotation.m5 = y*y*t + cosres; + matRotation.m6 = z*y*t + x*sinres; + matRotation.m7 = 0.0f; + + matRotation.m8 = x*z*t + y*sinres; + matRotation.m9 = y*z*t - x*sinres; + matRotation.m10 = z*z*t + cosres; + matRotation.m11 = 0.0f; + + matRotation.m12 = 0.0f; + matRotation.m13 = 0.0f; + matRotation.m14 = 0.0f; + matRotation.m15 = 1.0f; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by a scaling matrix +void rlScalef(float x, float y, float z) +{ + Matrix matScale = { + x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + // NOTE: We transpose matrix with multiplication order + *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix); +} + +// Multiply the current matrix by another matrix +void rlMultMatrixf(const float *matf) +{ + // Matrix creation from array + Matrix mat = { matf[0], matf[4], matf[8], matf[12], + matf[1], matf[5], matf[9], matf[13], + matf[2], matf[6], matf[10], matf[14], + matf[3], matf[7], matf[11], matf[15] }; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, mat); +} + +// Multiply the current matrix by a perspective matrix generated by parameters +void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar) +{ + Matrix matFrustum = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matFrustum.m0 = ((float) znear*2.0f)/rl; + matFrustum.m1 = 0.0f; + matFrustum.m2 = 0.0f; + matFrustum.m3 = 0.0f; + + matFrustum.m4 = 0.0f; + matFrustum.m5 = ((float) znear*2.0f)/tb; + matFrustum.m6 = 0.0f; + matFrustum.m7 = 0.0f; + + matFrustum.m8 = ((float)right + (float)left)/rl; + matFrustum.m9 = ((float)top + (float)bottom)/tb; + matFrustum.m10 = -((float)zfar + (float)znear)/fn; + matFrustum.m11 = -1.0f; + + matFrustum.m12 = 0.0f; + matFrustum.m13 = 0.0f; + matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn; + matFrustum.m15 = 0.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum); +} + +// Multiply the current matrix by an orthographic matrix generated by parameters +void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar) +{ + // NOTE: If left-right and top-botton values are equal it could create a division by zero, + // response to it is platform/compiler dependant + Matrix matOrtho = { 0 }; + + float rl = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); + + matOrtho.m0 = 2.0f/rl; + matOrtho.m1 = 0.0f; + matOrtho.m2 = 0.0f; + matOrtho.m3 = 0.0f; + matOrtho.m4 = 0.0f; + matOrtho.m5 = 2.0f/tb; + matOrtho.m6 = 0.0f; + matOrtho.m7 = 0.0f; + matOrtho.m8 = 0.0f; + matOrtho.m9 = 0.0f; + matOrtho.m10 = -2.0f/fn; + matOrtho.m11 = 0.0f; + matOrtho.m12 = -((float)left + (float)right)/rl; + matOrtho.m13 = -((float)top + (float)bottom)/tb; + matOrtho.m14 = -((float)zfar + (float)znear)/fn; + matOrtho.m15 = 1.0f; + + *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho); +} +#endif + +// Set the viewport area (transformation from normalized device coordinates to window coordinates) +// NOTE: We store current viewport dimensions +void rlViewport(int x, int y, int width, int height) +{ + glViewport(x, y, width, height); +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - Vertex level operations +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_11) +// Fallback to OpenGL 1.1 function calls +//--------------------------------------- +void rlBegin(int mode) +{ + switch (mode) + { + case RL_LINES: glBegin(GL_LINES); break; + case RL_TRIANGLES: glBegin(GL_TRIANGLES); break; + case RL_QUADS: glBegin(GL_QUADS); break; + default: break; + } +} + +void rlEnd() { glEnd(); } +void rlVertex2i(int x, int y) { glVertex2i(x, y); } +void rlVertex2f(float x, float y) { glVertex2f(x, y); } +void rlVertex3f(float x, float y, float z) { glVertex3f(x, y, z); } +void rlTexCoord2f(float x, float y) { glTexCoord2f(x, y); } +void rlNormal3f(float x, float y, float z) { glNormal3f(x, y, z); } +void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); } +void rlColor3f(float x, float y, float z) { glColor3f(x, y, z); } +void rlColor4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); } +#endif +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Initialize drawing mode (how to organize vertex) +void rlBegin(int mode) +{ + // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS + // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId; + } +} + +// Finish vertex providing +void rlEnd(void) +{ + // NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values, + // as well as depth buffer bit-depth (16bit or 24bit or 32bit) + // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits) + RLGL.currentBatch->currentDepth += (1.0f/20000.0f); +} + +// Define one vertex (position) +// NOTE: Vertex position data is the basic information required for drawing +void rlVertex3f(float x, float y, float z) +{ + float tx = x; + float ty = y; + float tz = z; + + // Transform provided vector if required + if (RLGL.State.transformRequired) + { + tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12; + ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13; + tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14; + } + + // WARNING: We can't break primitives when launching a new batch. + // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices. + // We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4 + if (RLGL.State.vertexCounter > (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4)) + { + if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%2 == 0)) + { + // Reached the maximum number of vertices for RL_LINES drawing + // Launch a draw call but keep current state for next vertices comming + // NOTE: We add +1 vertex to the check for security + rlCheckRenderBatchLimit(2 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0)) + { + rlCheckRenderBatchLimit(3 + 1); + } + else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_QUADS) && + (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4 == 0)) + { + rlCheckRenderBatchLimit(4 + 1); + } + } + + // Add vertices + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter] = tx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 1] = ty; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 2] = tz; + + // Add current texcoord + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter] = RLGL.State.texcoordx; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy; + + // WARNING: By default rlVertexBuffer struct does not store normals + + // Add current color + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter] = RLGL.State.colorr; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 1] = RLGL.State.colorg; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 2] = RLGL.State.colorb; + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 3] = RLGL.State.colora; + + RLGL.State.vertexCounter++; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++; +} + +// Define one vertex (position) +void rlVertex2f(float x, float y) +{ + rlVertex3f(x, y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (position) +void rlVertex2i(int x, int y) +{ + rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth); +} + +// Define one vertex (texture coordinate) +// NOTE: Texture coordinates are limited to QUADS only +void rlTexCoord2f(float x, float y) +{ + RLGL.State.texcoordx = x; + RLGL.State.texcoordy = y; +} + +// Define one vertex (normal) +// NOTE: Normals limited to TRIANGLES only? +void rlNormal3f(float x, float y, float z) +{ + RLGL.State.normalx = x; + RLGL.State.normaly = y; + RLGL.State.normalz = z; +} + +// Define one vertex (color) +void rlColor4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w) +{ + RLGL.State.colorr = x; + RLGL.State.colorg = y; + RLGL.State.colorb = z; + RLGL.State.colora = w; +} + +// Define one vertex (color) +void rlColor4f(float r, float g, float b, float a) +{ + rlColor4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255)); +} + +// Define one vertex (color) +void rlColor3f(float x, float y, float z) +{ + rlColor4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255); +} + +#endif + +//-------------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2) +//-------------------------------------------------------------------------------------- + +// Set current texture to use +void rlSetTexture(unsigned int id) +{ + if (id == 0) + { +#if defined(GRAPHICS_API_OPENGL_11) + rlDisableTexture(); +#else + // NOTE: If quads batch limit is reached, we force a draw call and next batch starts + if (RLGL.State.vertexCounter >= + RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4) + { + rlDrawRenderBatch(RLGL.currentBatch); + } +#endif + } + else + { +#if defined(GRAPHICS_API_OPENGL_11) + rlEnableTexture(id); +#else + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id) + { + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0; + + if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment; + + RLGL.currentBatch->drawCounter++; + } + } + + if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch); + + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = id; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0; + } +#endif + } +} + +// Select and active a texture slot +void rlActiveTextureSlot(int slot) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glActiveTexture(GL_TEXTURE0 + slot); +#endif +} + +// Enable texture +void rlEnableTexture(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, id); +} + +// Disable texture +void rlDisableTexture(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_TEXTURE_2D); +#endif + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Enable texture cubemap +void rlEnableTextureCubemap(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); +#endif +} + +// Disable texture cubemap +void rlDisableTextureCubemap(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Set texture parameters (wrap mode/filter mode) +void rlTextureParameters(unsigned int id, int param, int value) +{ + glBindTexture(GL_TEXTURE_2D, id); + +#if !defined(GRAPHICS_API_OPENGL_11) + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); +#endif + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); +#endif + } + else glTexParameteri(GL_TEXTURE_2D, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); +#endif + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_2D, 0); +} + +// Set cubemap parameters (wrap mode/filter mode) +void rlCubemapParameters(unsigned int id, int param, int value) +{ +#if !defined(GRAPHICS_API_OPENGL_11) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); + + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { + if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); + } + else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { + if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f) + { + TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif +} + +// Enable shader program +void rlEnableShader(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(id); +#endif +} + +// Disable shader program +void rlDisableShader(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(0); +#endif +} + +// Enable rendering to texture (fbo) +void rlEnableFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); +#endif +} + +// Disable rendering to texture +void rlDisableFramebuffer(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Blit active framebuffer to main framebuffer +void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask, GL_NEAREST); +#endif +} + +// Activate multiple draw color buffers +// NOTE: One color buffer is always active by default +void rlActiveDrawBuffers(int count) +{ +#if ((defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT)) + // NOTE: Maximum number of draw buffers supported is implementation dependant, + // it can be queried with glGet*() but it must be at least 8 + //GLint maxDrawBuffers = 0; + //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); + + if (count > 0) + { + if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8"); + else + { + unsigned int buffers[8] = { +#if defined(GRAPHICS_API_OPENGL_ES3) + GL_COLOR_ATTACHMENT0_EXT, + GL_COLOR_ATTACHMENT1_EXT, + GL_COLOR_ATTACHMENT2_EXT, + GL_COLOR_ATTACHMENT3_EXT, + GL_COLOR_ATTACHMENT4_EXT, + GL_COLOR_ATTACHMENT5_EXT, + GL_COLOR_ATTACHMENT6_EXT, + GL_COLOR_ATTACHMENT7_EXT, +#else + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, +#endif + }; + +#if defined(GRAPHICS_API_OPENGL_ES3) + glDrawBuffersEXT(count, buffers); +#else + glDrawBuffers(count, buffers); +#endif + } + } + else TRACELOG(LOG_WARNING, "GL: One color buffer active by default"); +#endif +} + +//---------------------------------------------------------------------------------- +// General render state configuration +//---------------------------------------------------------------------------------- + +// Enable color blending +void rlEnableColorBlend(void) { glEnable(GL_BLEND); } + +// Disable color blending +void rlDisableColorBlend(void) { glDisable(GL_BLEND); } + +// Enable depth test +void rlEnableDepthTest(void) { glEnable(GL_DEPTH_TEST); } + +// Disable depth test +void rlDisableDepthTest(void) { glDisable(GL_DEPTH_TEST); } + +// Enable depth write +void rlEnableDepthMask(void) { glDepthMask(GL_TRUE); } + +// Disable depth write +void rlDisableDepthMask(void) { glDepthMask(GL_FALSE); } + +// Enable backface culling +void rlEnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); } + +// Disable backface culling +void rlDisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); } + +// Set face culling mode +void rlSetCullFace(int mode) +{ + switch (mode) + { + case RL_CULL_FACE_BACK: glCullFace(GL_BACK); break; + case RL_CULL_FACE_FRONT: glCullFace(GL_FRONT); break; + default: break; + } +} + +// Enable scissor test +void rlEnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); } + +// Disable scissor test +void rlDisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); } + +// Scissor test +void rlScissor(int x, int y, int width, int height) { glScissor(x, y, width, height); } + +// Enable wire mode +void rlEnableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); +#endif +} + +void rlEnablePointMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); + glEnable(GL_PROGRAM_POINT_SIZE); +#endif +} +// Disable wire mode +void rlDisableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); +#endif +} + +// Set the line drawing width +void rlSetLineWidth(float width) { glLineWidth(width); } + +// Get the line drawing width +float rlGetLineWidth(void) +{ + float width = 0; + glGetFloatv(GL_LINE_WIDTH, &width); + return width; +} + +// Enable line aliasing +void rlEnableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_LINE_SMOOTH); +#endif +} + +// Disable line aliasing +void rlDisableSmoothLines(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_LINE_SMOOTH); +#endif +} + +// Enable stereo rendering +void rlEnableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = true; +#endif +} + +// Disable stereo rendering +void rlDisableStereoRender(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL.State.stereoRender = false; +#endif +} + +// Check if stereo render is enabled +bool rlIsStereoRenderEnabled(void) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + return RLGL.State.stereoRender; +#else + return false; +#endif +} + +// Clear color buffer with color +void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a) +{ + // Color values clamp to 0.0f(0) and 1.0f(255) + float cr = (float)r/255; + float cg = (float)g/255; + float cb = (float)b/255; + float ca = (float)a/255; + + glClearColor(cr, cg, cb, ca); +} + +// Clear used screen buffers (color and depth) +void rlClearScreenBuffers(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is used for 3D) + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used... +} + +// Check and log OpenGL error codes +void rlCheckErrors() +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + int check = 1; + while (check) + { + const GLenum err = glGetError(); + switch (err) + { + case GL_NO_ERROR: check = 0; break; + case 0x0500: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break; + case 0x0501: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break; + case 0x0502: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break; + case 0x0503: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break; + case 0x0504: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break; + case 0x0505: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break; + case 0x0506: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break; + default: TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break; + } + } +#endif +} + +// Set blend mode +void rlSetBlendMode(int mode) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified)) + { + rlDrawRenderBatch(RLGL.currentBatch); + + switch (mode) + { + case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break; + case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_CUSTOM: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors() + glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation); + + } break; + case RL_BLEND_CUSTOM_SEPARATE: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate() + glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha); + glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha); + + } break; + default: break; + } + + RLGL.State.currentBlendMode = mode; + RLGL.State.glCustomBlendModeModified = false; + } +#endif +} + +// Set blending mode factor and equation +void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactor != glSrcFactor) || + (RLGL.State.glBlendDstFactor != glDstFactor) || + (RLGL.State.glBlendEquation != glEquation)) + { + RLGL.State.glBlendSrcFactor = glSrcFactor; + RLGL.State.glBlendDstFactor = glDstFactor; + RLGL.State.glBlendEquation = glEquation; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +// Set blending mode factor and equation separately for RGB and alpha +void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.glBlendSrcFactorRGB != glSrcRGB) || + (RLGL.State.glBlendDestFactorRGB != glDstRGB) || + (RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha) || + (RLGL.State.glBlendDestFactorAlpha != glDstAlpha) || + (RLGL.State.glBlendEquationRGB != glEqRGB) || + (RLGL.State.glBlendEquationAlpha != glEqAlpha)) + { + RLGL.State.glBlendSrcFactorRGB = glSrcRGB; + RLGL.State.glBlendDestFactorRGB = glDstRGB; + RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha; + RLGL.State.glBlendDestFactorAlpha = glDstAlpha; + RLGL.State.glBlendEquationRGB = glEqRGB; + RLGL.State.glBlendEquationAlpha = glEqAlpha; + + RLGL.State.glCustomBlendModeModified = true; + } +#endif +} + +//---------------------------------------------------------------------------------- +// Module Functions Definition - OpenGL Debug +//---------------------------------------------------------------------------------- +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) +static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) +{ + // Ignore non-significant error/warning codes (NVidia drivers) + // NOTE: Here there are the details with a sample output: + // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low) + // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4) + // will use VIDEO memory as the source for buffer object operations. (severity: low) + // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium) + // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have + // a defined base level and cannot be used for texture mapping. (severity: low) + if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return; + + const char *msgSource = NULL; + switch (source) + { + case GL_DEBUG_SOURCE_API: msgSource = "API"; break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break; + case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break; + case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break; + case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break; + default: break; + } + + const char *msgType = NULL; + switch (type) + { + case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break; + case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break; + case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break; + case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break; + case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break; + case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break; + default: break; + } + + const char *msgSeverity = "DEFAULT"; + switch (severity) + { + case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break; + case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break; + case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break; + case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break; + default: break; + } + + TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message); + TRACELOG(LOG_WARNING, " > Type: %s", msgType); + TRACELOG(LOG_WARNING, " > Source = %s", msgSource); + TRACELOG(LOG_WARNING, " > Severity = %s", msgSeverity); +} +#endif + +//---------------------------------------------------------------------------------- +// Module Functions Definition - rlgl functionality +//---------------------------------------------------------------------------------- + +// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states +void rlglInit(int width, int height) +{ + // Enable OpenGL debug context if required +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) + if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL)) + { + glDebugMessageCallback(rlDebugMessageCallback, 0); + // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); + + // Debug context options: + // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints + // - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + } +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Init default white texture + unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes) + RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); + + if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture"); + + // Init default Shader (customized for GL 3.3 and ES2) + // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs + rlLoadShaderDefault(); + RLGL.State.currentShaderId = RLGL.State.defaultShaderId; + RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs; + + // Init default vertex arrays buffers + RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS); + RLGL.currentBatch = &RLGL.defaultBatch; + + // Init stack matrices (emulating OpenGL 1.1) + for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity(); + + // Init internal matrices + RLGL.State.transform = rlMatrixIdentity(); + RLGL.State.projection = rlMatrixIdentity(); + RLGL.State.modelview = rlMatrixIdentity(); + RLGL.State.currentMatrix = &RLGL.State.modelview; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + + // Initialize OpenGL default states + //---------------------------------------------------------- + // Init state: Depth test + glDepthFunc(GL_LEQUAL); // Type of depth testing to apply + glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D) + + // Init state: Blending mode + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed) + glEnable(GL_BLEND); // Enable color blending (required to work with transparencies) + + // Init state: Culling + // NOTE: All shapes/models triangles are drawn CCW + glCullFace(GL_BACK); // Cull the back face (default) + glFrontFace(GL_CCW); // Front face are defined counter clockwise (default) + glEnable(GL_CULL_FACE); // Enable backface culling + + // Init state: Cubemap seamless +#if defined(GRAPHICS_API_OPENGL_33) + glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // Seamless cubemaps (not supported on OpenGL ES 2.0) +#endif + +#if defined(GRAPHICS_API_OPENGL_11) + // Init state: Color hints (deprecated in OpenGL 3.0+) + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Improve quality of color and texture coordinate interpolation + glShadeModel(GL_SMOOTH); // Smooth shading between vertex (vertex colors interpolation) +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Store screen size into global variables + RLGL.State.framebufferWidth = width; + RLGL.State.framebufferHeight = height; + + TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully"); + //---------------------------------------------------------- +#endif + + // Init state: Color/Depth buffers clear + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set clear color (black) + glClearDepth(1.0f); // Set clear depth value (default) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers (depth buffer required for 3D) +} + +// Vertex Buffer Object deinitialization (memory free) +void rlglClose(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlUnloadRenderBatch(RLGL.defaultBatch); + + rlUnloadShaderDefault(); // Unload default shader + + glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId); +#endif +} + +// Load OpenGL extensions +// NOTE: External loader function must be provided +void rlLoadExtensions(void *loader) +{ +#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21 + // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions) + if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully"); + + // Get number of supported extensions + GLint numExt = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Get supported extensions list + // WARNING: glGetStringi() not available on OpenGL 2.1 + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", glGetStringi(GL_EXTENSIONS, i)); +#endif + +#if defined(GRAPHICS_API_OPENGL_21) + // Register supported extensions flags + // Optional OpenGL 2.1 extensions + RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object; + RLGL.ExtSupported.instancing = (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays); + RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two; + RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float; + RLGL.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float; + RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic; + RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp; +#else + // Register supported extensions flags + // OpenGL 3.3 extensions supported by default (core) + RLGL.ExtSupported.vao = true; + RLGL.ExtSupported.instancing = true; + RLGL.ExtSupported.texNPOT = true; + RLGL.ExtSupported.texFloat32 = true; + RLGL.ExtSupported.texFloat16 = true; + RLGL.ExtSupported.texDepth = true; + RLGL.ExtSupported.maxDepthBits = 32; + RLGL.ExtSupported.texAnisoFilter = true; + RLGL.ExtSupported.texMirrorClamp = true; +#endif + + // Optional OpenGL 3.3 extensions + RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr; + RLGL.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT + RLGL.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC + #if defined(GRAPHICS_API_OPENGL_43) + RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader; + RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object; + #endif + +#endif // GRAPHICS_API_OPENGL_33 + +#if defined(GRAPHICS_API_OPENGL_ES3) + // Register supported extensions flags + // OpenGL ES 3.0 extensions supported by default (or it should be) + RLGL.ExtSupported.vao = true; + RLGL.ExtSupported.instancing = true; + RLGL.ExtSupported.texNPOT = true; + RLGL.ExtSupported.texFloat32 = true; + RLGL.ExtSupported.texFloat16 = true; + RLGL.ExtSupported.texDepth = true; + RLGL.ExtSupported.texDepthWebGL = true; + RLGL.ExtSupported.maxDepthBits = 24; + RLGL.ExtSupported.texAnisoFilter = true; + RLGL.ExtSupported.texMirrorClamp = true; + // TODO: Check for additional OpenGL ES 3.0 supported extensions: + //RLGL.ExtSupported.texCompDXT = true; + //RLGL.ExtSupported.texCompETC1 = true; + //RLGL.ExtSupported.texCompETC2 = true; + //RLGL.ExtSupported.texCompPVRT = true; + //RLGL.ExtSupported.texCompASTC = true; + //RLGL.ExtSupported.maxAnisotropyLevel = true; + //RLGL.ExtSupported.computeShader = true; + //RLGL.ExtSupported.ssbo = true; + +#elif defined(GRAPHICS_API_OPENGL_ES2) + + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + // TODO: Support GLAD loader for OpenGL ES 3.0 + if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully"); + #endif + + // Get supported extensions list + GLint numExt = 0; + const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB) + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); // One big const string + + // NOTE: We have to duplicate string because glGetString() returns a const string + int size = strlen(extensions) + 1; // Get extensions string size in bytes + char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char)); + strcpy(extensionsDup, extensions); + extList[numExt] = extensionsDup; + + for (int i = 0; i < size; i++) + { + if (extensionsDup[i] == ' ') + { + extensionsDup[i] = '\0'; + numExt++; + extList[numExt] = &extensionsDup[i + 1]; + } + } + + TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", extList[i]); +#endif + + // Check required extensions + for (int i = 0; i < numExt; i++) + { + // Check VAO support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0) + { + // The extension is supported by our hardware and driver, try to get related functions pointers + // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... + glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glGenVertexArraysOES"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)("glBindVertexArrayOES"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glDeleteVertexArraysOES"); + //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted + + if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true; + } + + // Check instanced rendering support + if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0) // Web ANGLE + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedANGLE"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorANGLE"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + else + { + if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0) && // Standard EXT + (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0)) + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorEXT"); + + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true; + } + } + + // Check NPOT textures support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL.ExtSupported.texNPOT = true; + + // Check texture float support + if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true; + if (strcmp(extList[i], (const char *)"GL_OES_texture_half_float") == 0) RLGL.ExtSupported.texFloat16 = true; + + // Check depth texture support + if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL.ExtSupported.texDepth = true; + if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format + if (RLGL.ExtSupported.texDepthWebGL) RLGL.ExtSupported.texDepth = true; + + if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL + if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL + + // Check texture compression support: DXT + if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true; + + // Check texture compression support: ETC1 + if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL.ExtSupported.texCompETC1 = true; + + // Check texture compression support: ETC2/EAC + if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL.ExtSupported.texCompETC2 = true; + + // Check texture compression support: PVR + if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL.ExtSupported.texCompPVRT = true; + + // Check texture compression support: ASTC + if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL.ExtSupported.texCompASTC = true; + + // Check anisotropic texture filter support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL.ExtSupported.texAnisoFilter = true; + + // Check clamp mirror wrap mode support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL.ExtSupported.texMirrorClamp = true; + } + + // Free extensions pointers + RL_FREE(extList); + RL_FREE(extensionsDup); // Duplicated string must be deallocated +#endif // GRAPHICS_API_OPENGL_ES2 + + // Check OpenGL information and capabilities + //------------------------------------------------------------------------------ + // Show current OpenGL and GLSL version + TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:"); + TRACELOG(RL_LOG_INFO, " > Vendor: %s", glGetString(GL_VENDOR)); + TRACELOG(RL_LOG_INFO, " > Renderer: %s", glGetString(GL_RENDERER)); + TRACELOG(RL_LOG_INFO, " > Version: %s", glGetString(GL_VERSION)); + TRACELOG(RL_LOG_INFO, " > GLSL: %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Anisotropy levels capability is an extension + #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + #endif + glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Show some OpenGL GPU capabilities + TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:"); + GLint capability = 0; + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability); + glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability); + #if !defined(GRAPHICS_API_OPENGL_ES2) + glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability); + glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability); + if (RLGL.ExtSupported.texAnisoFilter) TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel); + #endif + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability); + TRACELOG(RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability); + GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint)); + glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats); + for (int i = 0; i < capability; i++) TRACELOG(RL_LOG_INFO, " %s", rlGetCompressedFormatName(compFormats[i])); + RL_FREE(compFormats); + +#if defined(GRAPHICS_API_OPENGL_43) + glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability); + glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability); + TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability); +#endif // GRAPHICS_API_OPENGL_43 +#else // RLGL_SHOW_GL_DETAILS_INFO + + // Show some basic info about GL supported features + if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully"); + else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported"); + if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported"); + else TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)"); + if (RLGL.ExtSupported.texCompDXT) TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported"); + if (RLGL.ExtSupported.texCompETC1) TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported"); + if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported"); + if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported"); + if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported"); + if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported"); + if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported"); +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +} + +// Get current OpenGL version +int rlGetVersion(void) +{ + int glVersion = 0; +#if defined(GRAPHICS_API_OPENGL_11) + glVersion = RL_OPENGL_11; +#endif +#if defined(GRAPHICS_API_OPENGL_21) + glVersion = RL_OPENGL_21; +#elif defined(GRAPHICS_API_OPENGL_43) + glVersion = RL_OPENGL_43; +#elif defined(GRAPHICS_API_OPENGL_33) + glVersion = RL_OPENGL_33; +#endif +#if defined(GRAPHICS_API_OPENGL_ES3) + glVersion = RL_OPENGL_ES_30; +#elif defined(GRAPHICS_API_OPENGL_ES2) + glVersion = RL_OPENGL_ES_20; +#endif + + return glVersion; +} + +// Set current framebuffer width +void rlSetFramebufferWidth(int width) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferWidth = width; +#endif +} + +// Set current framebuffer height +void rlSetFramebufferHeight(int height) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.framebufferHeight = height; +#endif +} + +// Get default framebuffer width +int rlGetFramebufferWidth(void) +{ + int width = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + width = RLGL.State.framebufferWidth; +#endif + return width; +} + +// Get default framebuffer height +int rlGetFramebufferHeight(void) +{ + int height = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + height = RLGL.State.framebufferHeight; +#endif + return height; +} + +// Get default internal texture (white texture) +// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 +unsigned int rlGetTextureIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultTextureId; +#endif + return id; +} + +// Get default shader id +unsigned int rlGetShaderIdDefault(void) +{ + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL.State.defaultShaderId; +#endif + return id; +} + +// Get default shader locs +int *rlGetShaderLocsDefault(void) +{ + int *locs = NULL; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + locs = RLGL.State.defaultShaderLocs; +#endif + return locs; +} + +// Render batch management +//------------------------------------------------------------------------------------------------ +// Load render batch +rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements) +{ + rlRenderBatch batch = { 0 }; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes) + //-------------------------------------------------------------------------------------------- + batch.vertexBuffer = (rlVertexBuffer *)RL_MALLOC(numBuffers*sizeof(rlVertexBuffer)); + + for (int i = 0; i < numBuffers; i++) + { + batch.vertexBuffer[i].elementCount = bufferElements; + + batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float)); // 3 float by vertex, 4 vertex by quad + batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float)); // 2 float by texcoord, 4 texcoord by quad + batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char)); // 4 float by color, 4 colors by quad +#if defined(GRAPHICS_API_OPENGL_33) + batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int)); // 6 int by quad (indices) +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short)); // 6 int by quad (indices) +#endif + + for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f; + for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f; + for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0; + + int k = 0; + + // Indices can be initialized right now + for (int j = 0; j < (6*bufferElements); j += 6) + { + batch.vertexBuffer[i].indices[j] = 4*k; + batch.vertexBuffer[i].indices[j + 1] = 4*k + 1; + batch.vertexBuffer[i].indices[j + 2] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 3] = 4*k; + batch.vertexBuffer[i].indices[j + 4] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 5] = 4*k + 3; + + k++; + } + + RLGL.State.vertexCounter = 0; + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)"); + //-------------------------------------------------------------------------------------------- + + // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs + //-------------------------------------------------------------------------------------------- + for (int i = 0; i < numBuffers; i++) + { + if (RLGL.ExtSupported.vao) + { + // Initialize Quads VAO + glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId); + glBindVertexArray(batch.vertexBuffer[i].vaoId); + } + + // Quads - Vertex buffers binding and attributes enable + // Vertex position buffer (shader-location = 0) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + + // Vertex texcoord buffer (shader-location = 1) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + + // Vertex color buffer (shader-location = 3) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + + // Fill index buffer + glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]); +#if defined(GRAPHICS_API_OPENGL_33) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); +#endif + } + + TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)"); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + //-------------------------------------------------------------------------------------------- + + // Init draw calls tracking system + //-------------------------------------------------------------------------------------------- + batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall)); + + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch.draws[i].mode = RL_QUADS; + batch.draws[i].vertexCount = 0; + batch.draws[i].vertexAlignment = 0; + //batch.draws[i].vaoId = 0; + //batch.draws[i].shaderId = 0; + batch.draws[i].textureId = RLGL.State.defaultTextureId; + //batch.draws[i].RLGL.State.projection = rlMatrixIdentity(); + //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity(); + } + + batch.bufferCount = numBuffers; // Record buffer count + batch.drawCounter = 1; // Reset draws counter + batch.currentDepth = -1.0f; // Reset depth value + //-------------------------------------------------------------------------------------------- +#endif + + return batch; +} + +// Unload default internal buffers vertex data from CPU and GPU +void rlUnloadRenderBatch(rlRenderBatch batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Unbind everything + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + // Unload all vertex buffers data + for (int i = 0; i < batch.bufferCount; i++) + { + // Unbind VAO attribs data + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(batch.vertexBuffer[i].vaoId); + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + glDisableVertexAttribArray(2); + glDisableVertexAttribArray(3); + glBindVertexArray(0); + } + + // Delete VBOs from GPU (VRAM) + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]); + + // Delete VAOs from GPU (VRAM) + if (RLGL.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId); + + // Free vertex arrays memory from CPU (RAM) + RL_FREE(batch.vertexBuffer[i].vertices); + RL_FREE(batch.vertexBuffer[i].texcoords); + RL_FREE(batch.vertexBuffer[i].colors); + RL_FREE(batch.vertexBuffer[i].indices); + } + + // Unload arrays + RL_FREE(batch.vertexBuffer); + RL_FREE(batch.draws); +#endif +} + +// Draw render batch +// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer) +void rlDrawRenderBatch(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Update batch vertex buffers + //------------------------------------------------------------------------------------------------------------ + // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) + // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (use a change detector flag?) + if (RLGL.State.vertexCounter > 0) + { + // Activate elements VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + + // Vertex positions buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer + + // Texture coordinates buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer + + // Colors buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer + + // NOTE: glMapBuffer() causes sync issue. + // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. + // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). + // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new + // allocated pointer immediately even if GPU is still working with the previous data. + + // Another option: map the buffer object into client's memory + // Probably this code could be moved somewhere else... + // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); + // if (batch->vertexBuffer[batch->currentBuffer].vertices) + // { + // Update vertex data + // } + // glUnmapBuffer(GL_ARRAY_BUFFER); + + // Unbind the current VAO + if (RLGL.ExtSupported.vao) glBindVertexArray(0); + } + //------------------------------------------------------------------------------------------------------------ + + // Draw batch vertex buffers (considering VR stereo if required) + //------------------------------------------------------------------------------------------------------------ + Matrix matProjection = RLGL.State.projection; + Matrix matModelView = RLGL.State.modelview; + + int eyeCount = 1; + if (RLGL.State.stereoRender) eyeCount = 2; + + for (int eye = 0; eye < eyeCount; eye++) + { + if (eyeCount == 2) + { + // Setup current eye viewport (half screen width) + rlViewport(eye*RLGL.State.framebufferWidth/2, 0, RLGL.State.framebufferWidth/2, RLGL.State.framebufferHeight); + + // Set current eye view offset to modelview matrix + rlSetMatrixModelview(rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye])); + // Set current eye projection matrix + rlSetMatrixProjection(RLGL.State.projectionStereo[eye]); + } + + // Draw buffers + if (RLGL.State.vertexCounter > 0) + { + // Set current shader and upload current MVP matrix + glUseProgram(RLGL.State.currentShaderId); + + // Create modelview-projection matrix and upload to shader + Matrix matMVP = rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection); + float matMVPfloat[16] = { + matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3, + matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7, + matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11, + matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15 + }; + glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, matMVPfloat); + + if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + else + { + // Bind vertex attrib: position (shader-location = 0) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + + // Bind vertex attrib: texcoord (shader-location = 1) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + + // Bind vertex attrib: color (shader-location = 3) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]); + } + + // Setup some default shader values + glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f); + glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0 + + // Activate additional sampler textures + // Those additional textures will be common for all draw calls of the batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] > 0) + { + glActiveTexture(GL_TEXTURE0 + 1 + i); + glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]); + } + } + + // Activate default sampler2D texture0 (one texture is always active for default batch shader) + // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls + glActiveTexture(GL_TEXTURE0); + + for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++) + { + // Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default + glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId); + + if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount); + else + { +#if defined(GRAPHICS_API_OPENGL_33) + // We need to define the number of indices to be processed: elementCount*6 + // NOTE: The final parameter tells the GPU the offset in bytes from the + // start of the index buffer to the location of the first index to process + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint))); +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort))); +#endif + } + + vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment); + } + + if (!RLGL.ExtSupported.vao) + { + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } + + glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures + } + + if (RLGL.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO + + glUseProgram(0); // Unbind shader program + } + + // Restore viewport to default measures + if (eyeCount == 2) rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight); + //------------------------------------------------------------------------------------------------------------ + + // Reset batch buffers + //------------------------------------------------------------------------------------------------------------ + // Reset vertex counter for next frame + RLGL.State.vertexCounter = 0; + + // Reset depth for next draw + batch->currentDepth = -1.0f; + + // Restore projection/modelview matrices + RLGL.State.projection = matProjection; + RLGL.State.modelview = matModelView; + + // Reset RLGL.currentBatch->draws array + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch->draws[i].mode = RL_QUADS; + batch->draws[i].vertexCount = 0; + batch->draws[i].textureId = RLGL.State.defaultTextureId; + } + + // Reset active texture units for next batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0; + + // Reset draws counter to one draw for the batch + batch->drawCounter = 1; + //------------------------------------------------------------------------------------------------------------ + + // Change to next buffer in the list (in case of multi-buffering) + batch->currentBuffer++; + if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0; +#endif +} + +// Set the active render batch for rlgl +void rlSetRenderBatchActive(rlRenderBatch *batch) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); + + if (batch != NULL) RLGL.currentBatch = batch; + else RLGL.currentBatch = &RLGL.defaultBatch; +#endif +} + +// Update and draw internal render batch +void rlDrawRenderBatchActive(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside +#endif +} + +// Check internal buffer overflow for a given number of vertex +// and force a rlRenderBatch draw call if required +bool rlCheckRenderBatchLimit(int vCount) +{ + bool overflow = false; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL.State.vertexCounter + vCount) >= + (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)) + { + overflow = true; + + // Store current primitive drawing mode and texture id + int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode; + int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId; + + rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside + + // Restore state of last batch so we can continue adding vertices + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode; + RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture; + } +#endif + + return overflow; +} + +// Textures data management +//----------------------------------------------------------------------------------------- +// Convert image data to OpenGL texture (returns OpenGL valid Id) +unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount) +{ + unsigned int id = 0; + + glBindTexture(GL_TEXTURE_2D, 0); // Free any old binding + + // Check texture format support by OpenGL 1.1 (compressed textures not supported) +#if defined(GRAPHICS_API_OPENGL_11) + if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats"); + return id; + } +#else + if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) || + (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported"); + return id; + } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((!RLGL.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB)) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported"); + return id; + } + + if ((!RLGL.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA))) + { + TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported"); + return id; + } +#endif +#endif // GRAPHICS_API_OPENGL_11 + + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + + glGenTextures(1, &id); // Generate texture id + + glBindTexture(GL_TEXTURE_2D, id); + + int mipWidth = width; + int mipHeight = height; + int mipOffset = 0; // Mipmap data offset, only used for tracelog + + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned char *dataPtr = NULL; + if (data != NULL) dataPtr = (unsigned char *)data; + + // Load the different mipmap levels + for (int i = 0; i < mipmapCount; i++) + { + unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset); + + if (glInternalFormat != 0) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, dataPtr); +#endif + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + + mipWidth /= 2; + mipHeight /= 2; + mipOffset += mipSize; // Increment offset position to next mipmap + if (data != NULL) dataPtr += mipSize; // Increment data pointer to next mipmap + + // Security check for NPOT textures + if (mipWidth < 1) mipWidth = 1; + if (mipHeight < 1) mipHeight = 1; + } + + // Texture parameters configuration + // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used +#if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used + if (RLGL.ExtSupported.texNPOT) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis + } + else + { + // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work! + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis + } +#else + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis +#endif + + // Magnification and minification filters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + +#if defined(GRAPHICS_API_OPENGL_33) + if (mipmapCount > 1) + { + // Activate Trilinear filtering if mipmaps are available + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + } +#endif + + // At this point we have the texture loaded in GPU and texture parameters configured + + // NOTE: If mipmaps were not in data, they are not generated automatically + + // Unbind current texture + glBindTexture(GL_TEXTURE_2D, 0); + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, rlGetPixelFormatName(format), mipmapCount); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture"); + + return id; +} + +// Load depth texture/renderbuffer (to be attached to fbo) +// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions +unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // In case depth textures not supported, we force renderbuffer usage + if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true; + + // NOTE: We let the implementation to choose the best bit-depth + // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F + unsigned int glInternalFormat = GL_DEPTH_COMPONENT; + +#if (defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_ES3)) + // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT) + // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities + if (!RLGL.ExtSupported.texDepthWebGL || useRenderBuffer) + { + if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES; + else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES; + else glInternalFormat = GL_DEPTH_COMPONENT16; + } +#endif + + if (!useRenderBuffer && RLGL.ExtSupported.texDepth) + { + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + glBindTexture(GL_TEXTURE_2D, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully"); + } + else + { + // Create the renderbuffer that will serve as the depth attachment for the framebuffer + // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices + glGenRenderbuffers(1, &id); + glBindRenderbuffer(GL_RENDERBUFFER, id); + glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height); + + glBindRenderbuffer(GL_RENDERBUFFER, 0); + + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16); + } +#endif + + return id; +} + +// Load texture cubemap +// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other), +// expected the following convention: +X, -X, +Y, -Y, +Z, -Z +unsigned int rlLoadTextureCubemap(const void *data, int size, int format) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int dataSize = rlGetPixelDataSize(size, size, format); + + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_CUBE_MAP, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if (glInternalFormat != 0) + { + // Load cubemap faces + for (unsigned int i = 0; i < 6; i++) + { + if (data == NULL) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) + || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) + TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format"); + } + else + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize); + else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize); + } + +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#endif + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } +#endif + } + } + + // Set cubemap texture sampling parameters + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +#if defined(GRAPHICS_API_OPENGL_33) + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0 +#endif + + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); +#endif + + if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size); + else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture"); + + return id; +} + +// Update already loaded texture in GPU with new data +// NOTE: We don't know safely if internal texture format is the expected one... +void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data) +{ + glBindTexture(GL_TEXTURE_2D, id); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format); +} + +// Get OpenGL internal formats and data type from raylib PixelFormat +void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType) +{ + *glInternalFormat = 0; + *glFormat = 0; + *glType = 0; + + switch (format) + { + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + #if !defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_ES3) + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F_EXT; *glFormat = GL_RED_EXT; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F_EXT; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F_EXT; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F_EXT; *glFormat = GL_RED_EXT; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F_EXT; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F_EXT; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #else + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + #if defined(GRAPHICS_API_OPENGL_21) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_ARB; break; + #else // defined(GRAPHICS_API_OPENGL_ES2) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + #endif + #endif + #endif + #elif defined(GRAPHICS_API_OPENGL_33) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F; *glFormat = GL_RED; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #endif + #if !defined(GRAPHICS_API_OPENGL_11) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + #endif + default: TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break; + } +} + +// Unload texture from GPU memory +void rlUnloadTexture(unsigned int id) +{ + glDeleteTextures(1, &id); +} + +// Generate mipmap data for selected texture +// NOTE: Only supports GPU mipmap generation +void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_2D, id); + + // Check if texture is power-of-two (POT) + bool texIsPOT = false; + + if (((width > 0) && ((width & (width - 1)) == 0)) && + ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true; + + if ((texIsPOT) || (RLGL.ExtSupported.texNPOT)) + { + //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE + glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically + + #define MIN(a,b) (((a)<(b))? (a):(b)) + #define MAX(a,b) (((a)>(b))? (a):(b)) + + *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2)); + TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id); + + glBindTexture(GL_TEXTURE_2D, 0); +#else + TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id); +#endif +} + + +// Read texture pixel data +void *rlReadTexturePixels(unsigned int id, int width, int height, int format) +{ + void *pixels = NULL; + +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + glBindTexture(GL_TEXTURE_2D, id); + + // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0) + // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE + //int width, height, format; + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); + + // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding. + // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting. + // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.) + // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.) + glPixelStorei(GL_PACK_ALIGNMENT, 1); + + unsigned int glInternalFormat, glFormat, glType; + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + unsigned int size = rlGetPixelDataSize(width, height, format); + + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + pixels = RL_MALLOC(size); + glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels); + } + else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format); + + glBindTexture(GL_TEXTURE_2D, 0); +#endif + +#if defined(GRAPHICS_API_OPENGL_ES2) + // glGetTexImage() is not available on OpenGL ES 2.0 + // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id. + // Two possible Options: + // 1 - Bind texture to color fbo attachment and glReadPixels() + // 2 - Create an fbo, activate it, render quad with texture, glReadPixels() + // We are using Option 1, just need to care for texture format on retrieval + // NOTE: This behaviour could be conditioned by graphic driver... + unsigned int fboId = rlLoadFramebuffer(width, height); + + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + glBindTexture(GL_TEXTURE_2D, 0); + + // Attach our texture to FBO + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0); + + // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format + pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)); + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + // Clean up temporal fbo + rlUnloadFramebuffer(fboId); +#endif + + return pixels; +} + +// Read screen pixel data (color buffer) +unsigned char *rlReadScreenPixels(int width, int height) +{ + unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char)); + + // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer + // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly! + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData); + + // Flip image vertically! + unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char)); + + for (int y = height - 1; y >= 0; y--) + { + for (int x = 0; x < (width*4); x++) + { + imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line + + // Set alpha component value to 255 (no trasparent image retrieval) + // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! + if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255; + } + } + + RL_FREE(screenData); + + return imgData; // NOTE: image data should be freed +} + +// Framebuffer management (fbo) +//----------------------------------------------------------------------------------------- +// Load a framebuffer to be used for rendering +// NOTE: No textures attached +unsigned int rlLoadFramebuffer(int width, int height) +{ + unsigned int fboId = 0; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glGenFramebuffers(1, &fboId); // Create the framebuffer object + glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer +#endif + + return fboId; +} + +// Attach color buffer texture to an fbo (unloads previous attachment) +// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture +void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + + switch (attachType) + { + case RL_ATTACHMENT_COLOR_CHANNEL0: + case RL_ATTACHMENT_COLOR_CHANNEL1: + case RL_ATTACHMENT_COLOR_CHANNEL2: + case RL_ATTACHMENT_COLOR_CHANNEL3: + case RL_ATTACHMENT_COLOR_CHANNEL4: + case RL_ATTACHMENT_COLOR_CHANNEL5: + case RL_ATTACHMENT_COLOR_CHANNEL6: + case RL_ATTACHMENT_COLOR_CHANNEL7: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId); + else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel); + + } break; + case RL_ATTACHMENT_DEPTH: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + case RL_ATTACHMENT_STENCIL: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + default: break; + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Verify render texture is complete +bool rlFramebufferComplete(unsigned int id) +{ + bool result = false; + +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); + + GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); + + if (status != GL_FRAMEBUFFER_COMPLETE) + { + switch (status) + { + case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break; + case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break; +#if defined(GRAPHICS_API_OPENGL_ES2) + case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break; +#endif + case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break; + default: break; + } + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + result = (status == GL_FRAMEBUFFER_COMPLETE); +#endif + + return result; +} + +// Unload framebuffer from GPU memory +// NOTE: All attached textures/cubemaps/renderbuffers are also deleted +void rlUnloadFramebuffer(unsigned int id) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + // Query depth attachment to automatically delete texture/renderbuffer + int depthType = 0, depthId = 0; + glBindFramebuffer(GL_FRAMEBUFFER, id); // Bind framebuffer to query depth texture type + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType); + + // TODO: Review warning retrieving object name in WebGL + // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name + // https://registry.khronos.org/webgl/specs/latest/1.0/ + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId); + + unsigned int depthIdU = (unsigned int)depthId; + if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU); + else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU); + + // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer, + // the texture image is automatically detached from the currently bound framebuffer. + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glDeleteFramebuffers(1, &id); + + TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id); +#endif +} + +// Vertex data management +//----------------------------------------------------------------------------------------- +// Load a new attributes buffer +unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Load a new attributes element buffer +unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); +#endif + + return id; +} + +// Enable vertex buffer (VBO) +void rlEnableVertexBuffer(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer (VBO) +void rlDisableVertexBuffer(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, 0); +#endif +} + +// Enable vertex buffer element (VBO element) +void rlEnableVertexBufferElement(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); +#endif +} + +// Disable vertex buffer element (VBO element) +void rlDisableVertexBufferElement(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); +#endif +} + +// Update vertex buffer with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Update vertex buffer elements with new data +// NOTE: dataSize and offset must be provided in bytes +void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data); +#endif +} + +// Enable vertex array object (VAO) +bool rlEnableVertexArray(unsigned int vaoId) +{ + bool result = false; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(vaoId); + result = true; + } +#endif + return result; +} + +// Disable vertex array object (VAO) +void rlDisableVertexArray(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) glBindVertexArray(0); +#endif +} + +// Enable vertex attribute index +void rlEnableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glEnableVertexAttribArray(index); +#endif +} + +// Disable vertex attribute index +void rlDisableVertexAttribute(unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDisableVertexAttribArray(index); +#endif +} + +// Draw vertex array +void rlDrawVertexArray(int offset, int count) +{ + glDrawArrays(GL_TRIANGLES, offset, count); +} + +// Draw vertex array elements +void rlDrawVertexArrayElements(int offset, int count, const void *buffer) +{ + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; + + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr); +} + +// Draw vertex array instanced +void rlDrawVertexArrayInstanced(int offset, int count, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances); +#endif +} + +// Draw vertex array elements instanced +void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; + + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr, instances); +#endif +} + +#if defined(GRAPHICS_API_OPENGL_11) +// Enable vertex state pointer +void rlEnableStatePointer(int vertexAttribType, void *buffer) +{ + if (buffer != NULL) glEnableClientState(vertexAttribType); + switch (vertexAttribType) + { + case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break; + case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break; + case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break; + case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break; + //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors + default: break; + } +} + +// Disable vertex state pointer +void rlDisableStatePointer(int vertexAttribType) +{ + glDisableClientState(vertexAttribType); +} +#endif + +// Load vertex array object (VAO) +unsigned int rlLoadVertexArray(void) +{ + unsigned int vaoId = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glGenVertexArrays(1, &vaoId); + } +#endif + return vaoId; +} + +// Set vertex attribute +void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribPointer(index, compSize, type, normalized, stride, pointer); +#endif +} + +// Set vertex attribute divisor +void rlSetVertexAttributeDivisor(unsigned int index, int divisor) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribDivisor(index, divisor); +#endif +} + +// Unload vertex array object (VAO) +void rlUnloadVertexArray(unsigned int vaoId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.ExtSupported.vao) + { + glBindVertexArray(0); + glDeleteVertexArrays(1, &vaoId); + TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId); + } +#endif +} + +// Unload vertex buffer (VBO) +void rlUnloadVertexBuffer(unsigned int vboId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteBuffers(1, &vboId); + //TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)"); +#endif +} + +// Shaders management +//----------------------------------------------------------------------------------------------- +// Load shader from code strings +// NOTE: If shader string is NULL, using default vertex/fragment shaders +unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode) +{ + unsigned int id = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int vertexShaderId = 0; + unsigned int fragmentShaderId = 0; + + // Compile vertex shader (if provided) + if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER); + // In case no vertex shader was provided or compilation failed, we use default vertex shader + if (vertexShaderId == 0) vertexShaderId = RLGL.State.defaultVShaderId; + + // Compile fragment shader (if provided) + if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER); + // In case no fragment shader was provided or compilation failed, we use default fragment shader + if (fragmentShaderId == 0) fragmentShaderId = RLGL.State.defaultFShaderId; + + // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id + if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId; + else + { + // One of or both shader are new, we need to compile a new shader program + id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId); + + // We can detach and delete vertex/fragment shaders (if not default ones) + // NOTE: We detach shader before deletion to make sure memory is freed + if (vertexShaderId != RLGL.State.defaultVShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, vertexShaderId); + glDeleteShader(vertexShaderId); + } + if (fragmentShaderId != RLGL.State.defaultFShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, fragmentShaderId); + glDeleteShader(fragmentShaderId); + } + + // In case shader program loading failed, we assign default shader + if (id == 0) + { + // In case shader loading fails, we return the default shader + TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader"); + id = RLGL.State.defaultShaderId; + } + /* + else + { + // Get available shader uniforms + // NOTE: This information is useful for debug... + int uniformCount = -1; + glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount); + + for (int i = 0; i < uniformCount; i++) + { + int namelen = -1; + int num = -1; + char name[256] = { 0 }; // Assume no variable names longer than 256 + GLenum type = GL_ZERO; + + // Get the name of the uniforms + glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name); + + name[namelen] = 0; + TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name)); + } + } + */ + } +#endif + + return id; +} + +// Compile custom shader and return shader id +unsigned int rlCompileShader(const char *shaderCode, int type) +{ + unsigned int shader = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + shader = glCreateShader(type); + glShaderSource(shader, 1, &shaderCode, NULL); + + GLint success = 0; + glCompileShader(shader); + glGetShaderiv(shader, GL_COMPILE_STATUS, &success); + + if (success == GL_FALSE) + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break; + #endif + default: break; + } + + int maxLength = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetShaderInfoLog(shader, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log); + RL_FREE(log); + } + } + else + { + switch (type) + { + case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break; + case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break; + #endif + default: break; + } + } +#endif + + return shader; +} + +// Load custom shader strings and return program id +unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + GLint success = 0; + program = glCreateProgram(); + + glAttachShader(program, vShaderId); + glAttachShader(program, fShaderId); + + // NOTE: Default attribute shader locations must be Bound before linking + glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION); + glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD); + glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL); + glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR); + glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT); + glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2); + + // NOTE: If some attrib name is no found on the shader, it locations becomes -1 + + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program); + } +#endif + return program; +} + +// Unload shader program +void rlUnloadShaderProgram(unsigned int id) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteProgram(id); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id); +#endif +} + +// Get shader location uniform +int rlGetLocationUniform(unsigned int shaderId, const char *uniformName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetUniformLocation(shaderId, uniformName); + + //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName); + //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location); +#endif + return location; +} + +// Get shader location attribute +int rlGetLocationAttrib(unsigned int shaderId, const char *attribName) +{ + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetAttribLocation(shaderId, attribName); + + //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName); + //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location); +#endif + return location; +} + +// Set shader value uniform +void rlSetUniform(int locIndex, const void *value, int uniformType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (uniformType) + { + case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized"); + } +#endif +} + +// Set shader value attribute +void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (attribType) + { + case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break; + default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized"); + } +#endif +} + +// Set shader value uniform matrix +void rlSetUniformMatrix(int locIndex, Matrix mat) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + float matfloat[16] = { + mat.m0, mat.m1, mat.m2, mat.m3, + mat.m4, mat.m5, mat.m6, mat.m7, + mat.m8, mat.m9, mat.m10, mat.m11, + mat.m12, mat.m13, mat.m14, mat.m15 + }; + glUniformMatrix4fv(locIndex, 1, false, matfloat); +#endif +} + +// Set shader value uniform sampler +void rlSetUniformSampler(int locIndex, unsigned int textureId) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Check if texture is already active + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL.State.activeTextureId[i] == textureId) return; + + // Register a new active texture for the internal batch system + // NOTE: Default texture is always activated as GL_TEXTURE0 + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL.State.activeTextureId[i] == 0) + { + glUniform1i(locIndex, 1 + i); // Activate new texture unit + RLGL.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing + break; + } + } +#endif +} + +// Set shader currently active (id and locations) +void rlSetShader(unsigned int id, int *locs) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL.State.currentShaderId != id) + { + rlDrawRenderBatch(RLGL.currentBatch); + RLGL.State.currentShaderId = id; + RLGL.State.currentShaderLocs = locs; + } +#endif +} + +// Load compute shader program +unsigned int rlLoadComputeShaderProgram(unsigned int shaderId) +{ + unsigned int program = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + GLint success = 0; + program = glCreateProgram(); + glAttachShader(program, shaderId); + glLinkProgram(program); + + // NOTE: All uniform variables are intitialised to 0 when a program links + + glGetProgramiv(program, GL_LINK_STATUS, &success); + + if (success == GL_FALSE) + { + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program); + + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); + + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } + + glDeleteProgram(program); + + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program); + } +#endif + + return program; +} + +// Dispatch compute shader (equivalent to *draw* for graphics pilepine) +void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDispatchCompute(groupX, groupY, groupZ); +#endif +} + +// Load shader storage buffer object (SSBO) +unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint) +{ + unsigned int ssbo = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glGenBuffers(1, &ssbo); + glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo); + glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY); + if (data == NULL) glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL); // Clear buffer data to 0 + glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); +#endif + + return ssbo; +} + +// Unload shader storage buffer object (SSBO) +void rlUnloadShaderBuffer(unsigned int ssboId) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glDeleteBuffers(1, &ssboId); +#endif +} + +// Update SSBO buffer data +void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data); +#endif +} + +// Get SSBO buffer size +unsigned int rlGetShaderBufferSize(unsigned int id) +{ + long long size = 0; + +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size); +#endif + + return (size > 0)? (unsigned int)size : 0; +} + +// Read SSBO buffer data (GPU->CPU) +void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest); +#endif +} + +// Bind SSBO buffer +void rlBindShaderBuffer(unsigned int id, unsigned int index) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id); +#endif +} + +// Copy SSBO buffer data +void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count) +{ +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_COPY_READ_BUFFER, srcId); + glBindBuffer(GL_COPY_WRITE_BUFFER, destId); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count); +#endif +} + +// Bind image texture +void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly) +{ +#if defined(GRAPHICS_API_OPENGL_43) + unsigned int glInternalFormat = 0, glFormat = 0, glType = 0; + + rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + glBindImageTexture(index, id, 0, 0, 0, readonly? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat); +#endif +} + +// Matrix state management +//----------------------------------------------------------------------------------------- +// Get internal modelview matrix +Matrix rlGetMatrixModelview(void) +{ + Matrix matrix = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_MODELVIEW_MATRIX, mat); + matrix.m0 = mat[0]; + matrix.m1 = mat[1]; + matrix.m2 = mat[2]; + matrix.m3 = mat[3]; + matrix.m4 = mat[4]; + matrix.m5 = mat[5]; + matrix.m6 = mat[6]; + matrix.m7 = mat[7]; + matrix.m8 = mat[8]; + matrix.m9 = mat[9]; + matrix.m10 = mat[10]; + matrix.m11 = mat[11]; + matrix.m12 = mat[12]; + matrix.m13 = mat[13]; + matrix.m14 = mat[14]; + matrix.m15 = mat[15]; +#else + matrix = RLGL.State.modelview; +#endif + return matrix; +} + +// Get internal projection matrix +Matrix rlGetMatrixProjection(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_PROJECTION_MATRIX,mat); + Matrix m; + m.m0 = mat[0]; + m.m1 = mat[1]; + m.m2 = mat[2]; + m.m3 = mat[3]; + m.m4 = mat[4]; + m.m5 = mat[5]; + m.m6 = mat[6]; + m.m7 = mat[7]; + m.m8 = mat[8]; + m.m9 = mat[9]; + m.m10 = mat[10]; + m.m11 = mat[11]; + m.m12 = mat[12]; + m.m13 = mat[13]; + m.m14 = mat[14]; + m.m15 = mat[15]; + return m; +#else + return RLGL.State.projection; +#endif +} + +// Get internal accumulated transform matrix +Matrix rlGetMatrixTransform(void) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // TODO: Consider possible transform matrices in the RLGL.State.stack + // Is this the right order? or should we start with the first stored matrix instead of the last one? + //Matrix matStackTransform = rlMatrixIdentity(); + //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform); + mat = RLGL.State.transform; +#endif + return mat; +} + +// Get internal projection matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixProjectionStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.projectionStereo[eye]; +#endif + return mat; +} + +// Get internal view offset matrix for stereo render (selected eye) +RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye) +{ + Matrix mat = rlMatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL.State.viewOffsetStereo[eye]; +#endif + return mat; +} + +// Set a custom modelview matrix (replaces internal modelview matrix) +void rlSetMatrixModelview(Matrix view) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.modelview = view; +#endif +} + +// Set a custom projection matrix (replaces internal projection matrix) +void rlSetMatrixProjection(Matrix projection) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projection = projection; +#endif +} + +// Set eyes projection matrices for stereo rendering +void rlSetMatrixProjectionStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.projectionStereo[0] = right; + RLGL.State.projectionStereo[1] = left; +#endif +} + +// Set eyes view offsets matrices for stereo rendering +void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL.State.viewOffsetStereo[0] = right; + RLGL.State.viewOffsetStereo[1] = left; +#endif +} + +// Load and draw a quad in NDC +void rlLoadDrawQuad(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int quadVAO = 0; + unsigned int quadVBO = 0; + + float vertices[] = { + // Positions Texcoords + -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &quadVAO); + glBindVertexArray(quadVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &quadVBO); + glBindBuffer(GL_ARRAY_BUFFER, quadVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, texcoords) + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords + + // Draw quad + glBindVertexArray(quadVAO); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + glBindVertexArray(0); + + // Delete buffers (VBO and VAO) + glDeleteBuffers(1, &quadVBO); + glDeleteVertexArrays(1, &quadVAO); +#endif +} + +// Load and draw a cube in NDC +void rlLoadDrawCube(void) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int cubeVAO = 0; + unsigned int cubeVBO = 0; + + float vertices[] = { + // Positions Normals Texcoords + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f + }; + + // Gen VAO to contain VBO + glGenVertexArrays(1, &cubeVAO); + glBindVertexArray(cubeVAO); + + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &cubeVBO); + glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + // Bind vertex attributes (position, normals, texcoords) + glBindVertexArray(cubeVAO); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + + // Draw cube + glBindVertexArray(cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); + glBindVertexArray(0); + + // Delete VBO and VAO + glDeleteBuffers(1, &cubeVBO); + glDeleteVertexArrays(1, &cubeVAO); +#endif +} + +// Get name string for pixel format +const char *rlGetPixelFormatName(unsigned int format) +{ + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break; // 8 bit per pixel (no alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break; // 8*2 bpp (2 channels) + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break; // 16 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break; // 24 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break; // 16 bpp (1 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break; // 16 bpp (4 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break; // 32 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break; // 32 bpp (1 channel - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break; // 32*3 bpp (3 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break; // 32*4 bpp (4 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: return "R16"; break; // 16 bpp (1 channel - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: return "R16G16B16"; break; // 16*3 bpp (3 channels - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: return "R16G16B16A16"; break; // 16*4 bpp (4 channels - half float) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break; // 4 bpp (no alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break; // 4 bpp (1 bit alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break; // 2 bpp + default: return "UNKNOWN"; break; + } +} + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +// Load default shader (just vertex positioning and texture coloring) +// NOTE: This shader program is used for internal buffers +// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlLoadShaderDefault(void) +{ + RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int)); + + // NOTE: All locations must be reseted to -1 (no location) + for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1; + + // Vertex shader directly defined, no external file required + const char *defaultVShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec3 vertexPosition; \n" + "in vec2 vertexTexCoord; \n" + "in vec4 vertexColor; \n" + "out vec2 fragTexCoord; \n" + "out vec4 fragColor; \n" +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) (on some browsers) + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#endif + "uniform mat4 mvp; \n" + "void main() \n" + "{ \n" + " fragTexCoord = vertexTexCoord; \n" + " fragColor = vertexColor; \n" + " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" + "} \n"; + + // Fragment shader directly defined, no external file required + const char *defaultFShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec2 fragTexCoord; \n" + "in vec4 fragColor; \n" + "out vec4 finalColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture(texture0, fragTexCoord); \n" + " finalColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#endif + + // NOTE: Compiled vertex/fragment shaders are not deleted, + // they are kept for re-use as default shaders in case some shader loading fails + RLGL.State.defaultVShaderId = rlCompileShader(defaultVShaderCode, GL_VERTEX_SHADER); // Compile default vertex shader + RLGL.State.defaultFShaderId = rlCompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER); // Compile default fragment shader + + RLGL.State.defaultShaderId = rlLoadShaderProgram(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId); + + if (RLGL.State.defaultShaderId > 0) + { + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId); + + // Set default shader locations: attributes locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexPosition"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexTexCoord"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL.State.defaultShaderId, "vertexColor"); + + // Set default shader locations: uniform locations + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(RLGL.State.defaultShaderId, "mvp"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "colDiffuse"); + RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, "texture0"); + } + else TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId); +} + +// Unload default shader +// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs +static void rlUnloadShaderDefault(void) +{ + glUseProgram(0); + + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId); + glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId); + glDeleteShader(RLGL.State.defaultVShaderId); + glDeleteShader(RLGL.State.defaultFShaderId); + + glDeleteProgram(RLGL.State.defaultShaderId); + + RL_FREE(RLGL.State.defaultShaderLocs); + + TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId); +} + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +// Get compressed format official GL identifier name +static const char *rlGetCompressedFormatName(int format) +{ + switch (format) + { + // GL_EXT_texture_compression_s3tc + case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break; + case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break; + case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break; + case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break; + // GL_3DFX_texture_compression_FXT1 + case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break; + case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break; + // GL_IMG_texture_compression_pvrtc + case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break; + case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break; + case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break; + case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break; + // GL_OES_compressed_ETC1_RGB8_texture + case 0x8D64: return "GL_ETC1_RGB8_OES"; break; + // GL_ARB_texture_compression_rgtc + case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break; + case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break; + case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break; + case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break; + // GL_ARB_texture_compression_bptc + case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break; + case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break; + case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break; + case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break; + // GL_ARB_ES3_compatibility + case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break; + case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break; + case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break; + case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break; + case 0x9270: return "GL_COMPRESSED_R11_EAC"; break; + case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break; + case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break; + case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break; + // GL_KHR_texture_compression_astc_hdr + case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break; + case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break; + case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break; + case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break; + case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break; + case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break; + case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break; + case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break; + case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break; + case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break; + case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break; + case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break; + case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break; + case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break; + case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break; + case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break; + case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break; + case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break; + case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break; + case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break; + case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break; + case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break; + case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break; + case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break; + case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break; + case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break; + case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break; + case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break; + default: return "GL_COMPRESSED_UNKNOWN"; break; + } +} +#endif // RLGL_SHOW_GL_DETAILS_INFO + +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + +// Get pixel data size in bytes (image or texture) +// NOTE: Size depends on pixel format +static int rlGetPixelDataSize(int width, int height, int format) +{ + int dataSize = 0; // Size in bytes + int bpp = 0; // Bits per pixel + + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: bpp = 16*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: bpp = 16*4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break; + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break; + default: break; + } + + dataSize = width*height*bpp/8; // Total data size in bytes + + // Most compressed formats works on 4x4 blocks, + // if texture is smaller, minimum dataSize is 8 or 16 + if ((width < 4) && (height < 4)) + { + if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8; + else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16; + } + + return dataSize; +} + +// Auxiliar math functions + +// Get identity matrix +static Matrix rlMatrixIdentity(void) +{ + Matrix result = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + return result; +} + +// Get two matrix multiplication +// NOTE: When multiplying matrices... the order matters! +static Matrix rlMatrixMultiply(Matrix left, Matrix right) +{ + Matrix result = { 0 }; + + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; + + return result; +} + +#endif // RLGL_IMPLEMENTATION diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.dll b/pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.dll new file mode 100644 index 0000000000000000000000000000000000000000..a9d218bb6c5e2e5a2d9ee69eda1ab3637da21a49 GIT binary patch literal 1821184 zcmdqKdtg-6wfH~DOklvknE+8ltfNL7jgM$(n;329kQq1w6NnEaR*|$QVtpaZ09MrC zB*N)-6sxw_`ry{y)?T&f*A`J)NO&cH^0F#oANaWSj1h^V0*cJ;h*=Il2UVE*z*IIk+ed@oz(Bt)ZJU;$18INZfSNRvxzhD0|w7}yTc*2VVJ%8x; z@`=j|VlSU~$+T-{2B*)s>6#foxFI;@2RGh$Q#|;?tAjHVHwLf0F&G|yaqxzluDbfH z0R#G%WvhNP);GB0%xh=n{_dObqZw;>zHh?yGmg{O8)kgTb@N5n&-g-LZ)is~$E) zJf5rW>g%caug0r$dAdC(1&=Bmc#5ZNu*dWJemc4MqJYQ4|NLtP9qxUh$J0md`IozT zg2%f^CauuZL{_&@?()@VH>II?n5X4ZkLNEx9OjuL6>b^s@t-L-!#%+ja?Sla-s4c^ z&JTxrF3BYw;ktO&P)|q$ntd4>>{*rv@~Z{TieEh^PIBeR^jScbz6-JR`WN(gn$DVW z)equ7@OZAQ=?n3Y=RB_ETzmZs@#ZWyn`h_E0MR_mx7IJ$9f3sd~HJhDtXY4xgI*SyL&!6Vhw_D__O=kCC{WU`X0a&^BmwYD(sZ~e?@S;bJ9 zEgvSrRc-aH>y4H_@Z23Sp1mai^hWFBJVsjIj2~sGx&q-l#mgG3X&l=(qo_Wd2$b2(_cJ&$aCo8371ZUW87h`j8wfFRc}PqK1+QZQ~RyfZE9fG4+SCg&ORq$`*00Z~ZJj$ZFjc9}rV(tF}eeCg+t{faFa4vZ^-0 z>~GuXU3|zg89~6T6fn&zCSN(}^3~B~N25grG<2$NC~SXIHx#x{K0?Jmb}LQ{S$6OU zb*a8F)exv}-If?^rbfPVSW`mS<*`((Y)&i{E}I^M#DiAq0o|9V+H7XFwYDW_{IhsJ z)uL1FJ_1r7MQ*#VKqa?xY_F--99FlBWH6TKqaj-zscMVag;wkO_-=3zHlCfQad1>} z->!HcjfmBx$4FlUZY;adRBfd6jGfd7_sAfe1yb#R)Kx|qJb@vKMf(>>a^G z>-wlI#G_WNb^(y`^Y43#3_Z09e-EADaFLW zZv8CL&#Zn%GqaIASdfUB&C5h=coNnBs`_*C)xSQ#2ZvB&j^cG2W^!4l-{UFhDyH_4 zJXNB&6#VP@F3i_A|A_Tft+(vCWde@T@)3}MXw!Js3WUzhNYdX)O78O-EwAdE!bGuV z@2+RPp3w6J5Wms#7H=fcn%C|Kix0F^zZV&rOs4dyGY0EdfO>Z7(gLUDNiWZJfl#%U zF7Ycvu9%Uu4Do=0elr7)%u@NZx z{DHxqsM@Xy!|I~quo~l6V|-RexU5nr&JLFa)yQ%?R#q0~r#x(5Qg((Bh?P|uflJDQ zQ;i{=Mu|Mh51C1ppOQ<;LPiO2FvyAiW-4?LaGEY(ZKWs_?Vw_C1k54lf!$sYdHj}& zAtLOf+M%@szCa%`0;J`j2UL=Po@9Aff{2%-Cgf1UpQ<~Uevy`qiERQt zo%1p(f^egxF2G-qKT_)`SSM*s{7tv)q=4)E;X~cOxt4wF9HXSlD1mAbbVFi{Ql)TY z|Eg`4+UyjM4lv@tC<2r529Bx5P3tW0>r;)HfA?G7&6a&}rDcz;wv;4ohj=zlHI3Up zqQ~X5A>)LQN3FHmclNQoql59&l5?s(Qj=BrH8m-zX>ILIff;L(cT|E)V3b1R%fF`3 zr4%xgD+Di;pttceqiWn7DN!Z>56c03w50|MvsuDc=9N}vr!$PQy^?xZt%pA=>t&AL z9#h){A#;@IY>98Hk&NAjnvwo`wc3IVrdjHh7z5s93AfEU$_X7rW+m5DUcTD-v;aY% zZ`JzABo4d_V;JxGl;|nEi5aJOk5#|n7ZHuT*W>aT;k#4oR zSD)xW0=kETM}`=|gg4W+T3G=VDo*(xv{_z?7VDy>8WSX`lO%4-xkT*(nRT_iK=sw= z-XT>V<#wAv^RLd=|7JWL1{xqi2>_bzaYMZ^)oH4_Gj#Q1gVDX+G`8M-(v78} z1y(JiMx{|>^!lo{sNG*oeH~7s=d$@K?@r-`}9+?BPs%auD21KXT{uT^3CKw-X zDKnU?DGJ+x1hbfl)DLv^MIqs)L?Esm8JMxjME}vGu76_cuTdMxVqZ5DJy*m>$WpGv ziBx@Nsr~i#%$=xF(-`Qe`bbp>kBzcaK~{~7pGSr*^{KJt^{F~P_npzy#oJv)@dQg9 zEi)Vhd#{uatF_J<-GwsIRomV!^w}yI5%}o(vgvS32+cez*75+l`j~*`+F3ep)tmKd zzeqOGz}F{yYERcOHJ62E7g^j5py!scbUNY){D{ylubmv8d2&=8tyV`>afemAAzl(z z5l_rmvM$=bv(WkNdB~vEUE2kkCIE4bgexb3C*js|=rg7Y(OTSIz{P{o&z)H)GxNWE z|H@I?j`)}FFMiYewdK84x_+9@wi`!~0Skc8d|3I@=K#U#(8Vz|$VxpVkkzYW5q?I? zF>)_A1N99PL=iVqx>5yXzW7WCnMop`K1caLe2D(Ggv6-}!^V<%EjstSg zEV+G>d!EissYCPSD$Q5Z(;nbvR++V1j5{wzYg8K4s%@FJz0WS7DUl6~XUx0ZzE3(4 z^KP+{y9bxABV;bJlGCTRLfJyq85OeVAJnFcg~ZD%k~R6zSh*0Nz9 zt7?s9w=Nzpczh#<)NQg3gs`Ec*{-`>29!SUJlVkj+xvR&rk^ex9Y2)FIpkTbINX(+;vAVAYy| z+5IhbA*#g|Gqc5-KeO8EXcHaUnxAy5*yx>e!^+bUxf>|CEEMIfBl3V; zprLSU^D=RNA&F&noE}qKB4Po!qx5OTUbQKU9E!m*L3>g4I#WRWI~bT%riz{s zOO3*%Vj|?T^9hN?%tWTTFvx8=sawE<<=xulwcr%D%OZ28nYGM{tHQ>pRaWZ3#ouE< zpY19{1no=i+nqScR4>g}GA=QdT*O6ii{Ma;xo27z#Hyt5lxRJ}tRlIM4@%AnduIEp z+PeIf3N;u@L;b?c|0C39nSzABnnYz4>mXIUK&YZY6vAoToNp%g7a^2WtpZBdS%T1* z`yexHP8YON^^0FD0)<+oaPFvMK2Jp!%af&T1hqSButfw60{#0Vya_`#Bl^DR(UpPEvQ> z%|#}8hK_0csU7^hUHqVSrLkWdgWPLQe4BrjU$aEvEoXoY;)ARN#?%u zbv6HP@lh~yaV1mbYNxp>;8CvtzOzn)jfL<1!V+?Fjt|9TrimtJXVDPb>5+@J2HmtjuaNvpQV6W5!#+#&~CE0B~criR%%K0;j>1MoA^LZvUp3C;9M=5guED!_W{8n-VS zbzfG6YquTN7tNo_Y_#mcJOn61O}(GRpDD8)X8B^OhroaIY@WcUqw!&H2kTY3UUkRB zR(V5xC|&fY%!BD$AvaO3V)mcPT z#z{O$e8f3+dI@>#$0r(7Z{&szI`w1um`#v&tQMDzm>7~a^F-7LE2`FG1J&DOoA_(Q zO!Qkuq%*28(8e~9f7X_$8cVLN)Mwel%MkWf%9Ko7=oETOf9Cf1sNDEQapzdxS7NoR zXPg|XT{WXNF+8g3+*VwVSLXv&71LxY%*LHT-b}h=3Vvg z@K=xj+UgMU&??%87+Foom8?;jhtBm+gJon|PE0Ti^)|lZZQAV(0>}6*FnFwM&*69R zM+^K})bb*+3l#K>Z~CZ$+|;RCN&m9wkY~nU94DG#!Bn{z`2U`06@iN15A)z<=~e1J zS-7CI(eh_*nqNF!7)-=vFrI)+f@nrY%Oj+LVafGVd95thYZS(a7NdTHGxkh~Ri-vA zcFR|55hz%{S_|vRa{K+T7S^6Ag&uQ3VKlQbnpu@ujjVqAh$SnaF?v;|EBJ;~aI9Ow z${&7h1%fa-lpBac$IosC{;v*U`nr#_9hMtXXh%F@iGtPml1S9{gV?62>&vawAzVCok798({Om;8=EjTwlKfCdwTQlk%|TuDZm5=F7HQfdyg6h&b=mE1XfzP>{;^?Iv>qK+u^2?YCBBC|7m&Y#p6fUE%F%ch)QBuE% zHuq(r>xeA!5p%JO*B~Xa*a$=xk>v?-SXbg$j_mu`D2Xg2X&Ha`x9hj_=V&Lf{NUro zY?Ghqq&I`G_R+;)B4nuum_e9F)hK<_#0|5kxcH!V=DWFC=}7cT%{-{laYA;)v}4(s z_L>(&qP1Mn3rl-2g#uf~ zek4?LTPS`?Pl3dnUB|$MbdhzI@Q}gc_U@A@y@Gg91%)xSS4%h(V@0g<*_t!Y6>2SE$v~@V2u_^E zlk<#esaFq4PtW>`*AuRpJ;Z4FJ!4AOq@tm$5o%7%J`^Utg&P|=xjxPU@tg6XIj8gx z#y7JiX3q}tSKf7_Gk-GrL+){MPj%kJMOMnKAxbK9#mz8cXB^89KezU8xyh_jbxRZY z30xAwmK`kgQ{+@oH!3@8wh2^sib+0j?>h7cX;RxvPAcB)9K2F8*UJpjd(=s)l%$C+ zXgB+XYvNHEcXzz$FXSBWw?gt_&0m!PyD6Vu-6aD4g2NXbu*qC!FrBxQJ)pK zGJXMBxNzN*^F9zmAf|2}$~uM?uoeQ=c=jeeir+*VO%yMeb#Jvg9fdBUse44SVv0Je zw!x*_(^aI30{e_Ra1`~c?Fd1mb+NA5L_WSQ3-pC^V6yFEoXzKj5$K}@j}aIb5P=gk z0;7T=OISG@S1BnhLX8T!awaeiS%dnBP#VQgNlRI?R3Vb5J1cb1L_SOO*Pw>g7hPxP z0L7XQI>%^GVT-^E!i}n(9**~`bk}v{O@6T}euf3_J53p}Q^x7h8YYnd0pymMybCXodLIECt5Y=pZ6=k8wxjv6y|s&zUxU&h>e#BeD`yXN=P#?~(RA zX-kYi{cpK;kk*%Z2v7QGriX~ZwZS;8elKM<>oS4*4)VP&bI|L&IEGBekclZIa)KHy z6cG8Q9r>nn!VDiKJu`*T@~GelEEGl6r(G;0&k7>wSKi~3iGnHPTcs>113i7(>bVEx*m<jUV1DG9aLo=cQy6Grr$+-e3)><47wa?eb;EcR^Mcd)+TOrUl`G@$-Rbi{AQNT$K_>xu# zPvy>S?z*{&QzMWr^ymt@Lwlu3w8**id7($K2G+@pCzK%}HlhT{YK168$p1EyQK=>o zHFJpkM}A1C7OF8rf6Gu=)_6lma=Zl!W;fN;1>)ZZdx^ooFJcIn7}857fyt|JzPkbh z;d#iL^o&h1e{Xg+Fd2g@E$0sbeynCpp-7S2h|J1(-NM}bh@a5K|FMY6N~C3F{M24K z6R-CYmcaozyq(1zeA%R7kuK!n%;~4-qr!|9uIx7P@y+`nq~%{x@;`D;>~f7YnF(Rf zkEE7cHE%xo1Ua+pnSnh=A52Fue67^IIT3ot%dqD;qzO|tliMA`CneY>mSXJ*RrDxx zg~TwWS-$Y7(I|;y8;!vDfSOpT#-9NL!g-kQ!rxMBz1pe03EUc|{h>@e0LH}6WF@~* z6f(_eC4ZE0Msr2I8gCgTiB5bJsAz#$D$*UcZ|Dp&J;Wq}K%4pEi7S^MVh64-tA-z8 z)&v4P(rE;EWdyF0)EffEX;&k~(eETAqR}{QQl)X)gl?mxwHrFZ*)LQE6WgsWnSph? zRVd8}^fdx0NklM&sDHW<&}9VdX{4cJCeTU~sG*7NMtQbdCD)hDF-oppV3bT+Bt}_Z zrwNC27YlWlmOH2H7TtI_8u*NR@V?n1g+Hl;%B$OqVv|fz4NRlPgmcV{iJ?B zMeXEy*(>!w4D5Z};WlhPEfz-m`+YiEhj7FHo{rX`T&Rw_;oNDjMr)8e?bm1(#ar%- zB@d*ea7R+cm>cMOwBJ~A|GV5?yJ1UT5}0JLqmRK)ZYQ4+2uXm4FRj#|_Sq{l(?(}S zvyUjmPrHr=PMu5o@wjD#H!mLSuaZV6@P%1cE* z$} z3N{!2q6}tHS1C3?3ypcQ_%oh`{d&tc3F>g=n?_#cA@VKc&mnIdcOsCqq`h7&Gf`Nz zAnvUX_F#oYjIB~&tcddEg7lh^fjG->>k|XT&ek;@D#)d7Nl8D;BAM>Pa-ouV-<2Y_ zx{gv81%-6)pX7HbX@G#(ozWf^AsH|j2jEk(O^vy(wgfTT4mA(%a@Ne~!Cjm>52`jMG!3JV0PRX$SDMqR)(Z>|0K-({?DiSQd~96NE_X8rSj#l&;^e}(0*o^x zawY3DPj4ioFE`j+U4J8fMeSZ>G2#%He%8%cAwH>7U4K5S5qS^(2@U_FhcSKB>_gg1 zKZzOAtNrw?EWPx4j%mlN(ej^kK|AXn=0-fdc7Jg`nGF(LYz4Nx0@^e~p ze?cMTI6FGDr~>l7)s|d5%<1vow&+rloSP z&|BS$9(uIY=M1LN@}QIuhoY?NNDr#sgiCQqG!BKQ>yU$aLURsILHDvDk4^z_P}cJ6 zl>;aPdO>}NRe{sm?kk~N`SN;6JQNh??4acmBYfD~*L(6tGduM|E+#9#UZ~?a)he}P zzB$LaQQ!g7$EuCtL=IWE$`jQ(ZZ6Qs9dDzc2(1OG2JPw9$&u$@TypIc*Gx z`g_|0%Jid>YEhloLu63SpZTp>B6$5!T)#zOHH4v0#UUG(E#Z@$YL7v$dbAPd3d zKbDNyDB-(2y}*bH7|PI)+!sPk5lDdQNRSW)WzW-j)PVI%X+KW{z|}_QatM?0XujZS zvUuW`)A+;OWlC3&!%7W!?03UF&aivX`%?o}|Aza6i$x+2xR*@pisncmXL)@dV1K}U~2L9#)0KFe-oSl*PIx_}b|G%6|3m24DI z-|pf;4fx|9DIxP4=y(<+=g`qBo;M3v4Lcv`atj5rgYwZqf$d&*1lHr6%7b(cdj)Fr z3jymfH^*1Nve~e}j4SZ0q2|*C6g@ml{_a!_P{Xr8x%SPaV&8PT_Dz8K&r(H?KR~f6 z3DWUE3VMN_7|ut_(}Sv#Avxhw^sDYr$k%X6aIjUpgEShAVEl$#CA+4I54u5#0A>5Y^92p z|4}m5uM&531J7S9C8xHHQboo{_r8e@K14txkLQXtBf%ov%`u6=#2i_OiLy9s*DsrD z-?oOdcKf!Wc(KWSTN8iN+8wVQ`IBmw>>3Y*l9D#nj_??kzT%|TF%0@`hZB=YXpx`9gU_4*{ww3aINox!p0YD_|)Hjye z*P0P%+!4IsrUJ&^9a*G$sYEW}ui7Nx6G7*(jNvhscFRI)&>1u);7J$i(I{PUxx~_M za&G*oOCq8WByaTxjMiVeEkYi1&1FJa&ah)4lDc9DYuUuX5@$+w`_Q9Ci%xYHN`IEd} z>e}p_txcaz&gId7r}a(sg)T5kCR*KNq6GVaUCAPO~hr@ zAuKKqaN{)@V&|TN8X=*U&!8-mQrY_IS#5^YLu||XZ2NKRlkGm|al*Oe8B0dcAnVY9 zK7fYXUATzIO>N2a-Y+%pgC@zTiu&G{<;|9|kWRUlHR`v+>Sq5+9zCL?1=Qvok z0UAg%0_Q-EA4;J7UNk{mBs}hJ-{npDZlHw6yEf&EXhU>LrxUV(BUSn=gD9GS>URG5 zI#`}U0DS2INlX=g!+C`yucVBTZcf=~c{e#Lb7`+hE;sGTT-u#I`F@^D+tibm%%%OJ zr|eC+v_6QOY<-vK(q{DJ8=Xu0Zcn}{(x7MvE#wlKce}IXXj!^>$$9U_B06!2*h8IG z#g^Xlx3RQffv>+sd~-`%;$vee#aq_LgF3h5OPPiXC8gern?PiETfA{lFb~fm@vXO!P9HsK!yIn@9J=@*u z53gcyu8K`ggMKIbB8tiFRwO$isAzzj%Q=%Q;xQ2#&>0vqJuYVQV9;p&4MVTiK9qdh z>m{tOG{bPT?<5f3{AH6ExQ-rj4d$@M*?GvMFcPw@07vz~bmBn?}KHXykCU};; z%>1_ZJ>&b^sJ#7s-_)pa`<9gNr^Jp@>l>7)-4`{&uL_O)l3ImsZt!I~%-VxeE>5-dSTU4carjjTlSAXJ?jO z1BiQf3pAg5)v9*q1aA*K4;})~Q5v31hm~1N49VP;qp9G#8QS_W*<4&X@BKxD%xgkA zPkmu%H_65$a5vEbs2Y+-pN|k!$B3?WgS9jHv+Qr;&)$hnFCe!Zm@Hq$;D(44+fbVFCErB)^1F0i&b)={gn zwKcA%W|^L)5i0LA%H5cku!>6irbKb`z583YjZFFa8_`vCm~99n1IFcU_j5SNNDM6|z*N64i3Z5?3k>t+t8t))I{vEX9~YgW5|xLT<}hyqPXK4Pnzn zd5I#@Aa|8!$|@ACr&1ih)aB8O|6~M~`o%mvqxFr{Pn+dkfd6};X=F3NlWELClAke3 zMlR;Ljpt{0-okSm&pUbE!gDvza!+V>x*+j1K`sG}{h|}jkX8#Vdkh0Gf$g%bJ828! z;5WY*hFPt>#prW!ZlB-<>pGJj8HV#!hO&sij@A$O1u5JG=z@EfbJtpSt1NapFAS5d zXsjWpN~bpD@Hu2Ze4QF_0S!5G9w_vrCsQ7~pP1S8k(61GDc$x7YPntXCN_&`8{f;6 zc9X&?)9>&oP~Tb9H!5G>nti&yKSMfB^*n9iy!8Qye_tDZ>r~N>Acaz;bpnDe zV^T&9n2q3YF8vK_wF9nt4A9kf$KokQXn(5oyJW_Lxv$JVwk4@)khdo zRG-o>c{^{7Fl^6SlW?@LwCHB?=GijXek4xSX^vwF2 zY_723S7$u#f2uW~UFr{b;=_PKs`qIq{2GelUQqPp&)R3Q82nV3g-ZpoCO!znTETo! ztt~WRhA?L2l>IL*;N1(-VN-n+QTv?ucadvsU4&vqfSfsgFlMvQIps40t2&MC0bl)E zYbyj}V{J5|*4qCmeA3bS0Kd8_RHcHB)1h3R_Rd&x_n)OW z`sF6)vkPe5PEMy5V@rS6uu1Wd{4~hVbXKC8(Rn8< zM6k&$<#AqrTqJ4&e^5#Q5>souGgV;KMn)n6rmDu}M8p11gmO1J=a4~sfG)ZyD`*$u zZA2DByfQ300!=jcs5&54nRJc#2j{A*YfUo zKZ%*rw|9$sVs&~C?t-lUwz8@%g5T6G2(#J1#xJPeu+8E2g@lcoL&A1+sF~d7PZY5O zva5vKzzZ_4%k+?jJ5}j2sz>m=fjDGsd*CvA!GZ;QPr2vk!&q+fnY9vS90U+nzE+2g zx(%k<7V)lk-e$$ivay8Q;^E}2L)mgZVE!c{l*SHW_%4|sw{?Ma&4L>sx zM`G~@ofG!R$RZPDk12&FQ%F0KoTA=udbrWuuYt9HNm;<%*x+t-QXimaHOOSE-bQC& z0#^HFhNsRGVkn1b3gCqxkC&XwlSRxcpP@;=aWTR-b-@lU`q%>Tr7WSFFD?XP^zRqg zMHjOZA=tN`_<)xAyhG04V~H{P7nGQga~CQo{XdFXX!Wzi?6)PZw$y}>_E!@QE}DSa z7?y=E=M`2XiH@@D$(7=0xRW6W8_(Cxpq`!FjGfNF3{@9jZ>|gos*P}m6J&(56TPZq zt+lUFGCq+075tv9D1AP)(8rs`3P>+GcTg)=>BzfMNmX0N=yDn6s%=j406Mfix{~oS zT6~mKmd|ZVl|KKgVIDOU*8aq<57A`@raxd$>bC3m^&*Jd9@GR;Tlx&MASS(Z%NSYu zD|t#44^mrSkfxjsp9@_?b_!us)quWK>1a^Qc?UuXm|oDr)Qf~VR%4T_?L`iOj|}1h z$v=_&E**T?jX@uvGKqEx)T6m*Bsj13De|OcqZ7IRV+=+~%RJZ9aS#w*Z2PV-(I#ha zwbsUDw8W0y?)?2pMCEACCg8n05clk-5>@&~=E<;H&S6V3LSH-nkqKru)98|M%zmzv!#|Cn?|meMjy;UGC|> z=qpF+|A)E$=QZ#5Ns|7nI)AVJrxo3x>t`^*I3x(7r$RyDPG^x&v;y0-i>jO@!EOH~Rc*9K z2SW>HmpR@y3Os31bphf@<}TsK-M70$IgjKQn;|A4${&7P=DAK-BqStx>)i!foG`(8 zep(>ZNjO5DIxnZBDm?}zFw3jQ@5T2doGK(rz!tFwh=WPp@M(WnaKEEzvKZ;z!=nd( z<_?FBYbJ>O)V)1Jaz+nHJ_hn2#!kS8Pbsd6(A6Jj?#hnDi)3;sv56#?66-^~hQe9& zGeq6!AhPv#Y7*>#e$cY7o|2-sIHyuFtO$}!l@6A9UMH5gi86b9BcFKS1D$hdxOQFK zKtvWIxGQ;EZ-jT(YoEmF`Mg`)ybN0DxAKY0NlcG}<6Rhr3k<^l&aZeuKu_&DqxE`W z8#No*$mXB^yp5@GY)@tJ?n}Y{s1TxzlcKx``n#Gbo7~yAt6%Q6fS0&F#|_0~3Sn&v zotYW-ZjK6QS^F+kglm?HvSPHpF7=HIQFZHokdV5NP5Nz8IJ3oEiFV1!GjWSua^kS9 z!a4A>XSlJ{qs?5L#k=Kxqq$7rPrg-PCELq5<-*H$QK=$Y`#SsZUbiQN1d`09e)Tia z%d!n5-}hxM4T$i+7#J)UddcV(?Qm;lf9XD`OG>9J$d}w-n7Ar+;lMnUz{ld)Jpzwg zxZPalmxpBgG|(ao&4LPu`>O!>vjA+9{8<2!Z9}zxDY@Tkw7$TL)P*Iz8yo+xka7Qq zQprXaYak;J2EP5nQDXJrM4+R7Gu1F$Lld`hkOXr9oMxDivK7 z56#G29M2#fmin`E;ptS-_(y=LrcazXtmqZa53*`T`RSF$_qd_X`QO7s|D<4*<2R^z zG6aWDNTd!uah@GmglhO)Ge|I6TinF-Y@OYgxIUj-ZlZscEc?g$u)};cI!1$+fDY9cOA^@2d8FUU&Zy#pQgtZBtF$US3YB$+S%kdpoDv z4~+d`2?{zQ#Xn=m)XX|gB`f5Zx=&|35>r=06m-6gZE$+xKr*l{!KCU+j%kjlt(elZ zY3Vqc2JJtTZNhU`w4KgWJ~rxx=zHrq43!hmhGiXvgB_@=vQ@`bk!p`CV1Aj3qI#uPR3l7BM^;oXMW|vCx@zV|Mios3iG#n^>nE~rE&DG&*{>jXV zY$S1d`4nxAG9F{UoY7s7Z#UN3H(NyV)Vx zMILuZ?k9;Mc`1?`lB{;^jz|K@o_<8^4Lu@PepjNdiynm)yuPb zJhCKQ|CFndkIHJ~5Oa<8BpWR+(OS*2Ae3gbv~jOW0~laoRhh@-9N)i0Sn&3`rm|Nezdn>8>=mOsiTV zpzf>#hYNe-N8`_z$m4H;RB;GB-z7Ab-0#CeRReb2rFHvCBp4{cxPQ%g^gdb4H(D3! zRwh-7GB0X8ZRIe`R`FzwI3A>FPK{9l)ua);*efF z4bbU_Deuz3s*#66csK=YAp4;`cuUG^3V126Oh*tbH(M>L+A?0>8sk($T42{F4i=17%r;MOx}pTEx&um7WByTtmSBR+gy7OOnVH=hK~< zsLm36Yj?nA*Whr+>zhB30lK}?b_a~go+hJP*>XyTMHf$%KEageCjQ1v6jS55eBym> z;?PL#n!Ks8mbX2o#>#x&tKGaoD%g-uY#=fHl8|1i^skbtK|haF4$#b~QRQas8l&|( zO`EqfYcX}g zl&-yTufXFLK7zdgD(uJ+0Ptr4aFtURfJ5w!KT&JW-pDqFy>Vn@ocy+n42?CAaRhrK zj}q*S98RRSIeSCU5ofL3g@hNOo*Ji@$zKwz|@K zREQXyn3FSoQF=H%C&M#ce3M1yrC>*PCP zD%s1AXq~W+6B`T5!!@r6zQiKIVyjGF2CZhTl5v&JHTXc&V|9|YO2*MStdbg1#40&M zzriXg*9p4oM$2kCafns&7ROHXwn|D^XF#?7Md6`V$)`uOO8z7k2}6KAay0fx2mj+T z5ql)^f5jf@h$h#GJ#t{iBZ2^D1i+>*$000FwCkKK31dj;?H$KIj;Fn@MdcYol2wd9t|6q$O6b;0Df(lEop}*zV?VD{wG3 z0HDXY7Lf&|P>?lmX(AGI&Z8o+wnRi(9LLEjC3iVPOUKuWk)_XDLb#kqSH-15VOCw< z(5nEp8MJEV>s7E8o5EpL^vvzVuQn87R>(?3$|`aOy(`Gof!DG$UH2__rS8@p?iz)3 zG`D@Da`I|5zX`zYdGf2~%bJlrPk!NUX@}@sxu{V=yN zSh=kK%-P??Y1Dz0;{7$k2gB;eK9&W;>W9TuZDDmfa>^)y%PpG`qHsjLtcvE}HViJ2 z^d>NM6;7#COW77GAR@DYm7zP6So5 z715t86a_Pdl?_j21Z$IKS3BTE++$O0+o|$LcKuA`Zw5rqxnxC zO28sHM_R}txhON1D*Ed+DCv5UT!t1`$CQtRUf;|D%lT+5)oBHAK%#Q6XW>ZHWll_K z8+l&10G~!wgnpMe2#BvMx||$`s?!zHidLuHSi>ea{Mm`HNT9vB?=yDn$K|YUZdjtc zyHlt}c$u)~CfJ{}?K+Lki6l*j2?RM!xN-4;a1f$YJfH}%VcCz&Ep5Ufww&gu;M9DceQDFsbkY^lg%Ig+7BX4?VsQ&#afs>_*@y zNt~I7^rKUAIgXJW-yw&{?Xz-x(U_g+3htQ+Z zdLQW4H2EH+17`I{ABeNqDQ3J#llWBSSB*Y1FwAp? z2jE15&Jd?Xilk@mKuGu4@jn?mL(%IykNwIXjCgoE5Ol(n!AaQ&3 z3m%VPPZwcNf5XkuOpe~{lbEbo=L2#6!4lZFa<(mZ9OcMNEq6fyWzIs{05%9UNdKjm z#}bEL3B__50VQ*(w)>{#vl8o?y`=X^0Ns>kV7dCiuffFtg;Eo2ICKtG?T;QhJeY=JM*-}pBXX{L= z^kr^b9ru@rNCoQ=CrerwTTGjXtWNo~P`_1+P!4}g!NoelQTz#IiZA+Uo8YeMol z!JGqD^!^ge5w=w5!-s>)WV7!Z#*zYbtn5LD&fHmj3nIIE0yjtCJa@ zai?HP<|T&I@~3Y4QtJTPUqvha#E&Fsp2KDFB?LH;G?~7GNY8fTazaZlYnOv?30+(2 z3nU#$ZzEl;%fC6`7Ap8^p@KupNQtg1X)lntlH*wdBaM~Cjrn%2T;;YyYOJyF@Z_lSfllpnSgPrZCRg*<9x#(_zT`SzxOS~^=Mb&>gMn~u$IOXiQzMQWpDKP-_ntF| z>gau^v2;j5@_p&zs%+Q0j@96@oWgl8!J;oJ|Q4S?AXvSqb_~UUE7yho;$@LvpH=u@h zG%If4^9Ki_6&u=}!c3dmk~*W6WLj8jl)p?~wsNfw0zhM-3{0U>zJ|k%FAJCWByFVp zmW=deQ)4B5NgX4n?hlzYy$2D|Un{K4rJM?%YdK zjc>5j;&x4*V}o_S#^`>HfqGW47U2{mUe4D>z`L%{Lxrxp8}4E?fqhcyONI=*%7#w% zi$+spd_>!!BfS!>*v6=)iszZBx&s=~IA~JmYfQ(oS4PYz=fIZB!u=0$mbA%FiFv>s z$Kw8^^dq5PE{jjH@KYi`m&N+~d5-c^5(VJ)KvaN!+N}Lz#xY&rmCq8@5O*jC{u)d6 z#MGAp59?&Bqu!2iMMpGMe5c!vPueM<7Fk24_f+yvPGpbNZZhut28fky2jz0WH1eNb z=aG^Bqq(2L)MPcEfjx9k^$2q5%#PwmRe6uqF?>#Yg zD==2FyZ9YhH?NS0K9AAD;iR7C z6*{(+>6ZuMGe!UBNMdZOC<$7gMk+oqT2AE2ou!CtXVucH0l=68bd>+Pv2~lLoW1ZTdFzoF+ltgr)A4GL8`m_Y?_h} zCRNwhu9?LH0W??foehrtm6*;YqnI)ul+K|cSgGMj=OmCo^aE3~C1x2~viq8Zkkk`m zO-b8pqEbw_T}&l5_sIS^%e&vIrO6q%f7%l4kmI8@W^Kl}^K3{ltiU--QkSZt@)?Y! zwqDeuVgWM#YhtMp^Te}tZ1#Lvwq2pcOwSCq)a9~OH1T0f;A5+rECSK;bp-Q-D|Uyy z@9ELZj(5DC24@a#ULnp(zUkF**Hv=EKTRu)dAbx|OO_y*rh76>?YPU0@#IF+j;E`? z0L>0cms%2~x{k2AzHCIK_P>ogJJ}u4RivNw8%r(KVV{^Ot#f%N8~&Pu!Z=w9CFE7e zRv5CuQpX2w6+F0%Abl?}fD)&bA`Sb|0WxK_9zrMa={CFiWo5Z=5s!nK^$ zAsgH*H(tB%x@IAD;+W5C`0-5fp&<%HFp@@{I!o!PAV5uCxE z`W98C*Vb)4DTXdKFQJY(n1=0_Wrc+hi<&2awGp*bT3U4p({)SLJ$MYyrSxztXu4aaxA9s+_Gu- z=Y--LMM{;a`z0(`;wU4v2aM!%Te{k6RJi+@6rquve9Q{rvV+kL9Gc{{@1%wAoO zeZL?|ZKyq%I63pOxvu3Knr4&#T`+Q8cto(EdAUpYrAkRg@e!2C0jlNc3*f=#<(ja2 zQsZUK%iXa5=rxD zma5dZYD0UvxRqlmwC~R}tj@jH_}kwvuH9ga-jMRy?K}J1^D$vP*Y*wgsj7|hhM1}D z4UpuWU(T4!t>3E`PNRaG z`FoVVAM=;w?{5Ac z`W<*j*2WMN8=Y^zC(agkNzC0Ne`w~V{W*3Lhubj8TmwHI`ugYkbNw|OQW*|5>qvl1Qr7OL+DW{|(w6h-bwU*zoioYRQx$Y8>s|ZM z8C>jS`7;QA!k0$Nf6)CLPv!{X*8d*_@%w)N6G7Zfjw2Jq3|)4ka~?1W`egjmlO)ll z1h)sGg{DW7n(a`!w&z}wzH*++#+yaYxnQ~IIjUL6PbKHLRG46cO_99Ur={pbrQD0V zvxc*lB+E0oEK*#Lfv$%^(A5o?#(NDU=XPB6r$IT;G=!mvYz^a#6-(8y-Ak|O@1cWX zW9hvjTa2aiUEKl)L4=L!C$g)(0&+d&utcX`{^`JcCd1y=gxt0;-Dz zJ4zW35Qu#}u^>yD1Rykv26gig{V~(6yV^hW8cS~Ge9+I(KR)GePt5zga9hC=tuNK? zo)Hp7o&_3aTv36Uazrb7ZlS$4s@3aSs-+9=mW=aH z$~nw_v{LvB81zR_WR4H^?nEzHDhOgd5=WT(aR$x~hg`M9n$4XNmrE%KyW%dJlQPOPR&Bs{(VJz8U)g1r#n}&I2jzHV} z8#hj%FEi;YF9^)e0nT!Ws)5QaBuz2U&y$ONR8MeWwc}eM`o#9){j)NesyD?pY^J1y zTZ$|cWpd8ch0T9DRwIGWfKqQn-53m4{7w)Xu6=)If3x}aG7|rrZ`rE1O(Hz1KFhFU z`T$&S%pXH8Jqye`kdj$oedaCvF`U7%gX*KK$jg3SoJUh$mw|~*X^VM_N(I6k=Zb^y zA@a(3PL--IgcM_EBx0yvxH@?^wZ{i&3BJ);+ONRVH8cB==IoWOsq8I^PZhb>U*ty7 z@npD&XRrJGYBA3vdG6yrm-grRT%P;7&!-II`6QkT-Df#-v1<^|CGK;=;F+&-c)Kh1 z$uZ#@os;p#r_Vx))5l=q!l;_XR8thWk^T@AIpr_TjL${M{VNM(9D{S+?2beB9y-(6 zk;a&#^v~0zzjs#9zEAG5RKSqUK1vUnYrr%1U&fg|GO$;6eOX*_DNfzj#F@?@SY@E_ z1<{vVXj;9B;tf%6bf&D6Gs`PDmG}FiA>Vohdtp10qAiM{z!#A&Zjx+se=76(#tw#! zWd5y7{x_j$>@#$@P%`7}-$hO9XhX`C9tfJ0>WUN;N|CC);vah9WorSEXlXOqslPwrKB1Fx>)m8MN0 zMopHQBDos{Z9@*vKEh5G7#u3LDhjc3ueo3Q^EbI%gO zjVx-OhywaM6q@I_*5c3{gs3{5KRvmL{7!ygVXK#pf!Jgj7eg2s&i6TG>}FK8Rcm14 zCsfZ9doXd#R9hzy|KMua^IQ#EmQt)K1=!CruwqB+SZ=Ooc-`kp;SZii$W{DYK^Q@{ zvf474iMi`+SuZn>tWn|0n6iS0TT6+cW+4b;Wub zv=o+B$52NW?(O}+>AKAJ1XeemJ3Ew^3A`Vfml;o7#DO%Fb7{>7Sv~;3-;Vd6a0ocZUme~6rTzs z0{8RO_%GeSlGz8k{7h|XuMz$z`K5%K+_t}~Px8xv5#F!HN{|UBHn~wGM3=a6ATV(* zs)R-J2Xsscwk&JVVW|RhuvxVYqx}-uMB5Wxa@D^RU6P9`$wis`A4He5=tVwf z^d%Bt;vl&sV)VkJ-2jsxEG67i=4VcmM|tog_hs`*s<^OyzZaSkdA`ZHmm{e_K@889 za;qa6gw{N5jlQo$CX znAg6}AGU9W9%mLi25rUcDNw5mPA;;9Rmu=yC00IWujjL*#Ok$AKCZ{i4sqNzgj&fm z0w1$xfy(*O0D4Fq<}Dn+31wGuFxG12t?d>fX)wljiym6ecMCZ{G&W^jY|4&s^~J-C z7Bmvh99Yj{xzD&;4Ae2H5d_gAoGSK?NuBWsP7zOi$~s_G?2fjlIj3l%FPdqOrDplY zrG_AYC@t~zEX4&`P&u0QikP2O5@dVhNLezGpGFB(sS9#b%p#P$D&!4+*%whS>z0kh zEIR38vW&t?R_?9kUEBMuxEwg*F}Vug0_CG}Hp;wuKFyh$%*c*Q4cE}eD*iDhHRR{@ z74TzSa7?OrnAB0wt95E{+tAA@Z=_{$z?itrRPW>8y{8nkBo7AMCEA#p8BC4KSX1ct z*r3+YwGUHAMUP9J@3xpKo1gNPSW`O3r_T6JH08U;s@*rcUp=1Wq$sM<+WqqMmXZ7~ zp47Ti@X0sd))#L?XLqKpq8o4@VM)RhoAS?bsp3b1+{#dNGv~!BGFAl+^YMXL#b(Au z*53mr3s}B^$+axl28t`kq==WPc2NQ4U98H8NVU3dC8Of__VKz3R*n zQGLaR91$^49Njh12mG3lDt6Q3pJr)kd}_!~@Q}F_6bSo;XjmQ1kr1!&dKEMDjT`u5 zRjdSc*{kU$;1fd7nO(w>dW2+pz38DCO)d}8gWE$m{u_@*CQ@*FaM{k@)oSuA;KA0%!m?x@hDSvp$|BPyy{FDAHfycP#VV+_s z`x7ovwTmyO$>(Cr1sr14{$WhasQLSNXO!O5KYAkJ2_X?aq^~%ly z4mkocKKy2D;5mEY4o+SrDJ|-}eEg0@h+mg=Y7kgz;Ti^%U=EF@Dp9LW$)LQ{8!N+M zRt4MUgroQ){X`5EdtQ0}G~JkKm)sKT&`nT-r+K9yf|Eb8Xh`($nBNQU5v*c;SixrJ zDsC~9vTLi33Qv_m!E=bIZ_W zr);U8vP!5ZBz?4umJmXTkA`d3S_*oiB8d^hvDALUipa11iaMb7#b!9Ko4I)l875AvC*dOocElt!Of%Q{?y^StT`VjMhXre+uL zeM?e#+RnFJ_M%zyG**TGhWjMKSNs@gsd*$-H}hNKYwlIIpWR#q z`YF!RPg^|;zd_evNcmdn2^uxa|CTELFiK20_YGo091~SK?nO(+4k4q5gp3|KjC5kD zi#bFF@-ZT>2gTiv3NSm3*a9R~s&n$+$xk(S3Tv@9Qekpk)WCKJ|Sn zt}Ea>kc{^Z8M8bVWUNqY+`9StUu>7Io3pEtZ4$r~2p7oQ;a2~Ut{%Y0xJ2XvOr;v& zLup+%0ZPZ_;my`bm0nh24u#kqE0>(UFXXgCsNNl#uOX*)$O$zc19v_Il_ewzQT+-b zb@h+tMysKRs5*^QT!u}{0L~cDl!ce3SU#c3d3dUCZZbS<-2RUV>v6GQ+h~)CY#$f1 zVimFIa@X2+JKrfnuxrtrw&hF}GVSD5*e;h_neD=Mb#@YcxNJMmV(?Bk%9-Y{dYehe zZCS}}AJFrwYww8K8&vaTija>}e2$^RtYF+LOM=X2eeB=K3|RA|%wO?-q3S0^ly?oz z-XyRCH##>q$;=g>dQi#BOwygS>T;7-UBk@bxk;-|CM_swY^Af$E2|6ce3e{8bGi9S z2{24nNoiT;D*Sa!p+I#Hek(?Fv>e9HS?V=QD$%DCLkRH#E!qynUo3VgU;LRe-lx_k z_xo=zW)pO(=}fi`g_SIS)bCe5nnq@6H^2d7_?Pi@+oMxUH8VZy8P-r{$H zx9zA-)y_0=N>x?Wo_TNaTg4fpN41C5_IAf-&U?o&jLa$g7-suBzVK1V^^JTfyx?|I ztc2>AdS17W-!m5vYO1YU-w#)87?tu3icV>Z)C|8XVvOcH=c6}7)D|gw$6rM`st#4( zbetSYFuxkeqEj}6)sO{D`F^Ew5}mS*X}6@deeSidd|1(L>z=si;#7dH$#~aV*WX?j zQvu;%@lI3D!-rTdzGUfGEo_vBS3XVujZ7sVm7QDO_N+Slf8c71%J zDA`ZSXt-bD214xZLlK{YY^!bq&^DQ`ydSo8D*`$3hy9^%4L@OIT`y{Xx#)WngcL=m zv&32OhN;^~4DHd;h~1Rd^axK{?Gmk4zC=ydV=AkEAx*aPq*qqzS)s_O3zN&W{$;6y z@gf|4T?Ric?f$Pxns%=|X#Bf$8!GtUrQ6$^#UBBt0M12sR*8zCL`Ad`RY910UWd{Q z;9~5S5I$78Apcy1bfMM~_p;Hc#_y|jrCWwKFV87hZa-15v`<#XOJhth2V3M1In?^K z?3NPd$2(@Kbk^>jA#Ti0Ojt}`Ll#Q;)V1a)LJhHh9WmEJ#(1uAG^!( z#inLV?|7|OI&rJO07LCfxiS_XGaG4Ir99ye zrXBXZ;WM`-_oH7XSfJP;ZuQ4X-F|c`R{sk0MPz}sJ23~!hI!G#P|XIh*ZmZez|C{~ zi|)0Ad>ZOWLQEyF${i-K*r(k%`2CX*7T3m$T$va-T*U9y?m2w=_g03Ux9f2lDYq=d zg2r>bJu|2GR^B5fNVFTrUOWgLdvlY7&-{R}r&)q$e|O+e3kb>Exo`17G%QrD7aXNl z#OR=Lw<{w+1U}`zOPSyy&{HQjeKI1oJxa0xIvqT z!im#P+yLL+NxgwD|~`y6!5F&yim=5A!~vdwLS{f zS}C;F5RulZ(h99*CPu<#;RyoN$}?2n94g-)@@~50r#{aci+lAakXr|YsWW+7ha+yC z%Y*R55;wPTFjwvEcQWtI8ia({X6$e8bIPHds@f|@bE4fjs9tMsOD^W@UOX-8oCUFj znwCEXk`$-zv@DL=Phz&lq5`i|&C4G6eVY|f?G6)zd`}2_<&)kInFoWIpENt*ngB)I zNaOj~^F<5f_^8D{dggRa_K^V)h?~bL=L63n zk({w6eZ03so%hSJ&fR&xKQ<@R?|n^+9V7+7P#N(LI=B%{R`(WcE{rzYst%|4tW_uY zH5-t68YcW(-xPOs<-pV?BPBeWmDpj^st@Tgj`Wl% zM9RXU6gs64DYF?os%no+mO`Tvdz^!s=~AKAqWYN~%^T2pax||_b#qLPKRWDXn&%J( zS8K(1WF@`v72kQTfEIX~rG4rCCUi$ab$L_3+q$wtPt~K$0L8UII=*TY09&P$t5AcWd1W=cVIuxD8bsWH~5w8vSp$b{j1yEcZH#R5f=#K2$H|TrJ}MZ22$o z6$M6XHNPgKZ%V+atrh|L@5i|r3GLXdm-f<`Tx28$3QD#pd~o0`IISru)XlssGqEkH z#%`yhMaFdgpoH1VmD5`CGK7=3pbTm?%!nYF2*Q$iUlZshpr+kes;rJsXMB{P_D#7tOi+LrwP z*(%ENdqWw^e-$X7FH#8(WvkJYuILKZC$GY2P@p`-+^7yVIcu3UIM1UqDhBALKcmxu z*N#aa2g{pE#|*kGqEQNphTm5=I%sC z`evXOwtY3&&D8+$gcZd>^BL<>5T-7ndFk7dx+gv(mgfqTw{Rg?&4pl-uFZ&J+SdBz#qmgPfB2CVK_cLwP zm+E2++!m~YYor<;h6+TlNQ@gS><I<|D!^OFIy|?sv9i3mnqFPO!nEe;mLt zSpK;=e%oUhzJG9!eF zaCH8CXp6i=Uj)2@^-b{Bm&7ImQvJWywTreWRttFQP9mP<|7HHS^8YUXpYosLU&EM_ zw)z23hgmV_Euq*LUD024?Jtf<`v6dBtw!#dlUj_(AviSR_xmE#*=EFMWQAg(FQMay zWk1qXqlX`xhvM7vYlsuUEsudHs&Kvvy9}E(E;94%LGa5URLLOp)32cM z#f(R(>O9?6ji%4mXt=DdGHNuO*xrsZWb}_jj0B&awffY&{3)wHa{E^O5z~lP3sirq zq(3N}#)XJwjW@q`2j1&=oYX?XwY>VMnOy#3$sUUNzhv5{EMC*sUZyPFUTbzF!Y7kb zYPGlj#L!-u3H7;e4(#?0>iiy!T`~Ua8)_|&$I=ZAaL}e2LUPhr`VIaE@i1`%t>>J4 z2Y@A{#DlCtVH(bkIZLI-q1eS=s`mS0GKmc|$A6DG|DLM)jEv$JV|QkRGcqnnaVFoQ zB@T_N+M9_qO;vqrrP^M;*kgCH7CF9Y5BI6&(C@iCYphBrC%ev&ma|6hZ zugYVM2fQuZn&v_Bnu8|zgRH_q!I*QJOxHg;6w)MSf$_|eQeQMfK$gL$CP!ufo+2G^ ziv17jkqr5hWG%a{ESpK@$ z?p}Qol`wvT7akr0-$R(JOU$ld`4g%xZsLEWO6n|zH9FyYP_vLy3n;kgWkrT!)401Q zvjVZpT;L1SV`CIrI5Vx#ClDgtUToKNK?im@g)R)&S#VuBuBsAh)mHUiwFk#l?NO^X zA**(=m;;&C^Ur3Ul?4S^z=a~D|ARHpLR)=W?mu1i05}6Mb{l}aNv{7r9I65Dq2)Q9 z^U*L{F-K?-sG{r&n9dZF;9U353=JNFA`L9!L(A*@-goXe9raGbJgj@5Z;BI2$96+| zIWE2gw{mLlq8yxeZt1GY_9{CsAs?*h3&&)`7-zA}+w6 zW<>UM8D=6`{g7B!nU6Hb9g;fqrQlieW28iJ1>B@xt#7MDx%-ZI(j4^~*mC zntv1!5-Q&mjD}p$VpdEFns>~Zl$sWvdQL{=DFHJNFWQX(E<@-^uKc|SBZq)sO-MN` z$5IWbvB_{?F-(n-R`a0~upx>%)o&4+)IwiZ44o9GxWbHzfkL|FMwwXtsSa?hmLZ0t zHL05%9Q!i?3O;k86TMk&HM07AdtdQZXXok;jr+#INP8yDjQX+9_OVtoi|Ml_?b;qG z$|CRv9WTh7De~(h1QgL#QS5`UXM`GQlUxIkTnFevb9KqDMRdIYFF`O2e)RVfT{m~4 zDfJIB3vOrTd}d{#&s6Oa0)lX^1KP{;W=upB%@YuR=okag+mhoI&D9rGDQ`QikLdcm z%zx+LfCYy)d4RS&P^_CcJY${XdIAj(G$A-4Pu{g#qn%wZLBsKlT1qi^&Z!U}pMh73zOb4OtdW-Ek@g2ByG_R*RbA zMg$yNAROlzi~Th%%VzqxdKSSWltYb!b93O@Z8A$DIX2O@<>R=|+P{b&k`OsT9|Ben zzawV1wd(KEW@#()<7mYPS9|8RL(%y%`_fX@Aom6@ja^mBKm_o8rPJ0`o00$Qkd>sZ z_Vr&+Vva=CQzLwOy5Y#dvzA?)T1>P5?=Pk<|3A8zR&@M7v6ybf^wu{lrhD0%eT!+n znxyn{`rixIFo3-| z`SBiWC9bf*+Fe3A=m*wv*wi9f;bNReFpVzY+DtR=psYb7>eK?MrjYlbw(7q@HDngC zX&y8eLaPJ63QZJ{cSiw~l<53IIOy8y)r`7NBn)fR1c8_O7pY0IOlF3FVt%S=f%F0$ z0hEObF-*^#6*6bSUz%w;b79CA0U7f-elZ|6V+4rMFk>;ahFUplb#o=wWx8d`%>yBG zeDK;sGQU8j&+U^-cT9FK_D!kGt^A?c#45cI?I2lC_mJBtZ}gxr;9rtnZ-H|3hfq3h z7VY)|4g+o`F%q)!HisM=lTWaf1(?3AqWnwrRAXu@#)FqPcK!f^w*N+fKaCdzD>&&hng8#pdCI}{^H1s`UZ;1s2tkI3kLa(Y$!&YU&vz1 zbc>8j2^@uEPkU`7*eX_VAPe$v1+Ps`<&?urWoFRvJJHJ!Ah(D*9+)hrpNR2JsVO3; ztzN`h7qVetAojov0WHuD3xsCK_+D+%cuU3J)Idse1{O2vwOz7|wP#-pT_Po$?XV2NKK}VnvKg=CbKX5pa8W;KKsJScE)I}(aybysh z=W5hY2;@6ghrCT%>>P4n6+GZ!u!?!^|}xeYtGLpN!`20l)MR;jHQ%SkThU6^U%7Kbcxk7PKB3~+d- zbb^f!8%aAikzOTSEeRn|AjvEVb0wkU^-hP+(RO??B`kWPL`E#zOFQIJRV&5Wf~rc8 zOcYzhNRC=t^!pC4oEy~sH3fa%mM*A-A-fB=u=&or*i~d*j+qr^Pc1OeTI{gw z5I{)zCeN10LD$W<$z^nysWonAMiD=;g_>I;EnPx+ZvY~eHyg2Oxll*$>PMf0JlAf- zii?q77M{3BE|(#;Y^>#tZ%<(yNz3OU-Z9mOIKfscwiPh2{4Xq^P zGS#tEmg`1L&yqGF!6p?Oo^4noVyWz7snmm--b-mc)K9HaPf~0ZRdz~YW3Bs;P(;;| z9*n@(z*uooI7lWb0Zx8VDis3E-)=eN)(r>!X=$MrAh~fl=94p!`r`b-!7rPuQ#xCa-Dd!bC4KH>% ztx}E^ZI{z(r{RlTjum5tq)3wJKlH)vC& z17U{sb5b=eD?1PDZri61+U99PxIo!@6Jg?CK$Q-9cP@{0Ja4t`Q<3u(m%bT#+k1Md z0Vso1HF{P)PpdQwOUQbpKFbhM5^Ol0sypiY+665o-dU`z&q6jymCyq~pk=-@;<{rK zO&eqFf4vRxbV;UvP%{l=H&2rW?mMuXo40>Z0wx56^|SpLUEkKB?!ypt;D{agEADGx zjiuXfgAT*HWjU$?h!^Oo4T17T&`G`5VmZyZWZd=WW+kEm8|5PkctHSrw_` zIR>7`QFW2q%N&__t!5<2_yW3##8X;y7aDOIf$5c`s(wmevC#}9uBgbu?UbIyLfcxgvi07rDLCGqrr>Ko<)8=yeF?N zPbxZp6CTDpPkVkeFOh?bZXRaV%SY7|Jq#PeUvIX0-{7dn-#8u*Mv_~bkn3O?7? zC;*OJI4ZKC*qCtHrBBtf7U_^IxPCdcaaJ(wZ&%W<{)BZ3~qFtXiLa)6@hF&$(+jB?x z-&gawUsv<+zoSZj(Qjl>z@c=_w}Dk$J3#E8Q=}R*xl+BSuyf=FQ7~fdgkry$Mh>}Z ztYaQR=3Dmu3jZvgQE@9dXJo3ilcO9_bpBNJq90&^BXZmT3TP=gwijo#MiPe@z0)YX znreVJ-vD1av!4fZ&d_Uz0zB-db8j#cj<|Q1w(2U7F{bq(b1uL#P^lV2VxHK!sUIpAA&I&{p*y#P&wrFp^BA5dt`yIS=_ zyjwGc4Z~Id6ksY69}sX1IcAag&5fN?jssJ`s7T@{-5jxa%{RlRx=WF}&<`ZV`q4PY zCUd7}8`hGbZp?ACLMSN6XzSrdEFxTDQ4>6;`oWCFVo@kx%u71C+u)OkVGtI)7sXU< z)nJ98qVgmICToCajXK$ymqMc(7Lx4|aP-RSHexp}c8RPEl`540d+HQOWtu&DvQ7ipasyQ=Z7vIM4-Q<$=pc1Z|&<-d&_m}d` zuPqQn=IlqUm(q5r=M}ARucUpCv}I$I8A%D3Zl!&Pw8EV{5Zc4KCpDa-sw*2@qMi#5 zYlR>p3m5^hEn0R#k%}$_^;_^Z|DS1vTba|+&4h)=i3CsKCW%0GE}QfBkLY|E^n9Juu8_eb8AGsamn3OagqJkV0|t2ziS4uKfs%dbaQtw_Mc+bAYdkgBG;dQT#V=d8^(xi z%ninVzh*2StC}WWC~3Nm#YfOAU}bZAc~yIMA&)p47X94UQPGtvb%6sX3LgoogpmnJ zh*L_G#W@uV#Ms0cq}D(}iy zHidAW?zndd0Hy^~pq`Y7rOsh_oSR}H2V*x33B*>pPokD!)N=d~idDM@@-7Nr#YWYq zyVO{UnLau{QBVcQixxc8)@O>$njE>v`QV39nDkdwVflg;tBcuk=^1&urIR?o7=!LUW;+woxm5g&W&wt!$rG z_MTR@Nh@p6O809E5?bTOqqTh2KpeC8-{q!e>HNNw+8l_)5v}jQ5X(yBZPwrMWx#v~ z_=W!T4u%*fX`_6YDv4!(x@Jg5^7kMGF=sdJ{2#7i)s{j(GAX6!9F1kk40lz<&2xrpX!6Eb``rq2nGqwJwJ07C~z1yGRs&GxIyryE1vIgXf zl?@Vuo9|%!NPG4&DalDmsAB|Uj~%2eQ2n5zUDlJ3+uT`jtm#0|jb`E1ZgkP)>^cB+ ze=<=!|Cxsm98@2%QdnO*|9_#FsxRs2!z%jee$jqUYwi4}ZhJgX-tfFqyM`ZX`s;!* z|5H#*IORgT&yQOSgg>yU8JM385uvtHWs6+*Y?YTva2oJle+!>yk7V8Oylhn6AAbM) z-xIoWw7z|hzJ0I0{XHF1B&h>?w(W~e%k-nl$!Pd9O6f~6r!b~|J3GHyTy*Q03inZe z+fo0HqyC*o{jY`nuV;n*yZGPj2>ajQ|4shil9N`X_*j6h;j`Wtk|E$mImVzhC$o+d zK2Kb)if7pux#yQL0d@Q%N5U8eTg^>APkrKGR$Gst1;SQySk|_yBfAu8P}b^4aJET0 zr<<=hnk#M!G9YRA!hC=yZv`z80?xRMf1>iCEhHePr&Qco~rqj{v{cQOo zkZ`+1qD8x1NVt}*l&?`3Q|n*kE7?BkKFuN2e>+6>7efJEG!R=?=FD7_3Q;#kHrb7t zXtO6|Vj*Hrj^uPr+N|_pD8*s_&SErVzaTA;5vJa3J)KNKP07zK-{^@h?8}m9$!`tELHtW z2vI_zbqdHIAv$W>%hfX%T`Sw{Px)(k8nFrfFkY1n2gbQL_YmEw7Q+bo%LTOG=Q(QQ z-vEE^r6X^0NCbh1G6esyY9O6ax6noH3`1fYn191oD_FH5} zh!uq^;)<9#{KoHs8Yd18P+A;zQCbL-13yI90h}5=AgyeN+CHTqa%H@hzQ*(ZpGyM> zi0%oGwnWdkNc&M`3`t?)P$N4>C6eQGa|>eOg$;<6>kdI|tAFky=cE?d9Rt`W+5^an zH9FN$v?LBY1D-Fnnr1~eV9tfjeuf&(-uuuA$H(vaK&$x9kH1?US138skT66={Vv)}s(eYD4$BaL=NRG&QVp(nb#OM7`EhTOC(f+HcuRZ^F z))R-dxtXxE>n(Bo4=9P^)B6S&+ZxT@*Ij zuno7x%I|4bL(K#*4GvK0-YEcSdq6o~n2t?|##}NXBbkY>;$;Q>_QMIsTbEhNlIx}C zLwlrG6!<+~9yi8Msd$Z4Y6;;so%CYfY62q`cx$GCG;C;Y+DU1(%*xBM>UOEt|VmCrWXf{f_NmPP2ND^ruC|6+`*Dj1LXg zhms@mL5d#US9Ha-#}!M?f{Ig5P%bJfQmpGM#o{4CE*Z;CS#!eqV&%Fz{-|c-QFoYr z=v-8C717^zsn<(mllyDce%UC@MOmI)Sk;}*b(7n=ud@GLw~des9#>AetS&fAfa|Ca zamSmt$+eX`sk~i0k<~W1oGAKNx}A8gSzO0nlaFOnDd*e)R{BM?N^rX@dzAGKlZMoj z-P~K>BXQaA)1(kCo9{~2@jmUcv;VY%`-N8cH;LURw!d={K%b)}mz9LuLz0%rEQqk}S$--ON8*8KNF65ok29nd@Qf{JUo25ZSTG^=M8Yj0^HR^J=FMTK&8^KeUTIy&oz*2e453TWO0GK zfBy)~(@B_k^S>@?SM3rT^FJx7SGx!YV;B3x%vCF4P#N)_(5#}*6gsRpQHb+uG&Lds z1G-^rvtb|6)}st~SPZr*WuU3?A%RwDjY@b9^w~A|#_fO=^No0q+TmKC>QLqZF1Qz?P061B;)L2h(}u4 zms%O_C*8EOtV=d+=~3_w-_KtZ5qPaJ#dZ9AxrgJHDtCEJC|2UupUY=eg{U>?Y2kW} z#Ua7CCXWhukac+_;GyrXV75s#Lro+s+cG4eVID8YWL{nKoJUZEz@5!L`7$ii-iEui z!dDqJreguXgzcO^W)x6aZ6M<)&*Evl8bGiO?F z>z1)ACF1Om74g(HcEq{+H>va(nUwDr9OPB;r~E8Ph}5nh!4q^{?i6E}(}eE1fxyjQ z0RFT8lec+WV5;=;1ei<`-Jy`yeH+h&pw#*7)Xpt+0(2 z&Vy7X$CbLlXpP;!X9}3Q1z*Sp;ILtDm1W;db9ingVnMS7d9!~=96+=~;@H@w9lUTx zEZFRa9F(F=S+XC<+_H1aa7j>jh_5{oA%|S)Yg!?|dci@mZUZROmEl{rSm)0>l4y%G zfM=WhKu%q-kCg4ahS{0+dgK!0`Y#N~67q@8(0et+a*($0LPMHTOw zBZtLX(pnAzN>)djIt$U$7l1)lV16;lSfaeX4t(VBDtk*T;<~9UA(d^Bk^vp1tnk+* znUH16c1rB!;-ks6NDhcri99Oj9MAXUM^3y2TkYQMkeCLk&XCl5?JDI!lXmAOuQ-5k zRBTRCsxC~1c$4+_W%G~>MMrbXHUYK0r_I_VEFe~grQ<>130t+k@NtEP67#4cdlJA( zBuk&bDz!}rSms_tW4enkQi|O0xTwn}unAPf#}k7&*-HOrpKP!=LGu<3K`)QzH5j|! z7cz^KU^586Tz!i|SOClgtF-SWZXaDaQeJ#jPI((#IY_8^0fge;>O55uam=j; zK7wZByu{OtMZoCt>f%%rPRs5U`^4UNmj4Es8)g1U+;9{thQGi1VU*YAjpuR}qycfvPEQC?hN+ma zv=l+Toe%+_a-siik+`mL3HS;^V+71Sat&ba#I!~MdBv9n%eMz(56jp?zeeIkk4^g$ zEd{irE<))#gyB_)&4~HqbY6)P9)CY|-`>lU~SU4cgc+dTithJhZ-_CJZ`E@1O_;BCKC}k#*QH}PL#_lgv#Yyb zGijxI&!5wUR%34`qzC90(RMOJx>jA`tE+z(iB|9Vb0k#(p9_xrtlsnI6tE174exGk z)lIB)kwZdAOMJ{COi~akhitVeQ4&kWTTbcEqKZk3UO!z*|?L~AL8PPi?gCRr$+{{&5de_QV zn~_gO%m4||z0H=fvFU-30*|Ev76?}-%oqhstRp?4ZqqV$Y=vdmWMmzO%pS%Ej=Qs{ z8ZP#9S#sSQb1Q};=K-Su9*4Or`8FQ5It0qG56`RVuKW%RClX=}c&87Nm~L)t!%gHsq2BT= zaTnj9ID|7>+GRiDI7xj_TwC9&dm8|ynr}-_DJpLN zGXw2F^B}Wi2s>U|U+mzpaK|To94eokJC%vK5ZB_w&&h=Nv(ax}mM6S$r_hERaKB)K z>8XtZ8B4M(9vDhk0Y(eTB17n-;5iI$cRi%xZ59nf2H77gJIQdo?vGxXOE3N2H&!4| z^nT~}g;D>a%#Yr7gmLzr(GJ0(?R`svXoDp|^rK!0qW%6s?Sa_Eh(~OeLiO0f99Z+C zrC==JAV4LO0N(l)m^ekUr{g!2O9g8F+aLgoxY8L(B}XN~iq(8Z>fi&Z%r|JGn!le) zUHesbCh=o^P_pw!R{Iy`B8fPXs-zyNM0Mc8<2pbM^g&m3j8^#LH}^)!W^McR=L-b* z#4eaU9GI;nA9~xzKs(GW?s(z@C$oc;78?Y+dLlX&azI#$#Pc{dq~oexwglO6!YU%> zfq@*+SNkUU4(-``%F1MIERN!Q&#KH4Q;Wn;qPpX&`5p_UpPA=Oh zce{4?IIIOp`BX=L(pBW1pbGEtRiNwFpI-P)_0?W_vi>~4TUFIvk||?nHsgP*%^p4^ z+-O1X%CQHp=-4V{)gXQ+GH$0X{zmybIr1mPYg*`Mp1FH*)AamPGN7PBIKA|TT>L$| zsLZ&o;Z(zcy2AkJf5<$QHu=pf@tQ1cVt_-Add^WbnGGw71F;#o6vR0zK&u>RJ5I#( z%$0dI_!7Y7inIuB$BE4Sjw?bxo!Iygu_`qBTtX8fdHB~w^Y_0@So zu&BOw&>ED;BEBk*T?v+4(KpL0)?TVrV@_rW{E@FzA_I|=9teA4CVjOM>CHC^VAWpg zV*F0YNrhKvS(Rl~A83pvn2F#tiiJ_Vy>evZ^iy(;Sa|I$VgEGA#ATet40V2&$o3#6 z<#Sm?d?8NYaA|jOW^SF}nT^wjoQ4tA+UamgWHkdnPdq;Z`{qX-Fp~h8N{~_=G3tB) z$E#<3wOjD$1m_6?rVf$ZW}P6n8FVxx+5ti=U(`9_9C^2@nK&PlTej>d!<7r(dd4

^hyZ{FQ7CkU7rdDJ^;Ea^7>haD_i>Q8WE#ER7qyC;M22R>u zd+F#7zaR!*TM;fXi@&8mqdSCe`_-||k+HVm;Wv)A^O*6L5s(4z8|({C+`1zS_ULbi zx3!m^^7jmeB@+C#!|*NReQM+M5g`K5!E`L1GCfbbufF!uF{=0KNb3jwj^FiDPF&~THNIp2t{RS$ zw@yRJZ(U#J#@b6yOC%AuxZnZg{M;IcbnWzU_Hm9Nly#O1|3#~r)FZsI*?Dz>sLEAW zcU+c>RnR@S$q)uIX2SZRaaS~`bjQRfj85Tma`Qz~4pDcp>$nJVwPB+2#aW7FKIGFy zIK4?w3NCh~a-Bo+xx#HIi;g1HRU}fGDBhzujBP5j4LM=lJqsR&amKfKux09v0~mF_ z2t$ke0!>Zu(^C3NaDFrN7v)zuT*u`T5{&9n8t{D1{pgpH)j05W(9;w2Bt=~!Bjouo z;Au3X)#`>IZli@BSj!jCM=rHE>b9&+^zzFQZ4S8fC{|(ccn%%5OOF;iO?^L)T+`Pf zuX(0#pgdisE)Pts`SK(%Vw&k2FM%PmBeeR`Z-R10VL%I(Z^UhNla<>1NN;1+$Ts7458EF z3+Q$@DJ+7vTqrZ^b5aeMmhfUGW~x^-EHJ2{^d*$-N5xTBUYSG$Z;5c-M7B0kt4)l9i-1QC^E40ClM z0ZHsi{`oP+z3DEAkUzdX^lv<3zmT2@7iL+pl@xd6+bb|RJx#SR+c1YnFPbo{R^bRl zPm?{YrVA?O&bf+NBlD{N@Jew@T#~Csc!-c)B0n3Ep;hNd&>Y%364l)z0l-L%3u#Y& zV2E7}E;;XKh0G1f4}M5_)`-kS0~`=&n22+rBq*p#fz@GgYd(i9hq;ypia=;G?{1~+ z_giv{$SSa}Am~Ll`)&xDj~w)U=#ABv!_wKi%#hhX2al#Di| z#CmkR{6HUYB}&o1l=Wo8tg2%iA(sTrs;3Ac`KBQA!GL#HK%22k=9`(gcb)pyfc{Ou zY)KwoNKZ3=Em>_RS`&q2lU8A~4sJ$95wAOREW#Yq9;mdLm1Wc@1z=9b6EvezIYxy8 z=tX)Hw~WWcxGox85@AGDLM3I}VAdblWjqwb_ZGS{tsG@vO=5SWDbRXtIEXzMBVl9*2q-7#)rrjS;)<2<%s>=NhP^;-&T9}qB9k$Uawi4-}y*p}wab730XIW)ZYvsh9Nq~P zMI-a9&_t;GR&(UM?AN!=eQzD2k=1`eDAcb%Jr4x1w7W_T5(|<+)oN;meHyE(m2qXU zgL|!|6l{JzBr&n4*YHT6-;6iLdKmU@eBT7k4+9AJ74tbFK92)tNWqk`hItA@l04@M z)^aRzT){?@T!pFXJfrHU828sAYk3cul_Y*a0Uh!5`8h*_gB#^@ZgkMhd0vttZr%qk zT1nA4)Ar z$+XAJeynn@qeMmy0Ju`SJBuXt$Z6F_)G!W1ut1FWPzk3|9jVi66-PnI+B11CpXV-O ze-8>|l6d@m(zKB2bjyiy6=h)VqUHjgi1Kn?4a4hk*Gfk*++{?ckyX&S zsCTx8N(t6%<*LF2x#*j#FQjhHf>Xu%l{yNNdrIxO+N$O%UHA>Xg+rR|?wut@DV2N%LxH>xwfH5Q4M$IMt%|C| zxyR<@Fe~|Ym`Hie=HQdm9Pa{LSRv@*2&fiV%DX_<-k5aTSP;sfYer6U53+iJ4Wzq1#yb7H}pzhy~uRB^P1nEGQ6e7ta zF0bgHAk4uswW5pcAu;(2s|~*Z>!pZw_k7&Be*^Rjo5ta)twbZ*=@5rD1ove_EN3-t{s< zkP@!%Vkvqf08bQit(DJ%CD+{bN z*$rS9>lX$&M*+r=eJzK-Xfc8LKAk3+y95<+Nq>rEvCLulOqAs#mFN%S1yU`gW51Es zT3UAMK75LFFt}Lnja8z%#-_hlfG#M9Ec{?JY9X}o3ViS3wa;*Mo(I;u5SFTlEfkQ0 zEZiT6e2AtZc))Q@1b+Lne|x92U9`AdIH)yZ&&eUA<>zSmvt8^ggSU)|5<*21!sBz~ zxndP}juE?e5uxOKie#iF0Djb=$({sTP6@V*0V0MIZ28ob7-nQRq;JJnHkj&&k46Ly zHPs;>jkpM_iS3t8rm^==%_pqYx{M2{_GAN)sIE-aSQJsxiq-BeCaKpRhRoVJnKkAX zVX=;+S57=yc9o!?3*^Wvrlg>JW-?#G6|aTK#D@Q?3L}h_&MvA7?efxucOjngm%IXu znEnk3nj2Le0FdNapJN#hZ`cOFR9Yi)4Gl8{dOzwepf*HQr1>J$TP((-FRPP#L$X+s zsNSsK-rJi3zJ$znrKl*dPODaa#3Rqi>~qvl1?-COqrFgbjo?^h+Fe3u277s#KgfgB{po9j8Op>$Ut()CGn%22o)Z?UamR?KEw}jsY-<#k-AuwYzL7DI{p^& z9?j3$AFWI%sCl`@6+P z5K=g7^fxeP3S`R~hH+wZ)t&P=y$#2v)E;0@T_?3R)FENXFFTLled<@pfem#@^($CU zLmmFA_+_2&`9T8?9@e7H8-;dNUhZJGVEAor&H-0}*zYGfD_tdXwku}u4uYUKc z-*)wj^)lk$Rljel-#64RE1US;>UWp=eO>)><`chD{dTC|x7BZ(`u#-xZdbqC)bBg$ zw^jXaRll#Q-!1BwpHu@pl=E{kGrr{iC;VT)e+mD$@gLxS7Q;82=Y0O}<^Kx)Yxuv4 z{~P#U%Ku9KKj42fX-%Fl@c$tHzvTZh{(r~+ll=dg|2F zvR$ssbMl7_9XM?GDW{xs>Nz8FMvfYN&OiG%CTHwv;|fmy&Kd4Ab58r0Vfm+@e)^EJ zatg!7U1PVp`Q1+=14=##6cyzSynbOI8YhlC z^Gw6LOT>^iY08*HdMY8FWcr=;T1wF2qz)UO`T~e@EyDBcU z<;B{~?fhJYmeS38TqqqOeU2LUTI~via8}H0=e6%^zW$UQpFA!e{iB4Hvo+{#zWE*; zjcAb_v>L+T@JrUBK*Hsk8>Lv{y7O1Whj@w2f>@k%24Zuaf@=UjqA=>f>t`Ymr%bY^ z;gk0AG(}FN<+(~n3cCYT2U$-~@~vAGuF$k14%ts3F}^%aDIzK*Dl1(Vafgme_l2S# z{uhm1>QN9hU0(^t&Sv$mNKDC?mIIZWp&oN8ibIS7%NvFuvOnQy zRe-%>p^)gHcOzb6ekz0~zv91{_X&iA+=lV=>Gftagp5qnf}tIm3Jgb83XuO}VCbJd zRWOtzi84E#lTs8)hp533?qCMLL zDZ)!THXEA%wPYSgpU|>|PP#bNMA9QSzbOOCD1H+3BtxDrgV8^zGN(KvJEbBJFtKEs zs<8Z7*!u&4vDd$4e;lmP6cJ=|@*xgv27W`p`zhO?(QNDx|4r7Kvgmg#95s6i$;MdK zeKL!T@DC=%?Vj5c#Y1||!|JvoI@Cs_*VZ~`xn99FMV76i`pKrha;^XY@bGcq53yn}9(sn$O?9#RIOPl%mS)E@SU$Ty$ zSr73ux0atrmN9oc9}{H(o_{FiiMaOJUB46!ukp_q*890@toIj+c(*R3q`Khe#Nt(5 zXsh^8f@$j#f!^3mB+}wdPB*)N;YEv>FW9Ry%y&bvJB4*>kSDgvUBEI|8o!`wbIa6m z5{lKX0k4`Bn>=b(Y{ID7JZHzI^6%z1OShhRA$$P}x&7X(APh^eg&C#fH+|`4kjb-Q!}HWhuU` zYl_$cVqw0E7DU+`t@O4zD7@(4PoHR|Hx+BHs|wI#Y3Jiri_j9$7ikNwEhhO6)GprC zO0Sy8my0L*F>Yh2yAr;8o4_va+N(o8X$Q5sl6e3*Eay-OQv7~0UVbW0n$ zW|zcf%Z8I0E1wp%8y6=+pL;^&6r^BEEZrorO5yA)Wpt=pv&cQ1us!JFerh7wG1IA>ImzjeuVi;Cu&HYkhZRO=OSt(mvPqJi|&c^lmJu%EAWJS zjum*^y~qkY>Rw_6?stc+0OMf=;GGbVVxCgZKe^*Pg-_k8o;b@<&nMjN>iM`k$y4a= zBZU71jl!j#kGgZ!lcP+&LzJjJR}m$;culiG)5p0*AMCR~B7#oGDjq=cjNN`jIKOBf zAiy%g+!r+Wz{6PGMtQ#2bxu7z)t%C6{+m~bvOzI&vmAR#Hg$Ti1fX1NH8mvYP7Khh zm#0(W8LYycrekZ>R}*j1vbE|`Nn^T16X9AY33~T{EF^F_w+kzVQcI4q!y}vnk@klQ z(}IZ%1l9jW2QUoLqSaKe%ET{wHcia!)2D)Cb`ql;dzH^VtVhR$)1rq#IkXyw1d-wV zYSTMd)-b@q6jcY_;FW|1J)M*8D0ZlcO*g;JN|B>~KV#idR*3Z~Wc*Vo{rmOn@+`lF z$CKo{>n)1BR#Qb5>HREvkEJ2hs`PG1*QZiMMsMepBR}|`_5h58He7({IgWKPL=$u` zTZw&iG$39HI5rsNuR&=~J_=C?#Pf6^T!yK_d`*p*xmk>aW4nArrzV~1JV~^|3Xz+0 zv+^gT8uiFV1PSV8XsheMZaYs>!MmjhZW5NP8aJ$hm~)hOE2Xw+0-q zD60EVVNWP65_{g>rrB@8O;6rUqZ|#6p4bd0dEG|2SVIdqb|gQ6Y$eyJRAc1mKrOa{ z+Elwb*GW~MEd}U95)%|UAlR9*hze}s!JrXvC*}T1{txb z&-Q-!f)6_G8lzP`gjC>&in_bn&gmjL{qhAbx`~G%l1sb_9U+t~7$9({T2en@17>NCPDnTRmU^DF#YP#HwV8CSrJrF&h>{2@=KCL5<0h(V3NB${Q|Cnb0rxMf^ zb5Vam#PTTe^q}W8X>QQ-j#0HSDWiasVA0>uP3Ngme~+0J^&gpLI`4%SYi36MPQv#^ zYkH{DbVO^8@FeDuXpLa)X33Fgjg!D%1yL6ra2Mt{5}N0pAddy^$?~|`JymnXdb(t`$pp!l=bwB2s-7BEml-f z00Kffr0pBex)QW*fJY)ZatkO;XTwLZn@g0CC!a z5;dyIQWU#WzRs~eyb8M1Y<~g4$EwW$@GTL#EywV>Pkd*WiRX2#Y`bW0mwjSkVP%NW z5tq6h+6g$+L4&n2OR!SXh{hqx&x|(vSa3G}ci8!Rq&Q3b zLGqK449uD8mC7~0M=P7hWGoz8Gz&DXv{k!u?7vCK>fmDSip`qqm*VRTeQbscY?;g7 z+jfn#Pj$!|5W3A=BF3_pB z59&L;;yVa+t2ATb*cCHr@0DZk=0SV$n|&RIq&6lpaSQ0Yn2E?SBAtfVo{D@7sdr-{ zTRsFN1konyn-2@*HQfObbtC#wL?G@`zEu}nUmFt+RfvRgdUIvjxq$DG)HWu>F&suC z<;}_sw2{3pOwmHQ?ne@Qw&P^y!#dQWMGRLk_NZGRF>7HdyyL>3vHA*2P)@?O2|sfo zK@?u`5I^ORAPWDmjNQxg83DySUnu2?(UX2hfh}`YJoi$4zHo+xCWj31ZV~cbB%a~`bZ z?iH5{g>{K;HYs<60rN|syDzplWjv&B+mEI0U~ED!e+@}1zX=_7r`Ybik@=M>0CEA8 z9V3lU!S`oYBA0x%^f5cHW$=J-exMjCRf&H*-#I?i@lq zMr0;z(w9dh{;oH5$7^qTG_!`yKB1R58exN<>jJ(bmt0j=0{RWo{Dss7T-J zb0UCqV0&b5rX_)6R#%D0Oa$lFX@IYx z3MR@4XIqK-I9gFmuO29d@t+4(#L+`^x+@U#OFKf!SwIo$0h}N^+kv!P^Uw%yLL!Gy zF(SDRt>#U(e@J8`9$3WE7ZO`h@}7E-tsX#p?HG16XFxGBEb{mfFMnxRsWWN&s>ZSP%6zoLi{WiYp2J+)gf$(7daA8T>?XvVNgQa z2yJ7?Uryb`p6nnNj#+SL{zg{TMF_6fgvU}k^&z?QfK?FX5X03c5L+$BPx3s@iD3C+ zCzkNcCNyu}r=%Riu^Yp;nYn1xrsCcn%bo+hSRlT8O7%!n4$@tE;!}sYOZU86bvVTY ztvJ~itIGt1c|qPfoi%T+7!`oYgS5pWZl8!RQ>Bb)a^6Jx5&e}+P{(&jOaCi9a`6`b z3wcI5<-2@uBF5+*}86Y2G5I`72x zVARsWLSDujzj=QHIdZj{^VGCK54eB;_Gz^0$pq5n6cR?HAou3mMVufIbJk2PUPr(&E$qvT}2Vl&r53TY7 zo_Tq*1V(`Tp`Ebl<`+XifXF&VAG!hgs6gTe?J|_s9OkWmZyeZzk1eO+Z9~fY>nd_|S@n$Rt0(9_BQ>LtZ8`{x98yC% zR3KY-P%~09SFn?jK1t*lnX`=!ff>Q;^x`E!hhC7pXCzy24@XmXgHx;iBYh8_f2~&Y zxCCy`{CBP9KU64-v6M?%_;yEyR&y628Mhp*=KoNdj9X=HN-ylF=FPaStaypxC@ZMo z?h$awXie6YHew1Xed$0><-bW&C)buh*Yvs1tt~l8oNEZgsI<2Ykv%x0-AN`6?{|aR|Cg)JQiu1a}}P@wzn! z#l3Uji_YRh(CuGL)MD%F^u^Ix^egC|(Jyi)kta*!tlqqV-jD!cEAK^eI&+y|@FekU z^?^-Xf^R;bJJg#l*c+M?oi$97Ufi#;OQ;Na9^|5 znJ%`6GrjsT4aS1q$n69{${9w-B(n7_*8dvDVikzq-B6%aPa_aM|3_NQ6bam(`D3j{ z?fcuamT5I-syJD!A~_l~0kc&-mved0?tGWht*!p1R3qxVf(yu&uag^{ul9yTqP5Uv zTp+Jn&C_JSk4+K!ITd-(k1>;7bp4n`m1rg?U_f301_hKx-mn0K$rD-U1zOEgm33ng zs27<1xG+huRv#z7Q{|tn_6LZ_F3CxGRxuQzwmK#JtF*T0dh!pk^W!&nT6p<{MH!WU zQ;u4ps(Os<4xtx2nq`Xv4>}GB;q$tSWhY)-kZj>57J#YdVgqV5;<=hc#T`2dV7_K* zuyPdR7eGCP2qtf?R`Zw&Ip%d1Oa)Lrpx!dsPNtOta8PBXV1#cat{{yp*@8&VRh8cfFL$4QbtRp0f2X3-%j1meD<>o3J%Jsb(J_d$ zk)D8+?4ruil5BeAFiAGMaNi-Kl9=$r?jreZ4gtR~A@H7g@u~azXH= zZyvU96gOZ#_jfHgGQM|bTPFu#N{`LPW<|wWF&!*D5iQ9x%*#MNo%u#|Mv)Pni}Xy6 zR7CNPF1e;$mlup)=L#U1Tyq+YmIW1bba$LjSbP4xTrILpMuf#9=vx@kq?(^d;1HYh zhXj1*C$t*TIbuMDX?MQKRI33w#TtDW=uBmt$&A$tqubW5L52!@G!0B-+|`R z&0_$x+QdY1$+y91AAp{21LzsO-~7EHUvJ2;A$CaMWvvBl1GObw)qU=nwI!%g``oi? zOW-E?+(8@6U$oeUytDfO**QeQZTl8*OrlXt$9|^cyXombaO#-pDCj>O9k+15VMfL< zBLyAT3cdFE_fA@R_S8V-`0&BGmG1DN>6PPHgYzm!0^`^&O8;tWGE+v@?CMx3fbseF z2Bx!=NS4_u%N&)3Nwu@QN>a)4T`S9=be4-Gi>|VSR2Cq&o#hcb%K>JaTJq9abjfl_ zzlL#?+F7o#vxp;IvJ6gVQ4I_A%Tmyr4_D zwRV<`Wa)0m)T&=3AY_>d5M{LL|B*LsJth|qUTp!Ri9ni44|}T9P2}Rrg7Co`DhEmA zDNK7o=g9(3crULUz9ipOI~icH6oT_?cJzaC(8R~Xo*M~oHkr89gn(OWk{Wu!`q`^6S3S!5iBBA*CJzG9>t$yci*`KrpP9LE)vKLD4ys!~++5PrO} zVd`R*4!4@hJoR;iU|OB+#9XCfm}J4zD_VV1E*??oq9X{P2QziU%57cJ(pY+W!UZSI zQqw&xQ_c1?-oVGFIn-P;m*&NG7xjK~9dM;irLRG*&8nZ?gf-zxBwyNkoc??(6J+Vn zH>;^SvHpBqeM{@lzi=8;nE7kTYFHX(U{_YzLO4+R@fV=RE(y?|9U3g(G%M!JG`v+( z$1VA&vGnS}-~4&{YgDCIOOVfY;#=D+1$ZgS`ec_c`uDPdDPQ#OlLSSM;l%p)k}zHH z*XZB(C81y`?HK+0eqUi}_m*anNz{53-VWQX!ac$g3>Q+h61#u8i{zMkvD?c|2zcVK z?pf9WJcCF6i_g!=ktk}@PAF?XFw6vUqd6oqVm~V&5dze^NEOsd_82Dos+8C?n4z?` zN1+(3EO&0P&;gbQ;?4h_nbVMsoua;Y$?`Z8_-JZMC%2=BI~0|~3S5sMs= zb}1O4+ZXif#%oqv(W#4bLH>!K8fh0*kw7W8ftEtc1{$bU*tU{*!; zK+3ss?C+NRf9$;rc$C$(|DR+A3=nuH8WgSCsA-L+wyD^j(0G|QnSmLYKoEgM(NeLg zt=5Af5j_e9CK0Buqo}>u+o|WAp4MJ|M|+M1tha<~0F?k<@X{KU>cptUOEn-R|Ic^7 z?_9!7`#b0PKj-;Be|^a8ci;EgYp=cb+H0*XGnUx_`_V!Y>JUaX+153$x%dAvO+mLJ z7$k6^v1j2SO}w@uADYYE=iHtqYtI(`@f7eokMmFdt#6LpV=P+SEPM1Qz|Hmds{({Y zro_x_UblzV;k(rvA4q=bX61XCv5AnP1a-Et^2l_n--2a zlxzltT4XJHQ^pD-zP~`EtWM(Paa3!qDyku~E|%(&7ve8^ZS$LlDCBF6c!gdCyph3; z8Ts7G+4O(fCLBLe{$1Bzbm5w-24A z|0ES3OuNlPcFYeDzvj7Uax$KN{;{T)Dd030EyYeJ*krx3_FZd!=g#-6`Q6Cs=5OQA zGt+yN@&3aklJ_5LIuDcBt3+n@kkzJ;fm%x!!u*=KT1z)`=Vw)HnQpBOlm%VPV-A{< z!s||`^BKRpLzDXc^l9#iuq(aR#YMAugfORs{#4mrulZ!Z!J9WvIw|N0q>-ieC+F>4 z|4>MY1A4JKvf~w`sIgHzS>Mmyak`kz{)RqkGLU@yG| z8k{*BOPE=@nX7`;MKaiJ__$#+?oQvy-NS^&oIc}SNC$iFz3tUH{p+Y7vi zt})ItLV=Fcb%aTHii*l4BhyZU^dgqVX9Hgd_vLy>>X7!v;iUjN^+)U>-BWv%`>05A zW>6YL8;LcI5gB;2lq%dj5g%R^o=DwG@Y$KaLaKe94x502)YB&veJdTM^ZrF{=g(vLh6})-8-pt$~B_ z=%hMfJ;>U9yTW`O3H&(ygp}q^F$iId;3J@l!IPQWN5S z(@ap;%ca~6*{)>-k1IKY(ZtlMG&n%`>w?5jxIB{E2KYrBnZy4!oGj zR+EV3`N`KCVLUa$&oF|<~T$EoDs=lt!TKc#)Dea3) zDW_8N4CnIUE;cU*J}{&8_GLIu@b))tv8C*B9{$V+e{Q%V2Y+xr_O6`kd-!v-k>Ln` zx?TJ!Q=RNyck}DA-|>MmtK%h*lzwie<6F#dgi8VmKbuB%Z}gGwUSx#3B_#|$X=Gz{ zThl;zA{}@<9oTN2%)un zVhSf}EvYASm(*gjq^2EiNy(Fi5v5M43{6;2X5FH@N%2XNxom8)|339 z(Ubqwdg7uwXFdH_dT75(2ktik-11c>iV7&SlEJP@C;mPicp#fAR-o1N2eLhsPJJ*P zSe=_qDDo)T9!sY_k`6qan@#Iy4cXSFQ@hfE&fIKTKB5R4)2ZvzfpxjrSUo^#>7Q6V zPHnksARrNF5ki(}l0cLrZK{enSYadVAKZpmIwG-;i}>k<_GzEH(C&2?+I(CWW)@n` zdP6S5m7+O98&|r|<0MrU>Stho}c|;dttvT4dM@b>ee)o3h=T+ z2nHJ_S{f|QJ5p*weQIAA4in`r$uKveO{$l^+B*qghued3>xB>O$3gNsY<0(BmD?R= z|D=|PN|$H#A!1kUo*(nQV>`otmABuQ*IE?EDbZ*+!3Cc z|03O{;%#b+WK;LmLU~5T9rW8U5*d)i9NY!aavUNET-5bC$vh zqr|aL>gH4ERr{o@|?0mlgFf!rRF`+=t`Jn>-GmN6xu&R+Xs@u zp_PwISMK7}MX00ZcI||8vT6H7GwLk<GrRSt$I6==iAN!ST#04MUyZu4YH9>IwTM0{&KS(5W4g;FoN@gR1oroxTf zNF<4xS#4WaBqtX1x%>3gajbfpk+8`FJP~KQ0wszN2XkBHjrX}U8FTv;>FPfa;BLaf zd)-iI2Gh`F1Pz{aMbH?6I75rfO&2-z{9JzI9DL^|;h1@>$Jt9*ZuXp7xwcWsCGc{?K5z?Ze z2!95T1uOH^ulElkhi9h}1ueIA=gdKp#Bg=WTH1lFS=iwf)@zHx@)tWx$ex^2hH7{Z z`rSOYVA!#i!uZ+|zQ%q1fjDg0sQ83}*5UEBg}z2V+gY+U-wNR$x@$fcCbGugq;b2{ zy~f`ka=SZr@uWj7kV7Nd*iFZCSE7ZRff7ETh~T-wLR{cBt#E1wOwX+Ld{)xTF^qoh z`rK|GjEv0HeA$6n9n;u{<2RLs@~rmnum_o!(6|C*BYz+3u9orfz6)ATj`syyj$g6| zXy>(lp0yT;uRRfd>a@YNzMcIiaWIIlE#mta^UcZNd|&HPU<15-76~yuOC#aGW`>O! zO$G_~g#HdBe2UB&s2EUXknmV%#v9INI`4XpW&n7a0udR6)qW)bcOX{Btzcs)dF^*y zfZ6T+B`(0m-ae!!z5%CpIHU82lJmzZuju=+qVMtnkcP2GBSIW&-Rbc#Ceul$_T9|X z9h~;TkhB?lUDTs+4jN>sH7}y#dhBo;xwXo7q{P~SBc}Q@soub?cIkVHm@@WJbV*C( zG@`(IiTyOF7drVh)#0YXKPu8$1d3`M3S#6J|85Qhuf|$)qa9g z`vJh^p|u4c*zpa+yvF2^Pz`xNae8P`S+XnwdEG<<|Dj;hN_7*nQ-Cz%1ELwh-o6QN zWpow$q8n+4diSa;hDO@XhW>Ni8J@v~R)*kZ=g+j4lQIJj2^{aq;7*+u<%Yj&QR?BM zuZTxP_AX66B$;y9R!UG0RY+ml^*CA=kVO2xcg9E}E>?pJcAU3ey7osG<>!4Nh9AqR z`FX#YmY;X(^!&VQF2whxwEyyl7YrXh+{Zut=XZZHe}_p#qpQZ!tZ1f>t1+wncFh4h zAiLL^@h?=Jz%v^X?^nOHpb-6BW08O~bR2Jo4$dr8^i)ZBf)U)oR=g*%PB3Giim1r& zw3QjGsmxQM_}lrC+?Y}jHq+MC?k%?KGMl!E&xulysCZU4Mg2E=0N-J88$pi-Qfa(h z?u^LWC0CyV@ZwS}_ncfV^)8>MMXCopCzo$BT0O?Y0e7w5;o+>@JAkJJKlb@&#V*7G zy8KHW(`5nukLR7lCmvsheO=M=7l7-pqVJd&!xz79UD_oFU~B%E&(q`9MSrwr_E@ua z@DeyS)m%iGPYOH6YN?ZlKx0t#Wo&a z!k^|F_|q);4o|J>acPQOK45)e-F3ro$<==pqj=A{6sy*TZ4VktUcGN_eQu3w+iG6& zy?oy%&c2`8PyM91u~Q9P?mv8PhJz}>knV6R-U-a!U=^MNz<|(#s`r?eGUxEsJwgQ^pBv4t`2y$Dk&Y2x{&#I0`Zj zTcPQ4o&`%+5&}yHkx$?eZ#7>{*3JI1kmE;NH&C<%oRf}AZ<9gMZA}LvR}QkdMR)}07vy4 z1D009mc$H>5*&Rp$7FDn;7NB8>*DBM-~w(M6s^F5a|Zo~DzrgR1)+Ge@pf|vbbZ`fWjEh@RBMs7YWhU$z8;+wl~16-@pq&lTunw#*Y|Nnw0ueBi>?+O|Cy zX-Er63f-eaUs=;ym{<_(6Dc%FKX8+*j@t;J=-Xg*v=iD`8w6qV`kv%Ze4x4Y8f+(K zV$89tgmO2P&1$kbo^yk<2|h_MqC4L2wUM7|UKkx2j#3Lmf-A+C4p#$3Sc#dOJe}4) zq5Xz`@cGZAwbwX*li*k=)-f9GJIMTnZ=_4E3_ z7#|?hRAr)r)2xnKH#qA;tE0*d&aSgM&T@;0{c&o8_QRap@_vN@F8;EL8E1T;z-m{3 zL4+}S=E`A;+2AATuA}|ccZ?|vs$5rXjJbCbA&^fNv=48EwVGxI*}gjNC4c{nmd~&k zwUi#YVE@TVkE-IVDc5B0(hJK06N>LaI6Q+&4d|tSWB_k?JP+b@`)o1*o8WA#<8(J@ z+t@a`!J1hBzzx=ht&ZUY`)=?6((wm?WU8K7u9{K68SFtLhkIdcuep)?JU4P*Q1>F{ z^7pK4@N?N=%v8c{?ZhH&4cpH4i?f7M6=Lu+?9+>n@^dztL99tGMyv%sq zF`~Qia(>&Q!Yd#^;}UgPjE$jS+oBPeX!%WOBdJp(BkE}5Og>= z8Km~$VPEp99V8wSN#r3xNJ7`kp-f-@f+sEnlcHU_3S*;sNj)nY{9HCzkqw@i4W5w= zmU}@OHr`~=SrALyF)`g{{4ZE5f}FUP&{KK<;C}{35pB*D1X6o>R6xUjimOQG3@j*( z`S2DOOFYsB@`XFzY8}P7si0+;{XjkrInL&G^Xt07v6$YlwQ?7)y1b?+HU-Ff8~;}D z?;if)k~Q2JZr{~%g5a76w{bs@-gbC7zbFxhS0q~Rc5YU5!2#f%K@OwWYsUFtMl z>Ghe|3o{{=c}x^`RJXIy(K9$8S>HXTYlx3-qak}WGsOW~SnYLzmEA&$DM-RxtR%cN zbkI8*NdjM*(4YB+apq$*Xuh5eUXcyX%LXsc2EUdK&h>)u4Jl_0icE=csZmSPLQc#a zhqrl6;LMmavj>*|EwPx{4#K@4Q@}hxShrJB&PrxpGK@$vj5YvLEqic#ggItjv|4c1 z4yM%O3q+Xm>(N>$GsjVevr{jjyyBTb?7oeUsX2NIc9#5jp5zQ0KER9aRKUko3%b*-ExwIBb(xTj>Y;?m4XvQv1!pC{PcIR=&t1L$-!gz2=A7Dc*h6a_<$T5 zTLv?}$%wAZHuSEU=PQZ)W=^C^oFZtTWEH*|ID9(|>Z{U$Z}nq49=?jSZ>6KIP6yoF zEUQI{y7wc=x&e9HIF0}U@bEQ!G>^pN-ZcVV|7SCy=LQi>~X_>(}Es=BlHp zR;T$>3{)^ z!}yrS*leu!53zM-IOs%~EmQ8@80^vBV4ov3=G)&F=Y~ie@Cd`D=yV`zWp%70M62*U zCTakO3coWUS@Hgo5QP@r;|(UL!MM9qdOR>s3APNz(-gn4rJ(gH58KZXwzJ-b80a3F zsSyR9Yh{`cG6`C2?QO#3}z5l>bbk z@$NA5OXRuqA1Glq$MNaF+3CQS`_CiicyeZ<&Pk_z$plnoKvimcy7V8&{bii!68tj3 ze;`m-#h>t3cu=>He!Qx_?X+38L{12qV?cFmRHyCiA>v%+;)~#U+2Hxv;04)WFdMYJ zApU#sA7?LlS#I)Li=@1Is@@v!?7!Szvd2UoEt$SKUonk0$9$drmG+XZ{7&7I?zv#$ z%d)LnfFBkWI_p6m8_TmRHbr-&mJH^#<>fW|q95**C~Nr`7J;dTXK$_BwIpQk9}2b) z8rasv2c}vbk5IgAQ7xG864PE44p|+~X#N+4IXOK}$TkM0A?Fo{%ohHw;T^E15c_14 z9q$`1Ms+@)GhYcM!n=M*=+d{-F1@T(-8=}`-INHw$tFbhJ^2gA^7B#Qbz>eBC#7<4 zn*Cx``0bGM_3|dTmZtph+jP-te;Y5EhULJ>hDEE#*Dik6B~s_mFRj}xWYIZ(0wZ9R zo@6>6TFCzI4uM0!2tuJ`U5$pt1T@P2u~3Lm{@0zEE%EQvz~TwppphSoEVz#Z31F%M~LiqSZrO8 zuvnheE;|XBMZUs(?L~6qgm(>gpEvlzFy4N9gKrpvS003w$ZHzxZmRCGmObr8zOC>0 zzy;Q_bwo797rjXZ4-#bSUDS)GZDDZrKEJJfJ zNY=HbPFv|=w#Q8S%#iw~l2fH|y%F969eQ1KXn;Y*lE2Xo+j_iN4tk_lfOz657Z9h@ zBh%7l1e`_pN+)3kL3hLZUK=G%{-1jJ<$Zt)w$fN~UMYOR{r2ERWgHIbx}}j7xoU8J z#J5#(F#qBEu~3Egx7ydJkZ)roQFjl~s|`Pr2;Ut`w036rg9DClzoubxe3SmYIlk$x z%0A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 z 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ℑI3( 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 Y5~KTc_#>Ev;0TsH*MDHI+C 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

  • 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%0AEz4py{^5+nSVZd#HA&9-UD ziIezMPu8WA@Q@lStxInIO>(`btR3}uPqE-+TzPw5Oup>-&EHl1)aM52Co%a-?iQTC zt1W^b%#}WRh2|ad(bc%{Lc>Zg|Vgd~-y^zC}kks+7wqStkc!_Cb&c!y+qtbwa z*A>w3=_dX_0R^vnfqw60^7@)Rsmd{EC(Q#NID=L* z#E<$2L$uj~<7bxyU-MBKK6lHH98jdX-83zvkv+*%NAgjL<8( zXvWONb3_1Y^`Zn^eJt)ky(r;&Zz!&j>bC^j9&1YUdT)r$5AJ+GBxHbjV`v>vyiU~tuigrB5l&W&u79LXvg%;r$5ycj?HYSNgSJ-XUy z#hL~hbe@x0pA6-^c0he{TKD>7W^>j9%9S+)beB#+Geu!@W?LNe;#shHtXn!hER(#W zf6G~y>v=X#Ck^AmGFj6<1LsnWWHa3Iu9JKK>#kZ4+yfALdGu>srfTwzkL#UTs{4ku zx&_``@o~vo~vtOmPX>3$DJmq^MzKt&p>_FB;%acHJ-!;`q>_1~!mbl|>5?wL$&iHuY2c(Xwv zH%{6SIUZxby;h=@Fav70H)hoMLmkS1P&*Kk<9=|iswRZ1R6KJdrz_YiH0%#o2;pFq zNJcIY=67tEl$_@|Fux>!r!1>-?e+#V%o`O<)!tzoN#6E$wd?j$jQ$IcReLiTQS$8e zeynwdif-C_zYP;UmBjBg%yc74z8#iu+y#oZA1+TCQEJ75<~E|d6rTaT7p|_E$+23O zvi4K@N6+yDJ1~=F9I`5&U_&tQnXzg+^xwn{ob!ZDN68%OUBMO^Emt~hx>L`jB|w2} zIwOruFJ`q~HVxyJVpF`01E9dB16YyUHc^Hfnm-Tcv$X!!JamjAq`EgPY{Foa5Fc&P=jW0yv zE6$>+L2=_JRjsHbd2n9p-Lsr2Bn7Cq4;NH0)x zX%kx9)rMdVUIbv+Fjh@ryqY^Uq{r#=-?S&{dGtsO(H_>To-z9+drH|8>2FExD#P{& z{YLXy=Thk^j|ZA^zhRvkU&}c^gLPXS4j7pMY_SctUV~lT4cH zYHR%n>=Nte;Tr523T%N`KRd@NmSkep)RKqVHp72u4$4s_xndQUrCtLoL*z^G#yO%K zI4qfFbsub7-CxuI|J0Nmpc7}OTHRlYA0-gop-CYxFS_T8!~YZ0yIQh-i}C4Uz}Y>S z-Vb0eQR`O6UZUgsE70TGzfz&xD_?=+Dee{9M3PTNk$3@Gb-hcH-jSeMJVee`g5t{S zg!@K9+xAnrj=}p3JA#fn#TbVFf=mBXJAvf(1cFbwa*LR$U@;MKrE`)7I~ZU^cpfPV z#~WgdqWuKtRoM$w1F>lt-Cf|g16UD8cH{2iiGpy3FeL3@d!%}Xvuz!TK|p@QrO*x+ zz0U7z?Cbb7u(_N2q~~%sa;M7Iy7nU+*YXJ$^$?%6ARBT*)xx|(56}`AJR@+8;3%$< zIJM#2tYFu4K7vuX4g1gO0_mK9WC*9j>w=X_eBreP=&4D5*i|;>=KB!Ib2Q9)#mV@c z(e%+D&yN$iJ}uL(Atz@?HTPvrr_V%Mnogg`I$ufJONa=X;~ZL>Jo&0&zeLKl*I7HM zWSbT^urNC^&1?vl&aMiV6-R2YAIE6>+>D|{zX>r@TZHyy8H+zgsrNTy|x|mCjNdsCKIZ^@rW`+WKn*w?Wnxx!4ou^9C zPtrtzZ0%utj?(SAQQQViL87N=9$EPWgKh-u+BHq<&pse;CK(ZXjk-qug680Ez z2jpMu=Sr^IwYxc8n z%}N)UD(viC#5j)ZH>aykyZFaK=8{y$_?u6tp_~tH{G8k<3d1ji9lap?+tdE78f1|I zNj?zIc+yZUuJI+ag|lvTfM!~g^o?i-{>2*TV~eDnX%75Rx}6g%(NNQYnQ2XOm<{tV z4YQ#em^&~B@I11KV*yi4^n!e*HL?TqV?CsdZeXskVO9g?8VpSmG<}VHn62_Wrr|wz zwM*rJr9L&#U=&<$Sd;t@{G&aF8bIIq+F14Le`^Sk|1s5MjQ>($i<0m zmy&2KnsR);Ch&c2k^c7U?}7Te1T@43pW4zLMra%@UV4du)%XoORl#lFvhDfNv7=z0 zq)Q;WcofZ(H;6euJc{8cqqKR_v2T4HQbT0yLSa2^(6{YdaJp=X_d7>;xs(tE_7=5f z_W*S4D4Whw06Qa!mofD-G8;v(rK+wFxj{^Xj@0cHIk^?L70jPxfZ5Bo&0MEp{!+vA z+LAWMjYkzPi+xIb1k%o9Gr+`_zYozAwFea(6HKKAS}ff>EcF<#D%0F;PllD4Pu-Ekz%9U9DnS;HC<_A5EVl8zY>t1{s&!Y z*H=yZLXYc@7Z5X}CCmcafFB)OhQY8OcVIXwQ`?KgO7uK#x%pZAqpBBP!XwShYY8d^ zAIMQv?~S_NtEApY8a^NYS>uD5KwAmWLzB|s=?xCkG`!(}Cu;u@Zad@V_%CgESmk!N zAIQvko%5HD-{@{X5H~vYV84U@zsFb=hkl*7hh0p@nv&XV$6E40tr~)J<`;;IAxO_a zwAvgylFsIo2w~&$Q zJ+4~DN5@uR0^pni2UP`UfGS+WK~+HqRYmFyuz!N$mNE0}8DJu|z^fSm&O|!$jcJ$x zb|wCZttcA$xwuS)I51MJhT+4ef*8L_AdUdzRYE$6-=c==OSGgzK1lF{dVCmCn=P_{Gp)C!X;=_XFwM|HbY^9E<$ed+^P#dt_ouZ zZVQj*%Rs7Q&lOUYCQ(8%mb6wO@k}QeMgfm%;NKD8M$0RBV#Y3pugPJRM{z5)GxHj9}{@SD|syjoFFYP`BV0xjMCYZsd4XyjT~1=Sm^W0Pr)5b0iSN1rCT) zQbFWJj#ME2GEvd?R|>=-8iY)h05QY{VYIYCpGpODh|M>5YA|OjFr{4^#UUjDMX>V3 zUqm=36=E50T^ke60hsQ+IT_)et(td%hP!{RU^v!{O#^Y6o2TYvW zxO8j*Qy|c(?rY4pHUwK+R%>cbOV+m+Aylb&NYDhiWy?54j_Xx@8f zKa~Nn2hcPk*sYQV7|wUN|1`JUqk*3Y;K<|vg9xVYEAZIlUT|1W0EpXzKW2&8AKOr| z$!I*I<#mE?z*#M^A0g0nI}}wKc#{r!Gq4>AvRDj(S@6Ms2p>F7az_?Hb(Fi&4BHwM zWPP0b33YP1ed`ja2|GirEsTGwQZS7hO7W)IkRtHvanlxfCazNncywf<>aZtj6ahoP z3-e+*bJ8`TtsvyX_;RQSib84?v8zDP_z#XkAYc%FSxw6>$llaC21FLCI+o}D3P0%GUxiPyO`nsHx8_$?V zKa_KFE7y}-j=k?Nruq3ov;wv|QR0p>8xX7H?CIVnQKmBTSuft{Y>-!VH!V2_jOywl zHQ(xvI)?W3!}xI|L)(W*N9lo);HE!sZ@~beJM6iZJ&WE{u^LALeY?nqm~rf}ipx~~ z8f^FC_s1(9ZkdzD!&}pPQ8W|w;@@h(!%LEN1Txey)UM-DUB{8>budyWg;PX5VjbBt zP{*OkI^M*)sdx;u>v%n=@Ob93G(32+XG$HScd?EK&qE!L-~~;q1sUoXVAs*A>o`BX z4qBH|>JZh9bqqx|)dW-5={mS&KNXMRMhkQR&QKJ+0!n6>6&M>Vv%$zzWM$3Vxrm%S9S=8W2mlO9pYb4H;#;OtU_`$4Sq~^(teP@JQ&jB1TB2O1HvoHe1)t$( zt@R}VeU2gPjgPXOi4;o8AF>%&UVlg-HAbX99b}%Sc(0^Ecn^zwx`DLm9bUhgcZ0MY zTGN3=VIJBoUWr3-kpk0bX#zG1u1~}5_@2Q1K~3z6tWd*-p!FBEiY)_yn7W`AAz_F$ zFk+mA%@{KMUEBBzW-0r%PM)FX@m(0Y3gH%e_;3ssh znv;r+X0G!Q-w8&!2UnDGN&6GzHaa_)vwJ;AsU4wM?hCers6)D4 zE{x;B515{D(b!N|0p#Xlv~<-ENrjwHRsrghk<9D`GLplkrx>f=qt|JDXYZiZ_V0|> z45`W}=w~zW#Gb9fxK5p| zkS2rMauwtCs!)vg#Kmgfe2!0|*UiJCLNPw#VVvDQ;>C|G$fC66k{|D4>4S{N;&xex znUUS|7u@CUyG7;`I0J!y`3S0BWCqqQ%&pkbIZDESV`G~T51QkI0yBwcV;?6B_`d3V zpS{sD22i2ai|0x0s803}!9c~~VDCfXj>tWb>9D6|bpKpKfh;%lW-L7350{?)2 z0-Wvf{`VLV)UEx@k;iM$M7KQRUZzo(=z--2gt;~Vo?>3l(I+cZ;HDS4{$_PIU8 z;%lHhz3F7t(OWMRx##vZpaYR?aZCIjcmU}?B{*;&ludrNgNAD`unW!OND-eyA zKT5yb%egDzpg}^Fx>!V|h@tbBql|pRDHnCdUqcw3N|!PYRq6C9XXx}QFTq=z%nyU@ zVhVEnAA{LSGFor84{-qc$V29d**7J7S zxy|nq?L?K`guh~tdYgdsA9T>GW?V2zHDjToQ5eWL1-<_m-h z3}D2WtVDad3vDKG7p(i3g0(BJh1<}N9_+@@&#ASWHcC8a0+=QSU=eU2EwP7qff85B z99Qa!v%tzuaH0x!8Gu{jMeyd+QzGa{JX9iR2(D6?*$yN8T+cOi=L^|9(TP|P#9Mxy z3{qjf3a$ZUj50@$7p82kV>;5$Pf%U4Z>GSM&2`C~J1@sS2TZ-Wj#>2t+`#U^U7(wI zUpL_HRNxpvGt>sRAx(lftvgJE`%X9DW+-rsOx|QmgN13}oZPE>M=E5C6gVU#q(-B3 zViK_CS3*Fj%FMm`V;dr!hhFl*VJNe-gkkpAP#-;yBt-62j+>Os9KYv1PiBtZc1D~@ zqgA7>mf{g+(~%W7vvcghhy}@0v+4A*%O0l723%#)SaG91smrEh=Ww#={6kMaUFS;A zGdqWPb6D@Ss;tp+JTAQLhG?a=L`9(fS;Ke=FsOFJH<|(YooUGDGDM2(_Y)1^C#n&L zAT7xW=*(}41E)~xw%+=CM~+cNC+VW&R8a%%mlZUMQwby4e$Y+PVY+Cpt0>8aqRqN! z3e}vPCZFp$?S*q3s)^$ZW(de9wFPs6YjFU!g8a;!|5LAfIu97%1jW#!JWXeS-b}_B z&URw+lG#7IU(ZfY*PnE7)34!&z(I;~NL1JQa4fPI%Tncqq(c&x+oo~twb-(bua+jz zNL`Uy>Wccjy0YDs?P8Et_ny~JB?_dbv>Kdp!=C}vS>M|6AFz0^+Yb@9$l`IFPrC|b zJ{`yTbe!A&$C+gRacc04fdL)naGk|Z{C`R-LwrRAXOF}JfYH#0Wq=5!emNScX6aJh z$$y<8Q0JLYRzz{ZDh;&pOO`vg;sStBTsFriJZ&pvQ*nz5*_p=jEL?&kbQC7#%sZ=X zIV0P?&DNs5)WZU2&VMtpNjw2U1q3!wlSsk5MzwL3)+DM`8&9%xR|7sy2{T$cP#9Il z=c&46GkIMZ2RE$AHYNJ^RKsXp!@Fk-71C;ejZSLl>#m`MH54Rkco@B$ibH-xn`4D zJ}UIuDdB+7DUhE>(!6){Cb2xMKWcQ|ReN&9<7bdVx0YKPzt8o@hoGkJl?k{^?TI1q zw>UlV_u~~c!gZ=A`r}D^%TAz&3#U(T%zYd`Z8k(B#@k)f#T|`5!kwhWi`_vxrM-L| zf@?Iw(;dAT9K%ud>TuP7O<`?j9YM1K%@NoEEaCPD(t?3Wc4csY#ea&m6;`aST*U4T zKcKkFKXU|KkpuZLl>SJS_%N{!RPs_=llldkPw&Q47#hDdRvnLv#Lw~5v}7<*=(zTu zziH;gNG5y#xzq4gc{_efrKkzB2+!FlcW~>>zoz+-k|txe@dZ2w8&aL>q8Eb~@M2UO zF`flvht*Q)O6=Z)_P4i4f8s6gF7#W)sQ`^{dWsjLhxKVPwW6~RU8{UdHtOVuL%tW} zhua1E*ajfa{<%E7t7Fy~{D|N^PkuNj7TnVOasOly{%Nt`M_VdPW#T-j+P4Cd3R*ui z15Cq?1)rp0p4Sb`m#^0_8v)aFV17cTOlhYBGe^VB(J*md!fe|Bh4~QY5a9g7`1fCu znIRcp{)-GS{q|`r&mE!0#zP^&T^k71X)LnEb921(WZ|*9048&Ad9fW_e!T|vJpdDb z2C~>qEKd(E-&QWBk#2?;ve^A^?59I~`DbL|^^Sdh7E{B`RR<7wExD5Q^Zz$L_OW@V z;c(R_hasj0Gslsc`+3QW($78fqr>CFHO%%&4$OJBMwaBA;}y)F`O$B;bH^~%&IKAK zrYOfS0W)sAbA{&d#o+Ot`LVCfkGE@>!xhX-{J8q01MuUaHa~t(1KT#SXMP+n5W5ri z|3CS$d;hK{3BC3w6p0e5f_1yrYZonsE%!6{pvsA}K|7?mnEgHOCH-$neap_q{4|~` z``({$GWidK<6bCMTySNraF(RkNuHO1{MXB2nMH0n@BrBtelI+_?Z}?`f+m1W@X|0`%@QpoKQj&xfcszEC4=Oaq$b21+yE?`@#d(tygw zS0cVx18r15vGG+l_ro46`{iH@N7S8KZ^Iz`T72xoGGOUnk@o%*(^Co&jF#8XONy>7 z8vGyuZ?rs#C$>8z6uYwAcC?f^>v{%7*vlYRc*O&(5FNd8FRIdxmdO=+wEZIFN@vey zehf#mI_7)3rug!QY#@JTdnG%+U$XN*XHUA_dR^`l`J4C&=V2O1vePhj0_d+8ta|9U z3DQGMH&7|@l{y<48b}|@E%32mJymE!d|2jSx9bZ_9-ghDXc*E^Um33ifYGv)1sD*m z)OzMne}k__pWz}B{?88lN=t0i(!_`OvlAQL#4vqS{lG`ZeF zip0*Jfc99ydhED^Bcl|B&eH%N3JSnO2_zYcE;O$}0(<61YH0!%cHm7iKa#AzZT*zK zk5+jx{>_OL)9|X-C^tf$lD^7e>x{?JlAQy*TfMgrC-e(y+-ynH7ih7u!T9qN;@wG_q= zFGSe9+woNObA>(sk0VsuZTqyemwhfgL%?S2s@Wo1!m+Doif9p;G8>TML+`a^fgk8% z$97f3w=htFM5e=QI3CpT7%II9WM4?-B>XE53{Ya|ZET8={oC!c%|JxX_fQn$dgB>9 zM4WOpoVWNy#`YRx)e~6PSnCu0fSVwBtC5N%0`D2Fs*t=u&-WjksgV3Rp75CKHhiZb z`A`#|(N_&T7bWp5!PtwB{=MDeGBirzX)I@gFW?Gfn^CrVe4B5uOMim>6~uRGJHZOd zFD42BMv!^AFI(r9UC3C)45A8|+YVDheUL^*c(@y6WG$N=1z)E(`Uxq4tYR@=u=d3}ib>}?B zs*?CjCq6&B$8OO|Y|F6m;j;8#@L7GoU3xM~D}J1=_%U$>Ut0+Z5i#*Ap6wvAw=jvw za6#n2cPZ8AKG(yBj9-5)#PL=t4~ByAIKJn;C~Jo{a|0WkSzbNl=Uk-+dm*lq{lQ=HK@Kv9xR4nw$aFV8 zjzoN=VyQPNs6=EDm=;-IexsRD_pZRR)(fyJ-P!HR_SMzInzBaVZn1BTPv_T2B?1Cd8+E?oA9JN z3RSWLG=<7N6q0dw;%{vV9gP*MO`*wX2q{$4J$;_P$u9UwHfo@kq1~Qe53%vsMppLF z$JuQ+yHMdUOmINp1omd4c^P!z>mOxJiD$pm#95LC6vTNRour5p(16#UqKI=JyDzyG zh- z)!~zakk-ES5!NCuC~Px+7*NC?_WnPSQr8n7?Y7UT6z2Z~0%|?+2~qKo6V9-=0asxj z@+*?QP@yny!;=)u?*)X3)+Lf202yM$vd;7Z$@x3!eJR6Qei7b>_oa-%4s&r0?@Jkj z9m;gD0|xG+z=h1mNfvxx*$?UMb6%#KHHdbo$Qy1Lp|`6I-(l{QSJB;Y#$fee#_si@ z3E|kod-I7%wgj!1$m+hG2Ci@%x@qr5Alyaj6=` z?cHT!3^|+gyYsQl!AQxtN|l_Ta^4lp(tn1=tfN-wXd@eOQ^*?mR^)=i?cuHsnja*S zD09Qv3(Ul8yEVt(#g6p!`(UHx2HaHr{^LB=@2{M!`n{2_dpZ7LjM3D7XY4!U{p|gJ z?C+I$&+hNVxK8bFsADPpy(-t~@3T<@Tx0tnjo9({=}MBA96PDIsoJni=q}zh@!>xJrM*SuFi`i{b)wJD zba@n+Q*Tx&ESPpaI=4kf`4c_)-E=-qy5Vg*CQ}4qFDwp`Kb|J@i39m9@vw4=8%F>o zvc3M-zD9e0(`r0c!uWbzd5P>~Nb_Z@PO3ghI?3(cu#a#Ugq0_{+&NWoJIU@D;=SxM zCcc-ipzS_UpuzOcxPattsS#Jv^gfYR@(%z-6bNoC=?2`<8r)sofZGAN0B}VBce4#{ zOd7a6yLCIY@TuAP%1N*l-1Hr-n91L1T6~9ID9d zai-@bpQX+20F#<92?}@lmZ?HvN0jkj=?k^k<9{INA((dJ( zoL9ky&Xi%~wpJ7(5KHo05~M*tPD3wrLzgJ|_3ypt2)*UZu2m`FbGZitO89L3eTn{_!*9{YZ)6|3bJQL{emk*H z1NN%!d+MmnqOqbu$1Tl;XzW>j53t4U?HcA~8Ybh@Arv7%kb`sTY#p2Tf;dVN!ec7& zEuN>&35Go_W*W%Z9X&HAaurV}#QvgjzQ`rkME^*n(?;ra zvtcWxf3=BZ0azfKX2W(#qb^5EMux>|k=TlllNrRLDtY+DSW%seY{Tmj^UEZv#h~8C z+>yQ@jVP_7Iy<KR)P^Hh-OujOLj6Le0A_5WMSm? z;yE;ytt3ZquQAiX&$IOu{wQ-a(fChSVlZz-Y(*W>nq9HOtQx*>j4~HG`Zls3)L82v zNw_GC6>ZmR_APO-Ke2Rg6IwxF`25$cb;N%*X*Y-I-x(dL+LavMGQLYPtq<&}Q1U}U zrTYY_M}Q^~R{PvrU>{WTXvH?D3gxY<1x+p$F2D#$ifG%?bbFMnU-0?a||qH73VQWj#d2bZ}WJzY^XJ2hT3bZQAkDymv<%~1q7p|H z;}Xpz@6sdi0)D2X&E3WqoXzyA@;mXGuAJ)&$aGKT`L^@th@z}t(}F;yzf?aAmi znxffjFgP*LK36pvg-$NFHcn(&}&`=(Atbw#| zIN7a`#73_l)%jYf_P_~fOLz7_8d%Hl9JNtSN}dN^AX*67mHOg|twbaqgxkGho3$>~ zdX9e%=LC00sVUs4E{1nu)I%FTwi)rl%0Od2A}5p-J!26;~y*=m{eO+VIqySYG#p!xk$r=j#ET^hwVg@bvxe{ z?@Zzk8fK&}6&~_FDR>>9DzwW0Pga+u$<+odY+{TBl=w`v6*fcAy8GnM*gepMckTSo zhj$ZBco6yN$D}Sa-CLMBS7Mq}CmGMe4uTZ^aoeAnZ^3gOkD3>cgqWA}k^LIt-r-ukX zNRBPH)%c$?lT#c{)=6;2P&Ew70JhLR1U65D{k{S#ao}#Sw*f59JtdP7j)J&ejfIqk z>LY-D->DipKtYt;;%4hLx+ zs}IsTQ3_5d493nuqNSHvKAylbgxPSwinEx?VlJ1OvQi`?UbJ5MC;uXvaOV!!+KHDv z%n$HSf-10I?+;t=Cy%9NZvCGEWhymPb3)NGL4@l_goZ|cam5a2d1!5n%|HsM;ql|3 z9)()-flMSXHsRaO3u5PFx9qugviK*~DYdpTCvv8weQHEHO#^GhI<67l#0C(M9_ch& z3qm=4^=k2@_^Ir5t`;#D1m0czgthJk_~KSQrva2*5s-ur$e*vP$z5XU>cbFiOgGHlatk%Z)MfSa;sr#!$K1P z7H_uJaf59NKg#;5)-wIpCn0NQA=YYZtrFb{)#q=aZCsd8G%$Urv0mAz0}qD*O#ircvpkmdKe_Z zK!>rMKHmwkT-fJkl}-=9r@OdxHm9OFL1R)!Y-}&n>WeC$L3O_PlSkzHo-D={gJtr? zLl$3#do{31R_w5*4h+Ng0b^JhfRrOJ?UY*BA)4D!fELP`l-E{%#kLx&=$4?hHu%*p z(}FECHt=jSmb;a6)xesn!bpA;ad?qKOsiVXgZz6%n>DA11X`;|_SILQC213kF5Z$0 zQ}nPcjmPWtQB9zI!9*`H*L{T}CheCa@AA5~wP;ISEEh|#Y9VB>bxu(*u&uEuWKF<~ zQ|+&7o!}=@ILRD|bC*qoLP&~YcAQ!mzvb|JpW%mSO$%vUVN}G-_==dJS}_~PLxDB}SxP9FwufVn7vTqRQqM zjOO3rcGJG2jOO)nF$T+iVT`+v(B-hh1I>fJLprVHItiOTlZ|K)C?_OY!f^cKvyNxbA1X zR4?<>E~c)1SrjcY{wvyQVrPRv-l}cc)_5Xp_qE2Og~6tMy&FsL*(U;Gev3igD`sXj zjXkt?q&El&`~vIdzafKFcIp!v;34U7^O?YB2K@nhf`wp=w;C~=d&Q4D41u-Ql<9b- zF)u!VzoOU71Kx{Es~gKJx~i_3v#fMirA~#KY;F>w}cLKn? z_?!4`S{4ms>V=K!Mw4^n5q0BX=f>T<5q+u+H++p_P}x(AKV4XAT2bD^pn47!cIXNh z;%!tY@63M(Rq>tpYz1R0u6>Om!sx)&!U~W5(~9yr;9Y0tyg-m;s)D9%dVl8p577Iw<8R?Nn!_Mutoow(B&GJ^d*PKRALRo# zeWHsy{J5d0r07%LGkvaR4GNH#J{Pempbsk(`mnCJDX&|*aFbG^n)0HOlA~NHkWaev=EU215_XZ4J8&oh_)y^Te!ypv`Fvx?_U zgn5Ui>(##%MW5uCnWlmMLc;%>#ZFvFkmDEK&E;9BnbzvTh?p2icb8`!}X(r~%*-g_5b8$}cY->So@EHK`8INL-7hMk%!2_jqJ4ZL}4Y%H1 z%IQ7~kHx+6jdbPst}%|kyOgE@3=wne^vG#V*JPa?nb>qq_PLSjrfYJ}i;S_RmCwjpjpe-Bf8}=R7YKWz`xjd&luAJ7~0gCRaJ2>|b$3C>`;d z!O$=YuYwTVUIXt-&cDpo;lLTW|9GZz>&3;Pz{YmAu#(96OwPxo+rT14C*5&N1F-GnD0_uI`{DSsLm1zFB zpk)>XtqsxlbAs0E+jg#;)Vs!bbeF!nHj#}7yn6`V;mx&)Tz!Y7)SZ0Z`C#RFebmoF z{X$;=>Tm${)^`ou-Rj&e(s%t1u)g|EKfJd+Xgp^2Rjp$q`tz1*@7hFv{o(+3a|i01 z1C2-H&YOev%|Wchc+@oX@4-#`3nRH3C-w1RzLTrIxKj5FT>VS#_4DbA{=Vv_Z{^ki zTzw-~1M%9oxz_?nugAw`FDx93*!#p8pzC#q}rF1M0F1!}ShaHeKh>HI9cj2n?-i`NHs@dj6FVOvQV!d?z{f`P-DA)IoUy_&IG}0&w8&tLin@p&qoO9# z8>6DaX!hY{jw$O4Gv}@7zCvRe*Yw~wBl;08jAthmjqIq2{b+B~{$S+srfaiiME=xt zZFX(sfu?J7>Lb6yrkTb&tcMB##k2*$Lzm-d z3yfv+0X!TVDAQax2is20EevvbQ!1Z*p~GcICR@FcEiJe62;;GATx4Gw3~Vr->*zeh zcr+Vf1!KQ4p6xIuc3=*Iu3Hd_w)v;D*1u91&RILDweb}{C^xM&_m#xIuo}a)Jgc?V zPir0aiabwzfCsSjm(Kd4#_$hX1*bNMen#6#_{NRAA)r1l`urAmC_KtLv4X&$?kr}f za6eYqx}>yHsI0~}xGuMJ?6ksR9Xla%(f{G?UErgtuEqZ(GYJC(&P0QziW==;M?*Cgtl-2tlbnGW zm;fqDg5goolvY%P2~dp~m_!*5qv-YC+SXoaYj3@6?@!xWz(-+1AP=4a6;Z0iNA-*& z7<@ngW&Yo_&rBXvd+lxe&*zgl`|PvN-fOSD_S$Q$z4kgXWLnequRRE z^b9G!a_`Lw4^}Whmur*D8txvFRX4OJBXJ8-sIU3`9O0UJ^gCth3H-vFxP~WXQ?;gR z7#FLR@AR}XqooE@bGvm#1+C0%cubID(!(X^~B8BzCOQ)=wTJdq+#;XIvza6Lv?A+BNl= zOEei9s^pYfZF<~iw8P!(?c_~#kkOIE31#vWY>q}JL$1;l_Nczgo}8_%CAYm+yEQIv zYuCqNk~24|*R{13IXr0BuJ4e{Ey)YCH76I=X0};n*HmO@%4#!la~MB`{7}0+XnRFe z54y4Z3eb?~M#Ct(PHXxAu^!Z3tu@_hQv(RPZ&WGUHCmH6VFV%@8klE&u=|I^v%IaX zpEd+#$Jubqe%D|%%EG+{u4T>?2!`~SeFb>dZ5zS&kuJgY5=0`e!uS7ZYQjmy3gz43 z{>J1btnD#-ko79qyx(R%{d%rNyC;o98LjJ{@k_MGB?=BT8d{?tDq%#l#%HNjM&&j& zDzd98qhgInT!CQRD=qg9PQc2LF|yFb3l%6{s+hb;uHNpDfh>X|ihG|}>E!8|rw*o!JYn9vfJBqVaT@mM)OJ>UfPEn(^l4$dyiIQ}WTrsp zlM6z|4+Jp+&$;q5M1UG;*aER@?8$SqwS!6IXd9YqJ=>E*v^8>@t*vivIQp43uDK$r zZz*K*1&mjNo)@*{K8QB4g!A&uJ67I@&sOuUN^81LrEJW=C#`uGr_Da|?zf3@-uhqW zUB0b7R&KMkD<&sKvo6$*1~yb+OFPU<^VPhQiq*Wk_EKSWt)q4;8F63#`KCu7TSq~k zkyPyOH8y9}dLqXTBRl0TJy1Tu$=QOFSqzj^Zfs@>G%y7+<1{Wa5`Wh?Nj3QmjEK}J z!$gbu(%AVuqi~}E^MMe~WBg%D!mnBwiuPL1Mp=SwjCP+T_?rRabSjN(bOvl#je6?N zsAg??UcL-^`22LEfoNe~@+$%dNVMP(T(;?@svKfVI#*k>rQwYY4R3l^gz})aifl4! zo8QQ(9V|pH@YhB|d4qU@l+eOpC_Jsuhho}Mk7>Gx-U7xCTB7=Cg+0)P@`}U;HUthMdpTywASl5C0&C;Y;&egL z!Hbomb~%B@k$UyKqEWkH$98kXD=1kOU@&CAu~i>ab6SyhkFZ z-)OG1#cRu>`SHHB3vz0k_d9CK2ilvVX5oT4K4WX-z3lLL@-rlIET``L^td8csd-Ib z+tOmyNn?uX_Vo0K@?9p`;a2$cakfS}Ga)*)8MdnsN_Q?P(m~qtDh64JNvX|hQFJpY zqfZLC>z+@v#vN=C^dn`yv}H3>j{dXf^h+d6@xH`rN+bI)h1<@M$tgnJq-E%8?c9lyHCr}9{5@xMxmD9-x_Ph zx&!QD+Yv7VCF!cX<~QwTnbie(s2IT1Zvf^r7Oc^W0=C02_AYpIms5U(BviTR$S&sH zFbGj=T+fR_kvB2hwI+$!3sqW;MfF3hX|mqQTioSa>s|WJDeGO&vqFr-y>~@MMIltc zRLHzLJRygMwGAlD3W#W^i`8o)rq;}DKDRWMxpiu5C+79u7IMp|XPy>ui=T~6R{3vim~+cZNjOonMm(4Pf_Fgwphe1zIH8rS{<(Vqi`LoBP;YnOa!!FD7-i8 z+;o-3ysqKelk>WYp%PguFBrXBa6Ok*RCrOr>aK>}|eOyEGO9noQ5Ou*qZSUG7>vIx@fpM%}*T z?HL}CrOGdymI1=m1H^?HAkNLq3nsn5@Yeu*VM9Mtvs%HYCiW)??THk};*m|CNgN_k zR?e9iyUbHreur_Qjk!BXYZ|OlHcTnmq>yOm_gQ14=B=VPZn!y^J>+6M=K;JCplDGlb2beIDa0U%-hrE z8qG*GXX3+-E!w;bCj<18`D)It{<>m2;IDusdIf0j-_pe#ER>eO;!q@#%nCtEtPn%{ ztPriyd*yAVaQTIFKGq`NWlHOwX>+y697#!!5gbCsr z>*HmgL4I*4Dy*R|r4?#)>7=bv_N>Rx4@LDHM9j%(oa5*B$BO{^Lxr{DM( z`}Do4o>PtFfe7;6|^?08@}k-;?vyQ zl9!1$XKba)#KXb7af|q8?+e&INtf_89?%-!5KzwX_VG_d*4Eanv`fW}9pO7=Cv3qW z+Jn+;UCEo#3z{dy3cJ!UiRxpixB4n)$ap|NXJ|BZ;i}MsP8nkLgb$J2>h55kf#piJW-ED7oVzh!y9 zGY6eqK4yS85z?Ceoz%ZVoET!iYf$9wvMft?H&jqPL_2I|SD^H)2G_N#*fh4Z=FOFc zeM_ihv$n=r&ZcTs$*#Hq>}fW2)E#Krtu;PDX{0XQvtt2!a14EfkKXr)Adm1=q^QH= z9he@QxCh(mjemGsD79oCZ^;-^#-Og)}4h5{G&R0)<2*B zmp?pV*ALIg3SW?lN4g6Z9H2Yvd2{MvK6Oe9N?N@t16^V=agcc0IH8kwBHg)*JK4=% z{?s$Fo4qCV2D3@&+aZ}tgjPkcE23>n-S9`L>>k04ar0!d2P-$Gug=YUw}a-fFIr+p-2+ovGcQMj~fG;9J=vKY1R5b zvXWJFY^+rQ&ud!bLS}j>w&5x1wxv&LYerQXNBHPSs-@YqN8Zt(wkA2K%E0Bb8>Bwo zX4QoNsH&5Z?A4JkG)`5ro#@CtvYob}Q$)KyI&!Bru2bf5oTfv@IYEq5#+H!n6|GSQ zNjH8VlMw{S4*iUPHF<@zPmJXUgL1OVzN50Fr51mS&tVVYB3Ogpvt_|9nR@9CCccIh z0or$!`i+EKYkZNTsk-vMMI;D>bmv0(878voSEVzV8vX(vgz_@?FUh@p^Gjhc(aLS4 zn?pbw3!vyH1?!mqqxUNGdp0d{i=$&~bxO;k8-5cw{5U+0dWc4;Ni8nx&dMXQ!F^ZR&#^%O*eWMm33EY*wx%Oezsdy3aS)RQ=aF-j3>b=)-9m0w$o3iEoJysX%rP!n)15zwALoSV=x&Ue-OBd| zMyd$|y+D3W5j)Ez7QE%rP`5)Ve|>Zl#uMGd)~lPeR768398A&hDW1u57YwOr(@&^+ z!Qbx`{*?Mz{};l9^{!VHM)*YjL?d*2IVIj)I`zz{gI>RYmrA4 zA062dh~-Yqc7h!fIiSI;~N@=M*wd4`SpD z*>-7-Hwce4luHDV`_U?WA>*;tSv~6uD+@AIP~5%kTPsU8em?&$NwxYshZf*?2nvjs zdXW|>doZOneF{4hww?HhgnF1RsJa&&{a|uC6J`*evtC+O9KBR#4yXKb!Wug@b>GbF z(j?DE$hM&4tHGW7jw zx?UkI7b!_cB1~l@9s8=prSb;$RkcjQ+d4AZv&c3)A12THn^{%6$l3v!=wENMLjS5vTGH%0!k)6v8| znJ2M2KEu9Q;o9mAvt*fi2kN{wtK_BB7WJ^)urEusYfpCSwpV2@r1{MpMbqY2KmHq2 z;-a&Jgmf3*D$D<^Ub30Zg_P{k<(STvT%JG?d?aigz-0M6Np1Oiia}eVu(teDj-V(; zj&i8jcH%a^9MG#IK{n4OCX-c$qVqGT6~2p&=1w^97}mU|1&S5Re&k$Imi+*}EA!<4 z$a+J@mBC0G)8nYv4UV%P`wy6CL&jx6_;^V8c%|_Xv^S&?^F&$yZBc}FBPsBHLw?li zer4L^c3Hr<&5Obm9+Hu)=QU*|&!xNwHc9LT*5iSYlOd1T#Y#d*LSuMGuQdhjHtOGW zRy(P8E49X-Ydm8rBKo;HU`F1+_*>WHa*R0 zlcKfeDxNNG7-@ObqgvD=2UH_grR)Y6tv`!W)uWs)oOPR<54xzPAAiOqgWE<9$}}Gbxj1`@K9sRUvD7@xT#h)53-y} z;2!{Ywutw4uS2Q$Iqb726$xUOO68!sx2cp3YvLbC8Ed;0iXIT;^(ewBPnPtjy40Y^ z!_1PtnfPxIP<|jba*>iPa5gz#JWhs)tH~9Am&SwLF0(Jf#7pM!Blh8F;Xz?=(a^zs zK1;W7aOwd8DDm=Z*qYSdR35}&M{YalF!O*A1@|DPdP^xE0eqIZP4der=+ldVaQ)U`IMkB^`J7|{6iaDA5v@RpwrL~ z*@dj-AZ6MfkYffv0C;&y$FXj*%XLV!W1tyZbI7jUBgghEp*&=S4nd+X02fxpjbdsL zLOQQ!re?N!vEBA;^=9PollFS;%Tzzv?3L+B&0T86>8yK zKDGP;Vio9Sb}uJ2ru06Fr(eVclxlTx!ButkR+%gG`5bs_NIx=?ZD~(~-fH&B_QVF= z*w>rY>5wenvkcnZ>0F=jVR@S!{5EXpEf<$puk>T9?`c`yyfSmE%3rA)YFs$i8YZrb z+H~_9N3f4L@cH){1(mTN3gcG4QT-N(Cu1$KyX9V|iY{#cnc5*h*XI%B7Z3`yW z$q633?b)MM?%_C$an)XOw`!AL;V=kAkr#IdBL}nV{u{He@5tUGdwrf3qt&lXYT@Q} z4_=!awMn1&j=Xwgucw7(UhsLkbZvaA-_z;W#&5(roW1A*F&R&be-zLz6k~9gZ&~*V zMrr{LM}ua<>osy-xAEQ~vSR5_Pi(k%)L{@H#22vbLu1E%*Q-aTx~h!O zUUuH<_YODoy+vY(&~b5B_ye1!1*fUZ8U}Z6CBHr`BIc#N$DQ@ zT)HJ>Zjp%m#(NN;aaH=X()3QI|^> zXv#I&dZfqdhN5nSPoc1Gd{)w&DY;;<9=j_$vOUKa*)fX9+^l`Ea`fx9cIs(fFo>BQ z*>30IwV1r5N9@#fg@=~M?5Fe;8lnn0e9Lyol82BN@WrmqPPOZvz2Q@NO}b_i*sMCO z;!cWhvx=8W(f#2;0u%k~SYVYXro^u(Au-Dve~yYRR+For7zlN>8jF`i_Gg2(RZ_(c zW~WOQLAib87OHTUz% zA60W(4y$rfaW%EenOSk^mYCVy>fUnorYg&|TcQ>{r3$Q69_@iq+sq683x2n3Q=IHs zGp}y}Edns4Hk+gzfASf7B5&s4@Gf!7HGgxH#50;tE=FHXZze8@m{22c+9~pgD$-7o zkZYb42~eb+it<$v2So${nObh_TZ`Z)@}`p_tNYXv?psTtDpE|5$NSW>q;D<4!y|8c zDe^?0TIzcM5!;k+**gu^`wSstB{x=QGF%%z4VP2A`Y-RQ^+3u5(C}p~KIUX>#pTbw zsAPxCD47g!%peSKBQl~5L38&S(H?eq7B5*iSB|Eouy)(MnVHJmbc^c$-E@Pr*1)qk z^%$^d*0g5vZ&9=QZ?fJ(QXJHAWDs#3{Thcu!54xL}G2AA)jrV z>_@3hsOnbneCtdXrV!hh=|bWr*Qb!)nej}Z6v9)wRC}uRy<7yp zaL5_PO%#u(U;meaAS8Jb2>(PJuuMyD;;Q?9-50ikzac%C|Jp23$|lx$L|sh9#wuiaIl; z$rcu;DqZPnaq%b*2Vn^=El#q0$h@?3U9Cn38C`0H! z(0BmWgGY-}kaW)*+R6(*Vo#1(PO|&q=j7GOst470hZv^`49o+2E+@DH% zGwI_bYEW*g|MHPmb4+fw@tPb1s*Y>!mwE6q_X1rt$0Vvc`ImaP)@n;TC3E*Kvqa7h zu`5!|L;0`S!nIu*kj$eb3hXb)t(>!{f59#pp%>tmKM-`48=>8H+YXrCZb+vm%VA|f zH9cARRu&ujExPA1S(LQpE3h5y`pyyqoxs8|r)l%Wj>;l0u;tI~kmn0S)p?mfqqZixV<(M5Wyk#PV17gff+>MORzC1iK3; zkSf_{3EK8VPGCZl$fL1wpEjF0IFaG_8M8N0AdBs*8|)V4XwEY<_lsnF&!M?n7={-$ z_x84OWhUZ|ugu7}a!bCk?Gu{R(d;_Z;tYm>S=KNlWehCcp&pACH9kuWbIt!#_=M7W-k>;sTP%AYTsJ3pH0(H$6 z0@0cZA$r}@szvT&(8+fAO1jtvkw!nw4FB|Q&Ao}73pMu(RQ7@zesy+)yY2k*@NbMe z1wIcgz$C+7Fuhy4i92G!g|uH3WUHXAK~9a2;e(RNoKXiNcMEgvz{gNIG~>WeGO|G! zH~GI+`5RVQcR%Nj2`o(a5$i#N_2544bmK4bUSm*^%t(b#2MxM`hug)Q77b3p>#DlM_45rp-+jhG!~W|?cPjjC zDfDZr(6xb^yXIo=6TO?ffNk-7-B`+EHmTT0OkQCxg#1*p_>C_MhZ$F_*vs9tIWFqz z_VI~9${M_j0pKWxuoLzL505$^Yn$ggOSI*eKuX5=xyC2bwa4*RwCsh(EaGdcmBMHZ ziOaL0pHUc$jXc9|j6OqJl?-QPj5D0v;Jvepnp5&+txC5!^YIg@A(*MW&OV&4azF|@t~};`FExN$B=g+=@9>Q{6D~dpYRXc5))VC_Ra8GvDcTq zFE%mV_|Q+Z27>pAFU6y>c>Cr`haMyuhjZ9V(~znP;}#%aj<-B_)xxf&k{zV z*PmsQQF91F-d<_zsK8@_GYX5R>&AW*yo#~mt@cG%Of;r$byymlELG)(eYt>FZs^PH zQT;1U^}KJcgWSULo~c{y3vgmr5T`bmd*&U=U+|EhgYu1kV8Jvd&t-PT@&gbZXJi$9 zD%zj>qR@V3b*=NL`A^=cxZqMkR!RrO-sx6X3xV=I9no1ZYYK+si)pi31m~6zmSYa2 zics2^cd4}Bs?POyf(ya91a}d!mIv*rcO0&u_efc<0M=OA%a)!ME+~hp!T1^h|EcS6@eX>X%k2w3Fdi)z# z1CJ%=>+^rdseJ8%uxq~DUiu5`mhfP5d&NWCN2{anT0x+MhT!>cdyOcmGOFDk>`MVH53-U$$bm~f$t>O5wT5NbK zNgnG+t~{UG(Ic`Voygmk^jd%{>x<4i+nL%t-q4=~!}{5UK0M_cC8BOx77}8?(%}UZ z%~`fZM5)mmWz&q?nl1U7yN#^snvMBN?%F6Igto{pEWK*4lDsw|sZ{G*_^m>isoG0W zkbR5TO_=ryRPbKX&aY`L>7M{x^=1*L=7z+*i|?n)@|whrD3jiij-#h-g(*vq_4xGRdOr%x&o@Q}qVxHrXFj>tj z_K=JGP_-)~@4uLq_mSnRcUk{6#0#iy*4&*U2yf9^cV}s>@qeQuo4JmqPc&M%MaHxc zZygcdXU)}?-_OZMloCjiU+9!yi+)L1q)oyicoNoJAYrX)vdJPuE1N7r#6f)d|F{zo zUSk&~%_+2dmJ3<;^3R^NRgM!GBhNq!I73!gbkH-LkzJsxeKBMwM=}# z0cx1ybCOO<+BfhyqW$${f!nr)jE+$qxJ?!4v8%Ehj+KN5at?N5!?CZ|osJ(MPW-86 zZq|ty>eKw#<2ro}-KF)#{El6GMyxPO0bXyXaCR*Jsz|eXe%F4TT|QQYOgy`=%Q;N~ zlo_vDt7Ui!z9=Cg_p&iE@E4*6#r2Xl1R5IIi_43-WQVMh;`4103aG9EI9Jk#vN^$eG>+_j_xrx5-~Ju15F$f;3> zUwMd$VmZ-)4U;c|1fD1XhR+v(#RVy_ZHEIPi}yp?+bhr$7nc!>IER-Yp* zsU7T?2XVXS>{l_ny!zN_j-`G+baK-9BW>+KHn?-p?%xa@_1A&F+T>#{j2X2O_4@QB~#`yNGup{#}x-arVv}5#=WyL!_d<{#rwA} zO{bfC_t(A6m8j;drfy3&)wcy)Hl&5pbPHaIyElcpIa&KE!84?1Ub>L`Z`3J0EM-Mx zp4RFrvIZb}*0TrF&!iv^7uwD3 zNedZXK?F^?X^JPr-iU0PB2mpO_!LwYs=uLt(%djv=l6x9W0;|(YPOdJPFbpbvOaav zNIP?)x?RK(n6Wnf)mrVMmc@Cs+Epz{(eTY9GiZHU$A_SiLfXaci`>+jJNg|NOgS`G z-Nk=5byf?!qxip5Sz;=99X#~`Is@-X^Cc7i64t>-*o;?m`}R#^4L3>T8Mx;On=U9rW1i3@~@-a!b!|4Nn7)3 zFw+XrgsJ8G*k^c|TE1?sOf4T%>l#Nrr}PJ#QK~j7iUQG+bn`T)@`$%$m?2{#C;#Hi z)27`^zq$%f1Lm(cC)K8Av9`8wQmrpK%{1DnwJW=b1Fd2o=RIh5WN|* z)(&&SgW?sYW+<#u&f|y;RAS}@z<054X5zESo7x3S_VPlb5PZs^-4xs2I3`WedL$>~xWKMsBzHIssBkAKxwlUu(LL%_8 z9;@u?+-rb{a<5aSDt9JONa06aCV-pwR%XVtg?29OqDu4URKSg3u*IyUz=xm!&R5d~ ztAJxDI|tGKwElPEp-|S!E#ZuvUQU?{P*K1Btg)m6n<&xLT(N=T0`4m-R z63^r6x!deU_yKotH+fR3P0Kz1FP2%o-sMtdMuWrx7$_e5W9U$pxmjKTu@75__cI54 zX(E627m7;aAj1?`$dCKA>ASfnYMy(u`TdX(gp=^K(704WrNU!L-RK%kk)1*fB7I}9 z7J*((9zoP*^On(pANSRRIgRLYCxG2b`vkrYHbsFpV!)dQHwMr4O)nu4sh`U z%NwaX_xm+>1%7kxiQwOT%~SkbznY&ptN6LO0qTX)gT`CE!98Iavc42uoBkGqd_`~B z`%eL&D5k5q66141KC{q@@wti|Oe69YfY}JN@?8SsSahmuBw^!2WL9ZzoB-Rzjc$te z@vmk&SrB@AZ4O);}FI3SGwQ0RSAM z8wcsAD~gyTXLs(`Spw7R*Jf>P$j{M*?OKzQTqt#d-8jMJlz{QNs#bPwv??ZO%^ra$ z&W;ZEqJXyQ^hF0SGMp0}^0b{CZ%>Jloc<@UrxYc>n38Z#%7lpJj5__mj}=C5bd8jq zaj){fO!z(9@4ms<<=JufL{1)SPj0boN4nl-YnSz%(?qqtNZGioMOq+o+z~EJwM9dZ z&gVn`+jh2{o;^!nOCr?{`S^ZV#D?=Q(9jecbH!+Vo&!stP)<*>U&+~Rfe0v;8sfb> zTe$m`3j1VuIv$x?A7N2b84QRFDvL6KkNQX+2wcD`cfU- z?GkwXo|nScvS{zB)yIae&8p+DsNGe8{szMGSMW1+1wvQNH2KlEB}N#j@%&Un1hQKt zqEZ!FF8dZ2f4FEMQAOrm%Te=I1t3ikEPCxO!nofxDhTZmiT!G$QxVQGDjA6zH7ZOG z`J~g3kJk8Y$d8a4?3cP+DiXPz;tyymFHmF&3G?}jQHOmg2^p2IPSz??@^i>#NnQjfES%=kk_C)>5lq@6d^bv5H)b}! z@n_%IsV>LT@oa<99pttxb!QPVUt7C1YBPNHXoVdmDJo)YOFr6rGIt!xL3>EjF>#9J4{{+H0VY7=uAp40pmga^x__^vNTUX89b9aeAmH&|r@F z>wA$t#{<(uXA~LIdd0Te)T}oUOC?y*G-vu95NR&q6?RmLv%;5TWM*XPiN&g=m)B=n zssO}k#eLhl(t6RI75=&kk2KM3i)SEwjQ2!h6-_o;;pSDhxDc6xNXojFvx+k3Kj5FuOR>(0RK^y#82UCzF8}XfLaWMe zAQQ%1^S&6=xFb(*5c^xzyar`tv+fGyjtzNfl@{hHn4PZWs=52*i9o=UslX2);fIh~ zH%o?ekBk}%PU#+ZWe*8hJT1FVAtVi9iR3PRZk7ii1(%yfu8id{l9uPW%d*D{f&XZ9DPRm{`5e2rs1vu{b}bBoK~ z7v6vpKoIK>(F58QStGxD*YS;6u7M{i*@!{zN7Q$BlBik{n{YAL8(pR5@aJICL?OaT z6b+!~1~Yo@IXpm>juOdhuknHK*Fbbkbcq8W#HF_*(>sT}@*@OXzjkXY0^2)s6hWJo z`cS)24Di#Bi3o_US0!@q%s6^PT&WVR=I`^B6xU`+ZXi|!{K4itpOu|LR#XBxL16E+ z*t+Ln{m-b=d6_6@;~~OUxw~6rJ2A3VcZ#H}G_7heYIgz&m(R09+=gnv66hTA>`M+M zry>lqVevM*uiF-lpgxwlDrM!nDbq3_6v+SEp++WS2_>i2>Tq*!#n>fEdLh(?E745IT{IyY>^h(Ik{ z0~qO%s$Z4cO+2p=#MLOBOF*na0;7yXFp{mPf~lxG-0!wjKPG@|#utQ9R4mk@MEsSF z=Tx+r^q4Aix~XVphcx(#{D`Lz+HtzEbQ`^OPH!_WA2dKJP}XW_pj`|T1d9S<$OTqC6Nco-tu%f4kZ0cohR|RAMBvlY#@r~zumOAP?MS+lc zgOxaFTwfeCZgvNag{48`&M{zNp`hk(C=O@~Y893*Sz3P~<4@KX07Mr+I~bXj)($v3 z62#16d{`NsvtLck%IM9+NZ(r-UD(OT-72GZ60++kGg36}DM;gP^WL?&S+QG*506E_ zcu9}loQr?8R@8WkO3)pPr=UN{V zbyP|@%&WM_$hb`hmR`fFhqdbuuj1Mkh#}unq7q&sI|vys161b}oKW;rgO zFQ*otcwh9YJbB=doIxBi%hx@7>YtGvDBJ6S$OqYVKT)WYbz=X!;%C){Pc-@lvf)!4 z{zeuQN|S>(iU7aZ9;zD)5T1_dw%fTJ($-dU87NFBFvsNMf%rSWWM2LUVM2L)$qjoV zpCUpu49(dndjM=UaAG!=zry^{U2MNZ7r~Q}@Q860S&E=HS~dx!hVG{o8zVgpf0Nw= z>6?r@VE*;Ee+7LUipQ62Mdh5hIh9(d!EM!m#5al>+<^1VjKKH*teV^+=}AqeP!l1h zLUWn{W3PFtfMF~u(rt?oPA567o^%EfO~brtOd`ZPhRt!#H1x5;05Rq`-#Wes^68P^ z&>#Y_tMh7Y!kF`FqZ5u1^Nh?|Ti{dfKDCl3NS+|9c2PY$Dk5ka$~cPNr#Lv2>$MD| zYX6FrS-why!cZ(b8M6%^5XuS+{f#;dYwk#I-=O!$e=ieYmJ{As)qyfD2Hj3!lpSMd zA$!VUB>7m@e3`#}&6FAc0wOmlF$ZdPxN4#Y(rS$u6-44gH>B`Ld9!BfgX*S+Eg#uOU{zroMK*j7^1oGczbPvt z*)<}VBFrh*$`u=3|GDS;$8xE}Y-!TMT+_B(n==~A}In-ZHXnaIwN!iiX@=~pQ zU;{zS0}582A?l`VRAAx4K%*?B!Yk$zMavmoTx5Rtcc3ta-+v%_8{eqBz6d4`BVXud zL7a$M_f}t(0Q;%PPwE>j%o}AhWkJVmN`xSW$crR$h-+Y-HDpts;3jPxB{ff(i4ovP z*R!|!^>4A-xiMh3nhSO#RA|mK*^=jS4Hj1SKCt4faEzk=&JmNgJF-AvyABrwFMkOT zIY{lxRJQ?Wr-95-y_J`?2!cW{ zDInWOo5&Q`1~JoB*-3mtVm{0zj`PcS2S;kPm6m_$c=!np7UE2&Kom!|+EoBH+m3*x zIUx@m6%>4}X%NwnRLe@}fMNlS=3f`JgXP6`Ns0+#@o z2F^3tQ6B--kb;O1ae#sJq*wo&%)nr$jg1g#KiU)q-d|ru4amlii!HY|Ajh#+IhJAr z^Y--@Q1XtbfmpG<`7%%i-j6Mp4==8d)d6vWlvF{W+jEse_*XTEBs|Y?K-MmL^Nt~P zgSCrZxFb(%Oh^uV#;Z*`tX=fZ9eH*3-(@FrF4?VJv`21!D>oh5MX$@vQ*slRSs-%( zDS`;vO>3#4ad+MMjRax)HEG76`Kq?!aGHPDo<47fZU=PkcWmXIFe_Voq3$ZosCdQRq0dO8yx^d|P z9geJo+*op6<`;ehOImy+mEo7M*>EIYhVRGtE3ICe4&?L zF)gYs7k+_@Ur=g}#;w%)8limO$-t#9K)26El@|e~z;6iW;D~-> zUhlzZ4>p4YW6_$8$E791h{28ubppk zYOx2v6@cP3*6b@m+lx!Lr6@ec8T^z4E31<&JI1vaUInB!3m!LXt8_?)?qGnuWv-v_ z|0%t(TIyD=&cEVah(ZoU3!Dt{9TrdR^m;Ps~ zBkK-l-B8lQ&NE~)&%GyEB6o${0YQx{P|lSZ;@VAZLS37!y{nloY8Sn7$AG$A&3z*2 zl;Y^9$0!4@o_So?F6t(V>=3YC1K=O>d?wy%&fMpjX2fEFR{4L8|97-$X!3itY5R>9 z;&Uzimc;-w@{i(wqVI9a0Nm$T`d&G6rD}q321yl6kW&x&p7H2=tPH5e)Qdd3)4ZQ; zyTF`EhwQ+7lhYL_-_I7x=omXgMz{IcpNZab$zi@KR(FaN^AR40lKGUxPGW2wJHxSb zsO&hf!IEnBR66S6Z0rFlsm<7tsmfeS%r}4I;kv6cZEg8)B-Ba=n>_d`(Ww!Y;;Pdb zDnU3}n@@0_t8u_V47E?Hjh3IFr0!|1e;d&^y(Wd4s$NG1?kOfu56)= z$l9!|8ffR@0;DkX;)nQGpjBgl!A3BBC(MoyL_#F<|U0$I{Ev z{I(Tr$>PZudBLR+6D;owRO(rd`t8sF8_2RM3MZuaLKCfp>z#Z3?7(4ZaZg;w&oxi* zbNwUy%z-NkPv#fimsYB0&76TwPZdf&snF+!b2A7?X$6916k%U9h=Ut`L5{OCMx>R|q&X+#) z==vLlWfIb_IBYK)SeMJ5QL>9Apz$lbQ}$J@v4E>={1x-Ac%(YHmMzkn-m=Mi71?FQ zTI0j8(6WJA<4U>Ssx>{J>a572QV01>6}VQjCfQDIN4&W=WSy5K?#8kX7N_G$l@%|R z@Xzsp_Vcy{#3SWveH*MHz=gfxOtkU0;IW zzHI+arnk9P<^K|T%eU(8hd!BtVD4LjJy|{$*%K?V-j~&CO^w!cW~y7$*@_~6L}8a$ z&QV0C%uEyZkt`b$zNvR!GrofVLE)>IA(digQywO6vlS8-fwWixgzyoLhNH!colNYnAtw-1F zClCJW0(psY{Olxt!C7>LPb1I{polGk-8{Bw_kU`Ry;%%QYos#Y1{sT!YRIAn-#RS9 zFz{gwH{ibm-*BzUBP3DXH283a*G*(ph^u?je2)3E^pcMPCEc-WS@F(f0M(t=rICyIu*X@vT z21{`p#U-5AF+Q*@sWzX`XhV>?f4d80bDU+3joEMkA16}l(Z%7jnL%fi4Gf>gt6RYcrMnO4pU3eni{1%=i!+R$1kqCjy&on$Gn>ADVr4?$MOEBDIR!6 zt*;HdNU+qhi)CT`d9$|s5vwYxh2nK@rY(FNkLz&_7jSa~+;R5CeFE!N8VjG>aJ)D? zyy5u3@aYZ56|B`3tXl<~#(j0K3aoXWUYOQ*N*&nIRG-i5g$QW!1eygyDQxuztkfYm z)rhsRFDxhBMa6|8ik|`>_iz=7mr=27K;SkmyZIzw40)am7L+d`cw3DXi{h1@vc0gwMRwPa>4f%c)`r&WrlYuc+x!<;Q~!;G$D#Sfag;AQ6g=4a#?GE{EIPKV@K+`I2A~WLII2s`Hr} zFUiX?#+c8^#bE~C%aeUnw)FR!bAKr)Z>L%?jhT7a=bfuw`;avMOIKENq{802RjI(HTz#+WgNm2d`}NGcDx8o<_r!=A}Oo z1*n_d+vHd|QZYi^Go9d&?N}kq)d=0K_H*d`U0A6>9_twcKSs$F>GN)C-E4 zD@NymNo45x2xQL^7+fhTci#qLK;Ct=tUvZ|QjlXJv9tLepSkW)w!9|d|I^A@PW)Cx z4eK67C5A*i2%pkZhsUZTydGng8c797qeBG0wpLhR`n)Q~SQ^SM%c?sJ{*PZjP}&dL zj+l1FX+o@Q4B@ElV?@ZW;0+P-JzRTMmmRzydSYu-xV_d?%sQ>D880i0lIF!BE&|nL zX^qQ-SlOAG0#lM1Au}ZTV`c~zr}-@Fn!B<=sAdYzW@Cg1S#9HJlT4W{n%ln$;@{$= z&}yc`7VIznrz8iXW@TJ*yySFB&J=R?OU`U^x+G^lb7hMVbkc!8s;pyZH3u?-3|WPu zx8QG&?gym=VzUM)YJs~eg7G~gvT}$WizOk}70Nb(sTuz+BzDUx{vYN42|apC1OF@e ze}sR&1#rt#Cy`J2;ZIW~ANh>e!sp7G((`==N5j!UVLo*t*q~e~}7rZCr)%qhL zH;{F$Op*`>RlEr6<*oJ-1+y%F+%z7?&7%>Ms!mI?F`_kLZ`)JLZ&4(D) zIQZ5|7cqZZd`DP=h%^dggN7Ty z8xjXY$kx}3sb=#VccxNofkMo1|L`5D6coEZ{oL+~4qxF*>8`@WhlnFWd(rCr#0k>c zngL}KwWe2DE*tL7{wzsB*X z;QEX{h|ZB0)PCM73Sc=3;6|2)q?&;xyO6-@;k|QS6)g%L{0bc1{3fAj5%Mrjf3b$< z`uzGc3TC?gt(p3drt3d0;*#;Q`9hIuVxDT^fONV?ZEj1VgzuymU#^LrnI@E8Ll^M+ z+i5POeq`@?u6jC>ZiRdHi21#xArVnB(lpMX-KaHP)gQ&D2#SBm+^k*oufgvgLc0Eo z@w?D!;$Mc}Q>kAtxuPF>>l!6*Wnu&(UBj`3*5{@B5U*1(`xu!00=!<>k8Uk}_U|Lz zJBei5i`viA$G zfZK~s!fk`_tG}ByoC$3IYW%LnhT7Zpe?D)RM*V`z)xC{yTlc8sJ)ZdP5y9_GTGP$e zYMo)c3cu67n0Eg;_ui)}G{qg&R>*qYoVU!128= zm`vw0nF7!CU0_kaTKX-pvZ(j2uf6TRf+*g<{ihST@)falqHZHRt-i{V8du$|Yy>v| zQf?ZI>+tf-YLus1(6FzL=qm?1ux(e@Xbsm&U|SB**@kcs_BQ zaA;*j`(FhtjK~75>7M@7A)~VB3r0njkKR#H_JF?!o-2FcVYeYJ24oy9@JcE0KcAQ* zVcIfQqdfFDLHNPD)CkQ5X&I|gO(?dQPdXju6MA)nMR&ZbJ)!aLsC^QVI*7~InlF-Q zKYl<-w7m+`ZB;!AQ+r|yvEF(Bh)uQtxaG?L(3!ZOcfSMx3r_~%;Itk9IupUZ02HPH zc)$KjU|?@z$d?1)!~0Ldz%9K1>`k;E>VttFPqHv@^Opf&e_|!?ehCcRelh^>U)O_y z{fY4k0I@?cOV3LK@ZOyY16cCLJJMuX2@MQP)4+gHsl?!P<67g}xN1WKef-B1HE4}n zd4P_iHEtx4(R1ERJk4DXUwFRK>hcn+MWMP3Ul6Lx>qm9ni68Rrm+11+*hx4)dTmda zyAx9t0Ah2a%N1z=j@+TTd>sJT(_Nkb0J(j-T$FBHYdnOBMace~1}cHQ2=!}?`^Z)O z-A$smzni%8txGrer;yd(6{#EJ(PD@WagtlvGIt$YEWFUO?=&okg=5(!u}oPG!fNM9{CkW| zp=h8u6!qdDI0a9^fa99$eAlXjg(mnl9(9R@b<|<8&vEFFOQ{^r!|593-bE|0B%I&) zpAtEqtu4QFFheWhq(-U)Mys!qs1%#a86;#+OpLie%vU(o6Ut^u*|GGTCtBl&*kw3S zz_|g=yD#Z94hEvP7a1o4(Qi~@AdKE#%)gs|?2NaU@;@eeJAmKr<VPSbg*_c7$A$$Ur^HjuxPHjwXHuf~_#s`8J@B|1X zIzR5s`o>f)Yji*(O0G zXrF;G6YYO9cbF6&R|iGK1QReP+$XfNpTqA4z5r_m;cGNp%oL|X(j1p67l;Qai0g2E zOELl+>)%Mkk&0;9w((JYn;nPLQ~8{Llo?Vt&=>Qj_$0|Td+d(v)Mn%5U}~f1g$2Km zeGbjo?u(5}`FN4gO55y#@8Z2XmyVd5qq$knxCLThnk@#l-;?v47|A4OiEK;MxaK~K zBAjK`^N5ZL1|%}r3i9OWW}~ZtlzdNCp6Ei{T!Y3DF(p35BVXh%*@ai;uN&T!bv$I2!zJTmY*u3OD(U?F2U3WDnSIKH3?u?J*bb7XwK6CgWb&lI6n_ zb@@z~;#9L(oRe3}CwQD3mn&778?m^SCiy&tt?qO=QR$XkJQ}2cPT$>T=tuc??VxPA3aILoR zb-YNmrAK6ISh}CQ1jClwXY3RxvE&F`#HfsPJL;YQxh~0;JSmm@4~R`Sj$?R|$-T{V z%4t9j2)df$OBM&d+bPK5Y~JOvbt4v~ImW}6&n68mRGAfgUr;vJaAA+jo)#=)uXxYT zH-iZbMBU)-oM%uzvdpW9vLF`K*szz!4`j@6HEA*5e)2H?r`6yy?~D2OLf2ldW8^F)SC@R8v&>we4#QdgUWl(uR!;7T_jUAQb?EYHo=0cd zdE^%A8qbluH*98^ycHb}np&f?u$ghLMGnJ_ARB`@(F*Ymm(r!?DXM-+kI|!dbLexi z(>!sHdfN+^5<0{TPVeTqW{2P=3|}CG{TK+{I?gIwLH~(B>?g9vCRAQ!R1^xYx`=(l zNcRBi>$-u+o!#)IGsrV+^3+L+4=|Vy(UvZeTd+r817&ub`IEudV3t_a+E)8mn%;?+ z%$JIG$;bRoUFE+yj)5?kt=sr?UqRFEx`QDIYpxtOc+}MZmerS6K4iC(h)MY^GOUIA z*zB~C5T|s@Ncg@r2vWO3^e0WiKte9J)K(gR6*=ipVlD$LzAg$J0ie)o-<$2X;s3RU zQ&Syv?@Ks6KKIhE(KFNQYj4{`=T5iHI;I=n&QC6rS;tB6l@=Q?CKnlzr&xH#i*J3Z zS-xuLi%sDO*W@C`a0jvA4;s+FQARmp3c(p7$2RcWicLaOvqrQ3+KTU8G152)L3B#g+mbd}yrm5Fmy z4R)>RG)dgKicx=EyXP6kOU`1K_T^tKK^wiMJ*zSgu$M|d#NDrejeHsrV zD_mt=L#rHCLSJRqJ=d?&mfysTm5;QR^%99u@gnh0VFQ=RM!YLM-n{2!557o`x~OdO z7@>?*JZNh+8k^px3yhGw=!q|Q30#h`O+ z8QV*&3F7-BAb>^O&$6QP;s06DKz`zB@&%rjP>muPWpc#bho1LeJ*sbEc;u~ zjsHUE9#&J`XKZJuh?DlA=;(HVY${=xft_PoB=gxov{wI5WQD9UwhMjv*q3tI`Btvx z-yB@F$r|VnvN>NO+nhL}$(%Fx`%B)@8vl)6;+WcKaHV_U$$U>~Vh_rHhz=)*^g+43 zf@x?%M-uTN*Y8BSS$ z=2HK`AxDdx&V~Onjghi3hkqQuQGv{~2rJFNg-anL7N^qww9HsOb`@Gtk zPvon4o-GSc(bgBl%3pfov+&um^3F*2pasJvs9cS3(s?eoY=@SL2GF9dc@NLMpr?cH z3~K+rG5iYrYRG^77*Eah*^#)sx$s=Xpg4s-(%upISUyO|H&*|BBf(B6UA4FFMftk; zYF-?17B5=PF|tj4C4I$mQg)Hn^bXjd3hP~_0IzF}zao>jh7Fj7LdNhH_3}?`{n$ub zXCyU9i^zcroPp^Wf}5lMa)jFMX48h$hKF~dlA>!@0n3)Z^&c#Gxo#iP4(?(J?(~)5 zSX#YB@{Z6qVjaY#Z$0o?eUszCd-;+nEK}&Wh(6v8qL~Cya&OaP6@+wp5fl)Pp>mdoH^&l4iZi{li&SdJ5@R(sfpmKI=j&f3}pz z$yLhFB|YqBD?Oid$GKK|3F*pjN!s5)vV5sZt|0mDbd_91^8NEw@)44|RG<8-N&Z*P zC#c!}CrIv7t@xiJ*=dzsNAf1OdM!?Jivr2tPIBi3Dz}rQ%cYWgNd^`C{{18;u`f%# zCdrS6t7I3+CG{%VO>)KpmCPdfvrAOcLGtwPtE7|UJcVq35y|E|RBkcJ^R1+tq~~^( zTT0Svl^sKJM5)U4k{on#R@O7hLKF1|xc`yW&J>bQepi*MBKh<+Dmk0v1r~U7NzSy& z&L=s?D!YW_7zr>LZ32A)_c7IlCZ)l|azpG5@NAX!Y^inkh;_Hhx?64CEwJvMuSm)?LvzRGo3_?o~xvP3_j*HtVj_y4zvhDKkMVw{)?3Z@=~I>P70#wC+Bh zs_we1yG6^?UAJ{N#=6VOCNq|M`3>rs!@7IFSlx;A&$IQ`U6FMcx9*CqyGs-yHK}ze zmb*#OQj-{9c&}EGev|ULi`iX$;s*p`4>e@LmkCMg3_t)4>aL)?L34U>6`8P#Y&=EE zS96b}$b_f3$4{g@&OL4-6FRxaOQc-VT><%Y!~dk~lEV^CZ!!5!%9P6I>k7){wiFAB z%zPD9M%<u89QK`x~M|A?`%-J6@-UIZBbsTVy4RPHAg!mVaUAG_J5gt8u zO!(_#*GbpI=Zsw^)rAWJxed@A5vc3|PxI23l9~jgN)F^VhtD>%;6;vUONX+2MmD*{ ze1pHX@_nre&eZF2oI;QztAd^5L>}r+=4Sxe;T1r{xDcB-+P6+t>_GHRw;rA2 z)T4J6>(Pa!=C5voO~;Hl&wT5O`3-U```;xK^TPl9w`fp;Kz^`fMilv5;d3P1NDtmK z{(mZ7B0+i(e+j3loOM&f-UU*Y5X4XFB!QC0x=uW*cZls-J#79%MEfID;9Rb$VH>{( zf+CxWtpn=bYvnM9Z<=pC5F`SWY*F_kvr@d2yUXd&-i}+sE(%8(!8+~-q!SXKFjKqh-r?<9cETt4&kqis|t~u zB;$RR;WK=06ucq2k%L}!7gq1MtsTeaQtK^8rchbz_H0jiq0h+H^g|pbmoG33R)L4h zImq&4oOqHssFRUnD&y++ z$=L0)A@l`{B1d_pWI~trWQPq&E;u}$@o^@jIGxd*$#A7JK2;ggh@)h>gC?Yf?~l$3 z)A@YqSKQ}0ypRAl-`kr!tL_xPr)|N2y1_orrgYvwP8aSCc(&J}DIexj1tu zF%XO#;P_iTvpa-j>lIOr;YYj`c>_Urv&av=nm)0pgoeE8VC1#xXe2(V(zWOv*+ zjy4%GKIB}a`JMNaUAI6@eI+jYW~k#ofjLd9X&xc%{-3L{zK$rPFX1?F3&G#FN3dvqUws5avLAuuXB)3?V4SlG@BS4aB`Js&ED6G0Lo=;O@ z1Xf?ZuVm8?M{O+G$Y2s|n@`3XK4;11OcrBdM_p{7DyX8QQMCce8ChHN59KTNzQR#k zO18)sFZk$dNvnD>nRBF52h&69PQ#`>pw7uh5f%=v#PIQoZlD}v#}dO!q?J#U$O*%0 zaFh^mL&jd|`Qs|N$J(E*jO7o)jG!Pc$UxlFk^i4z#smS(NnjRxhgfFjmMW zPGVjA`R~qibs=S{wbRJWc`og?>&JcZZPYEF@hAMo17puBZ4egAsjg4!kb8z5dJJZs zCwzH>2m5b4(aNe4Fv`&jwB8kt=A{=`ZGUMubpDO=1vXk zx?8>W)1KF!?0Id7^;#jXjXi6gl+(1vQz31?v5im1EIXPlkdzRp!k9e#$lf#Kk^MPj z7L)1lDM#+)&}Bz+2YFvgM@Efk&VT)Zcv-<8oeH2DXCqN zBN@XaV*?q_fuSsJO8>|WuiN#p-zf^8tB)P=r=`xUaFNl1hi0rgyG?H_{XIq6^pzs1 zWEs;Okz*J~DV`s`fHFpl6nO*$7~}J!Q&*N^YK>jRdn-$ilNr??F2#XgETO~t*7+IF z2>iH`V3YCisJ>4=RZn<5Ih=k9G71R;px{N+A1yFTYe4!ff%FPvyz7dbDXN&jEYSR* zSSr6!s<bxYk<(!*TyQkyoka?sPv7UG&+3N*da|c6_z0={Rvg7 z!Q*ChlpFup+A)~Lnp4fv@;$2Mm8DJ6ax-21j=Xuc(F|s-`pUG2RmndyHqj6`o{()c zBg*_W-1<#GIpm#sNV+3@9w3l>ebxU* z+nc~gSzZ7ClVwPR3=@PARM4owM&l9MtsB)usYOVf1Q{Pj zsY}&XE49_yR;zVE7R3aRu(%*@P_*LKPK;Vy$|CCXdw=eIW|Cn0|9`)~g%^|O-gEbR z&pr3tbI(1ux9x+0(DvsaNVh$tw&$zur4^>_M}sc0#IIXOLj!Ih%V7HpV33__ux&$0 z;cbORSm#!tqpWj1&I7G;V}0V19sIV4z85u5i_gyIUHWEX)TZi#(XDmPerSLE(Cp-OF{ULFehLJL0?^ykmJ~=wCl8WEuc>LtpHduU6gdwJK2OocCQm z+BM|XytuydAq5aM8T!M$X?k5lk}^yNZvThz zO|ia@?lV4fK9CIj0GuJ_bQ^XL;x~LVofeRs~qZY!w#W{A31;wkkE4Q2r^`VYK$b@oPl(EioH( z8$r$h?yokA4H#|$mE?|el4t^-n1|l5gN6Lcj!92`X?&7^A0dJBhGw#9m>c>HA_=h6 zU@qg-4nYQY2aU}4Ro_{Z*U@}LD{}K3&BS+|0uV=ng8PhXTz)KAyWY}^$xyHE5j3&- z7fK{tPZ7x?(Jr#Ao{)wY3V9@D=>7n>&E3Rn#^QA7ctX3^5`g<`xtGap8{mfSZSPxI zGZ*$q<6`PANJ#e`ijL6XAl(s`z~LT}fYw9F?+8UT%kSkx?YW%w=gZg9#-#DhAYG42E4i7{3BS}P76gh=RB_x&Y4 zL?k`cOS1Gic1eytM=nX|Q?jH@p97Y(>$A_28}%8wM5iD<1xx1W<6knD57lCFm4sVV zGh9WK=BrIcvfa@AkRq?H&3n@^SItTf!$+)Kb~ihDg(cGQm1WXK3YBK!WFd%6$C-c2 zA%lE(^1GMcZ~6U^-(UDG;`cniRs3G!Cpj4BQ%%JqB#sMn&kKvjz$)tLD!ygq8~9tY zxcggZVX}b*=5no2fxW2dRFqJf4^ll523T~dw)JE~KS_J}DfBiLXOT*MI0<}2^M~c4 z(G4w=k2$(0H%6^!YRnjo^Tu8oS@{tRg7c24OT->Js5-0!NN!3HV5vrC^L$?WH`^ppJ<(J#O%82puNUiP;t7~j$)w6F_ZM}|iLthRveN;iQ z^I>~zAKd~mO83!Nl_N&>C>;N$_NF1W+hVpsnm{T9J-)t3M5lgSr@O+T?K2CI7H(x; zxuKk^*&je@Kp8Pm_Y!31{P@ElEIZln_gn(^FpOx{kO7=v1(ywDPP>?ddZ{(7vPV14 zI;M>nJuVf@jusbd5|w=V%c_XGK@tvZM6OQdhSFP!n^ls*h%Ke84`$q_Xjm>)mrbWB zSnKk*nY4UKhPUFMfEfN~|LAcu@S8NH!TG#FJEMvxaF4#~;*?oyto)~QV0YuF? zIk!4%3JYpcDp_o!JWdqEurYL(U}Czs@zDLg)_`mqZ4UgOmi|P)XhrCpb}v=59HIr= zHSy~!tIy%?D~rq%^VyIj155RxugWBws?cG4IM_aem~{>}RvFRNZfN43qAUI)B}CPU zAqa4k{Y{10opdyB<^a6;a0X>IdD%gEnnNhz0J?>u!oS!LjEk?Fq|JjBq$NXF6WI-Y zHH564zzbKYPN8c}W&F?Mb3>bK&>wBk&uq{mCTN)ry442FutE2jpx@e{CL7djgXWl^ zxi;t=8>I4S)HNpP3LA8y4Z6w(O))`d5Jaz)Dk$Nfz^CaD&)-yp<4{3{<2Xc)!8l6f z@T;4|!W~a$7Jn8TqG=Y`bR{`SLv}N=OE>g!p{}-8uK?P;21xHPFF?s%qxvLJZ{%-? z*@0dFC|Y^L2~9Iuv4!7Dcv%+ZD&}u=?o2dwaTU9vg-lv*P%qgs^qP@gMDe=CMjEAQ zg52P15h0sN>nlY*jN>_7CO0>970IPCRg9{bxLx9VG2PHolGRuKtg-2$bPco(b3;$| zX6J^^?(11YZkgn{CS+aeksqp0)}=0HFGGXIG*!sAR|ZApFQ%UK zz>Aym75`*vtjRFiUU*m?RlW(lce+2;j^D3%RM>GD}*9y;nr#QBk z-Oyd?iLSWD%}c=i6ize^a6|8FvN_JB9;ASIQ#6^{uN7SGeoer>Gh3&-O|kyd9?B3K z=u&l16#{)UnG=)q%Qws5b1Zpy{<)m+B(8ys9`nviU%7Rh)Wnk28#oui7W9t#Bi89<_dQ5e<8=kTo|AD*l%pEQG&#oLXqKZCN1Gf6;&9~Hdt0>lXztqu z*a~1}Bl=M3H zLXo}cKy)U!fe_o?&08EOndkaqojW-Q=tNcTB+LXv-1Y8?_%7a@U(Ym^#(Rs&;3*@Y zm*UWT{8G|fWWH84SbF0R8~?q<3(Pk#?x%)QG#!Q6&HALjFrMcAiU`N7!|AzhV^Mp@ zPqhhfGK+HMXl0J3ui=09hVr(q6oRa9j~?V(!*2t>&HO&(_bI<2<%4|N_-aOY^MQ@F z<87{QGo;ZF88_tb^`!CgctCb8>95XYljRFyuLe=S2Fh+ylc`_{(8g+Ud$G5>&>iR|9bpd+NciPK6Z-D{6#+FhS~?KM?}PL z5p^^3$_-rzRC;`aIh%zKlFk)6v3cSgEvViD!B?vZ@KxTcsL<~~ovP%HJ|iGJi#e^z zI70(XeZ*`P#j9VN2ED_|440nhcgOz?qgcMVa#RQKrhTikr{`eZduad^>j_ln;9EQx zcQCpsUcEp`iIZ#NiW#mP^{X)$pISLfL{jc|}XxikSbFH~D!=v!Psscz^%oFX3s zwQtPlK26Wy^l|z92N={y76XFg)GwSeY?SgActXXVhL} z#XAghdEtT#y{FU6e3g`pxx-P@MmMxSU8a5?fWl!3CitnWoQLUA9R!V{58n*aUVv*I z;0-%1!;iC-YyG5bfa>D^=KhQ{uE;>Xma(4X&qW!Tw@}lMFW36^cAn61wJ94kcSDW= zK=q$6j?h7;&_g~}RX60r$;OC2+7s3DMFNsE^^=49>Ns3eBq;h8c_tNo{N8wB@e2Na zFX^%Ul2)XXj>}J{ebA)6$x9pRTkO}P)dL%Ql^S;Luaa3P5DG4lG%S|5u#oFEUE@Zu z)dHtmS^#1YHI_^m*N`yUFLm=VyE`9)unVwnjP^?%S}DZy4v((T74%%1E~BE8e!CU zXoOMYp%F%nhejAR9vWfPcxZ%Ce73Q8|80ZDO5^t zk+4n*&itAw9eh4F0=}Wo1x4#OpLcZl8a`Syl(9XlRPMah*v;9hmAplW*GB}7aBX# zFW;lqIAnn8s{rjs`vxG$?q3JHANJ(o-Z}L3_hx3Gy29%SXVY_UQ!Qya3r~55`sjn` z^rWMSIgS1F#a5DQIQ=E?YV0(osCCp)G~jX`(D5k4bUn^7uh`%=gZFWv9lV%u-JbdM zk(h;L{*+teW^?=QuQK!}2K`YEX2)$A7?df>JIvl%{U@SCmtg~#9e16UjU951aYKKB zK(MtK!wqMR>Rynh3e_z;5masSsqG1+%T?da#uF~>v;@p-Evr;rZ7tbY!W#Fk2T(#@ zGhx^xhCr>j$k2`E{eWBu#O_lABkexbE}US2%#UIEHtmnOTly`3FUG4|$%xa>c=b%< z;Bdtsyii+7=z%|ET#@`0W-RaUZ*OeID4?UoY1fL%^cA9i;5aZwi(HPR zizQrrV~&Kb|1p&`!ktU^&2SW!K1;yEB9Kv4nE1*e5S>Naz+F)?mfd}mSf@UC(2D)7bQ3hW20VkJCc z(b;F6b=LN7XL)C8|D5%SiG_)Y1&N9ITx2R;jTnAr0FnDd1oGLF6oMo8Xk zt}NL{Z>}jxo1(Yx*MM=YpG*=$I{qKulWDAU0NAo@1k-rDX1x(TvaXf8GLFXWS-oKs zG4rI>K?e>s4#X^}J&OE3Uc7sxSQ2dY0=I1ctZ7q@)E7B+#4jEu*k)wUM4M00Qgx=z zbLpNPI3w;#?Qm`^fMQ3Xbl(8uqZt4jugtJjY3yp9z+9|Xzx~*pQ$jb`YUuK&vldr0 z>gYL^h;u9*qq{a-EUiV>4`pMrgxj~FXhhbvIcu?@P!P>o%Y!?c`|5i;k#BM$xj9+R z>0d>vI-5?4ly>%<(|;%^!Yk7jxHdB+?K%O{323y|dA0jGXoRyo_*i5Ik9FpjuIL#O zsd}v`&smOcQjZ^1veFkIq=Qjd$5{A?Xw|BjH*$liYE^KaS}#gk7GJiSru&)@BGNJJ zaigAiTATuEf~J4Fb4>rXuT#S+Pi!6=iT|^uZfX}glw9=tAV+f_p~5Sg@8j8ab&q9g zNF!jqaTrcG!&23cVBFlgse|>vP6b-?>?Bbg7)3_fiRO8IwwEw+q+y1{Gs?erS_!Z%dN*l#6ZgVBve1BKm z$hWzHYJ3=heWI<@zZ0k3Ni+?H+?H#bg4DmTm(M(IIGuvz8Cv#oYAuGTV5A~l1IWuK z(KTu%^UU27t<}2*(umfTnp_?U?MLw9JO4F%YSTHbJM#uzva+eJb?3N4`Bt{>9CkF{ zLm+L(@ZGz0r|;NHxb_x0?|g0N{i8$&!DUVu{D})#-}$~ukiLhc{oeQU^MJSR?0M;z zRl!>yr;fq42lyNB9H=RF)30$`%31atrz!Jpyu3ytfwd9|_@6t+=9&J!Kjzi;^E0$0at{p!d6cwGG#OEjTaG~G}F86D%#lwx(v zw(EFyBCiiK^!tPU12c3B8$OR2D*dlCGqeYy?%f#?F+=aUdB9iqGDGWkPkZ8KEe1l$%EkZs=%NJKxaF6TJ z161g#jnDg#^3Zb^vZY4cb?UGt|MU40{2(^STS^t?^z0X(g*M30_^f;%fL8`A^7+;d z2u3&d`0);$#T+v_k~+oR1K61D8xys}e8kA9WK&`g(27#F?2!bDj5CWb6_2Lm zCqznLfWB%Q*(fUV^Z-LeG)8&^HpBk(%43X3IU`gW^a5JM1%Y{;Muw2EepW<^h00fBVI0pErN3z2Dvqv0Z#P;2;;X zFMjJ=(AMLA%X;_4W5ianYTNyQW~1Z{W&%R+-O(GVwC7*KmPSH}7XaCa-rulf5sl#K ziuoBl4P&+^>Ca}H6RWJQIUDMo4CKlu0gq~hs*|?kcq^LrN@6dGZVjtjFYwc?=733b zVM>hK@34NCI@_6-Zm44i^-1_YKTGR@IhF}>Ec14m9+zIlQq_#M%o=la|LdQm8QzgY z5USt12bG`tGUWO`0z4Hpr~bu~)D_2IH5S|q%_9IN=#I`r;B=FJ;ATEW zL$ioQ4X!gmhuEP1vO(9_po>k=U>h{f23=}{lrQIs+f9at*`V`n(1|8!qYWBjgU+x) zr6%Y(8?pc8D6-vr%cgF0+br49N5pBuW|20dtljv_p|j`QVi;d@7?fEOKpE91U*7KP0d|*9)G@duD z=RxCHBah=>fCsb zS-a==z54B8^IPNP*U&G&*MKJc58C`vM|qizN!#CLeD{m7AL@%QD@6N~p?gezn^NEI zm1%FnKZT4ctB>bz6Vm#?oy2iNuPFCq;9(_5_}Ad${8X@nf29dRg5!qvt|+7?>rOK) z+U0I&2>yE3+9DLJoWPU7-B6O~Jr~-e&I{Q;Sl5FYS5L-u6h}`s^tz1exr{4^J&z5o z)AlFy;Bo3t)|6){M$1nTb&JUjgENf%$Hm8}__O)TL_N|3VED)l-GLL?ZEdsmEgkeq z&lTyV<}aMEr3z|TZw|}RM%$lj@9lB9~KbE^bpgmzOfRT&7%BjU|`A zYZ^F#CrE2(0_W2vLqip6$hCt+G$M6*$P7r+kE|Z;rc||!Zsw;G zI5VAn!hfEr<-p!T!W43iS4f^$$YGQK#`VXLWftScc_nO?ke!x_qBw!iIfpR~Ncg`q z2QxaK@`#&CILa&GL7S>cB|x+KmoUwi;P*=SX}=O~?JZ$}DdFV)CHw>VmpZDZPYK_{ z^1-%*r6%sC)bM^K9Nt^PSX07>{Po%ZQyqHHE8)GNb}0JJr%}7N<cqMF1RNqUUb|Of3 z#=5p;Cef*x3G-0K^$84S5P=RTs{}`fcMjT8f-Xp+P z;-o>Q66xeq`Xmp1KrAu8(+!z=?o-1jeMVEr;awBvPvLVz57?mBY|z^_=nWHelMPyA zgErZq(W#T?y(7MQ(5_@@|U(}0%vMkHrsp+E6So{=b#>}Bbx zSKy})HIQdfwC%%P@b=s%=+^92M&OYfdifk`Vb~`V`@&4@muzg^bCnXFxy(ERy&)4n z<%XU%4#|s6D|z{L<4i+D0w)vM4NX#DGH?za zy5vTD>?bTtau#6M8d#Zy{lvn4Y+xfTtl7ejHL!dOYqhXL@ueCrqan$_96$+wSdc0U zxx+w?7UU2MdB8x51sQH34;#ong7__Dp@9?#^5u_B&Mz9scawm;XCdz!$W}pKv5>6> z^1dL?S;#g6d03D?S;#jA@=HPPv5;&;NeTbmg4_gz9!>Zkz!#HD`WWM&Ukh+(713Bh z9@yV|go1hD&ALOjr)M2g7k!A#F+tgl8Ogag=2X#dBqj>B^?-D#C(q!|%O`RX?5*Q* zJq101VGhQ+Ix*V>hp>x%YtM0ggiK@ENfIMqB)x8^6s^ym;TesOVjGG+(;rD_kb6p_ zkUP;<{5yRSyi8#(;C%$IaQ$M*^X@lFITsh1sIsNu_#-ixdcvDDD`pUBdP4z#HX~G3 zehW+nZN+VTk<<Gquu9G0ux|zO#=69rg$)=)Xh@t= zbk>=5$v@rA4AA*gF7X`y$Fsay)LuqLNEo+p-lmI58=C5oKBi*Hr&|a}-B=-;Ef^XU zxkvB(mCQPf%7e)&KNeq;ow~6d76~a`Bd}HNN0QXnE$f4=yRw+2%|8G^9y_i8b(S^! zMY#F|A0eV1IWE&1?%{4-18Uust>_04{b3V*iH#RC@#qHsZvb?^Y@+6*bH2|+eTKi} zyuhaDoAZMvx=tZY&c86xl|MD;&G}XU-AyK{>{B!!;`q<2lFfxee?4E~Rs^5%H{hIx z`vf|js(06!1iH7;Ttduq$t1YYe~mtcf%Evx?cd71O?+LJYCe|uXY`9d!N#AIY3-Q+ zOhGh9eWXoq>n`bWH;lNg@;gotQ^!Jo5VtbD+;okgjT)5+KR}5~0!rujE9EgcmG}e3P5%-)1UH#Zrw{k>qL{v)LT@(pT+q5}u(B(2{6z{a z^zS^@>$$?fcQ~ozATOCkYt?W<&%wmpZi7`n0ecbeGXhMF!}03h9L$mxY`dA7!&isJ zT>Rq$kw$Z1cmpJI0WlUAGR@r34LCLDjV6#l+74~a(oEdZdye)`j?T(mC-9Gxi0!=P zhJLLKlYxKYcSAoix%+QBTqH8ES#gjhC#qWkxS=x%m9}a1$7Y8Qa>$lx=?+5;`q(>L zm_0W-oWx1_P9F_E)4|H9dM4XU2CNSy@-KGx1jtYoq5t*1O;8a-x*s-4 zqsddVjA1Ks9vz$spbeMZx$Rc%@F=Jfo)-0clS zE9RN-<{Xa3qjRkXvn`7tLMSiSa-{V03c98NvOgl?tms{^BEi}fw4|iYeV>5|OIK!! zMg<1V+>DyU-yoyH;QM|0*lyqb$Joctz64I>$sq}%6_b^TO-K)EDQesx|uHJSSYFTS{` zi*|rRtY?Q3lql;yi!Nf4{ES@P&=vgcS*RlaLZ5yAjQra&I4Ug*J@ZI2&eR0%^k6x} zQtDy)%sKhp->IOD-7?DI_-~{R4jTy6$(WU+cHorW&(x44s_SXrmm=;y1c%$BN2Ltc)S~$gZcp~Jg4WUzTIZ}_{wUfXVAs4aNfopX0C>E zJ8QjdySYZze3s5kiNd9=2M;7c@|F&IBz4GZV14qIEpm^N+quP@g-UEd=dV3L1NJO` z@jPcfFSBumzgT7&whXK>pQda{Z8!_kG zSn^3tHETbn<;1M!lblzOi%`{8*UZx);ff=g4s}kMv3=7%8(QAanY&lLb9;KS?Wqyx zl$L9nh6&`-7B&*xRW|Lc$6A)E${e9dv5#$17;dCy=Jt*ItZ8{KXRc%06Hm7%KyKiU z_;Idzv@A_1E%r|Oq!0+!Go2!6QxG5h`z)o=inCi9f&Nn(`lV&5^Zhge{iifJN~5W~ zTR8&#r!=`r!&Q~t(+KpR()g9;mhYz#=s%?ypftCBKaD{DDNUYb-5bG8E;eS62?x{? z%iNLNNU}v&YB2hc$9|^q?*P5D)_PP;Nm8@{EpWSqD@k*38^g$!5I91TL*t9`MaD5OQ`I63t|o4dgvMry*rDfDBn#t;!3OS$Q0hm$AQ9~x zi1r8MKuxg)u_G%uPa8z%^a8A(&XqV*z~(*TU;Bf%vZIwZTi&eTtwMdgIT-1$S|7Z% z6>k)iTDn!<7)iFe?|N;iHA;Z~Or`W*j8`e;HfxZ{WK{g?>>JcUxr%7C1&{BI82_n` z!`i$G%$`NO!!q&q?2ShSv^|}1L^_XcdS1o$KJ^%8ry%`W~%C0nKsVu7r8hS`LW)}->8lT5zgq1 zY^9DGFDvh8G)tL3{F7d`2T1UlPUbmGMHx%OVUb08FG?HQk&2C@cpx2BzB$#6{3P;t zPV&rbX~A5xDbM;KDV&d7oc5x(kM}IRoO>kCwCdv6ue0g(Go-?$Kpy(%$|nxc${k3FE`qTO|%Vj(%vG|u$g$(u!#q$T-dm&wQ5*6 zct@AjA4|7v>4#e3?k%1{w#ZS`jJ`7(d2#C}EmRav8A=SDd@tCk1rUyV5= zigk7uMRHb4f3gxoF~NHNpsP{uRd)%m(jXf<&6I2!U?9%c;F8aVi2j!`#qQmGR-d!Q4}@(R$~8d~h#P`pOm%1auJu;q5JJ|Y$M zs|j#kW9}=~6?iO?hgl%q&5%5 z-;+yFy)K4EVYs9nRJz76Qjt=PPZ<|uumYvKqNcTsQW5jW^pPD$b?ppIi&^iRY0*Lg z4{40NashturR9nYzD#G;6{>>{l4+?IjH1wkL3qzOiA?`PdFm(Fr1@^BNt;xP844Sw!pQZX3T_&iFZOP=z&q}b3)J8qgV8gW(T z+)NiWrV6P{x?gr5tM7Hq0j6tKd0oR(G2a_22?;tVM#4kkl(Zp*L`;IeooFY)Pd)8A z(ZnfkDEJn$8gY=O?&bHCE`Jq+njMw#J0Q4Nfpj_zs4{*x{-(5Ip1@JCV+uwn6DI1b zJ4|-KE>4)ZZfMS%WIO>{i%{PU&Bv!HZZ4qy>ThO>FQ8&t`LMT$_1;+W^5RYw234Dh ze%Ft@iC%jom$0>iFn3AV_6FMyVhTa`c{A@BeqH?D;`a}JD8Xg9^DS9*d_whP?K4Xn zO_o`1W30Nsm)FviSG^w}ZsI#8j?y$%^zrvgSHDdI$&uk@PwR-Co8IA7CTX=??4*5C+6BqffA zScy$jZ#aq`aV8ARZJ3%nQ0Da40FWilwvM#p0Xg6%+h4*lHuy}v|CvQ^oRQnj^!5K0 zX$arI7kszBhlPvUJpMEccWR0{KQ4$=y%9}Z@`Ffl+#8V`EC_c*;$5&ZH6xK@Ad)HLrF9jm)k0Ve^kG;58#UyR$tAFSrn8?gStD zlQku^a|;I4xvP4{@Rm6hQ&>lL-rNGN;CJ=xKW!{`Kn*nCXmd_l{$=n2^f-s)4#4DS zF7KH%u((>q=PgB2L*+G51no+9@R#G!X{R=^> zZP1!8gOk<;CkB2~t%Mi6NQ_u6QJ(zwsl)k%J^lUU|J5gXL2zO1qy3U!;Gbpcb)NsB zN){^h zH;~*ukUb2ge_xz<^#rt^wrr0tOfW(x;jc0)h?(fK}gyKY>m0_p-S26p63S zj%@49$8IQAhS$f}=HkodM$G!)!sP||!G){w=i-h{J+mkn)o6gV3wf_?;c8`9zy%ru zG?+TKJ{v?eev7C8(h)klbMP5tjn1`7A6Pm(QXI)An+&;H1YTk8yT5Ez`&1+Ekj-do zLOA(Iu}?xttk)S$5C4l7d!(#=D+hP=Q%B#<3d*gc2Is3h zKQYSNb@d#J0Oy;aY=Mvbi1I;jL~5@A5Zi*OBk$TtT@O-E#MBw{J+Y6NBvbu|P!ewd zlF4wn5JRPAi8+Vpl&Ny?ITPUVAUqX#Ba5Pjq_`yeU+Jyu{DIfpRnggW>@ESHdMVl^SPelQ@V0F<5nvF+c)uX0w0CM zHGkE7G z^+xLZI1+K*5R!cSvTecp>|7YD;4OMaynGvrr53h2=Y;LZQ-f{C0EIJY8fH0@pQYcM z!h}roG*2?SPK*U|*x`eXa5qdZ=y|g~(p@f)GAqQax}l4RMGRwyRT;zxQ3myH=(~Uw z?Fs~60_0gBG0XGMb3)$@#UP`z66tOPiFyiOowM5R7b+{k6+|DM`Blr2?;e1B_wGdK zB}GXVbXY;JM7w5w?e`w@%kkg(13O0ta!E&kS0vs-rul9G@Z_x>^nGgTbCTlTx<&4Z zayz%)joT=HF=ca!>V~!rQY}N<&4&#BE{D6Su4-Fw-V-c^x|2~zgg1dR)!E;fn07{M zJv0;DNs9J}n(g<7s&j8~So0t2cbfOIiq2C8-l-A7?QYJ(gl|R+>W)5?@$8kz8PQ4~ z37zbxn+rKQ)o}dpT$tISO+qtc)gN>ow;i~s-Y{i&u*94gp8Cp#f(6?uVKfYBD8sQhTbm@T3F_c6*e+Rc zr1b{VL^|Wik?a$bp_zP)N=l5|o~b$S%F59(@9tsL*O@6!z@Ed5?lNK+ZD<40$|u#z zVA}u+F%PP$GzIPHwJ)yr1>5!mT+Z`c^VPQQLHK&l8)IEvP#PCjtmT9wea$?H#U}6# zJso>>jtmnw1;;y=e-(y*<5p1ft384G9JgzZ%9R)}mYg#JC(-MZw^+$OQ?Widrw}Nu z8bGU3KbrmxB8=vVt;>{5BTKUnv(5h3zI~g0>)%{AUY*J>RIS_TCnwOx!G{|rC`e1J$Qt+r$oI zVon7C3`sL&J@ocIUPV#^O(mw9O0@rszCq?|Q0?<~FrT)WG`$T8w(E>4zD&){nTZKq zPG%SHccaikh``>e?BT4Yfn9S(;$s+n4`(-H%O>#mU*`K#LrypHt;-_u8;1FsE>`5O zIYsG+`ASyo`D`0`lJthb5*1I1FH>h{&pgeRD5Il&O3ZFPoKpAhnp2|WMe6Usd31D7 znab$-9p0z!p#t+8O$8`N5oO|-ka9&tdKnmtBXxz1Qen%H0oUGgs%6@h8y9m9Q|iJT zU(b;0iv%J=fn*hyeD+j6qisIN*nD;ot2ZA;fK1AiNu$Z+8!r=qWFVbPM#I?Jaa-&Q zlX!i67M6nc(An58CJ`-O{loyUrg^XQU`5|fE3}uI>2m^NAn50cG#)h-dpM-=2>n8% zZ-_)eCf%0|mxzVrLQRAF&Zwq9hGGyzCDysOH&O{h8@svP=dWvkX{C|GO^Ki{?)^x}a8R)x^1BhuJ76DXA64ZkSC)r2~MpX{%u?AzOv zksc*5^llxQ+onWF+H=JJtO?~E+Fd=Yrt@83zV%qNWbJtWW!4VP4z*ldaDG~9oxcAj zzZ;A5`$8t7!`iA9-U{zX+=)p%0@p@1vtYLfl7w2%PyNBtm5ex091mGU}6rqL0 z?&)Xk(wK%U0-IzO6gyWYcT&CHsbT^zm@&8xvP2HD6MApDywuIMfZfWaZ~j11>^>P% z_L?yT<%UM%;~fVB>sQb86026)`-|ov75@JPDo|-`#qnY}UD4|1gmZk&*LlLqp@c)W z**h2$U1q|eKd}-)p^Po*+GKt47}-~{&*2R5|K+ekDa{1*rDsxqxEm_G6#9x+3bczxk zgql&P5*OLy3>++Hm%r4DmO4UlDfwEq>om&L=9e6ds&o5Y%go@M&I`W?9`-7~<%yq5 zl7+0k%=AK{Re~%JAwe%pjr@&C1V1P%M`O*c_QpA&z|5wce zrAyFLVf2gmmH(T@jjZ*dy5w!z7g-*b#beTel9i8tPBYgW2Ngjm+|cO;z??2J4%@SR zhhgiQ-eE{%gt=c)8Azho(R@Q>kaoX4h=Nx!=@DGyGk1V4?f{4ni>{k~vA z2ItBQWM^vMyR@Qc4oDQRF|`ic$2y#;h~}Vr>C_bD)L_gC{71|uP&fy1*JGL!gLr*P zkJxtfl%VSJSWRx#`lftYDgm-rv}#RLK4;QV?290_VILMPtr=!ck7T7QIc5;2wZXQ7 zRSQI()AiM^*;rpeRm^!I_4B{xqP}O%t}HI1v8XX?3*_^ihdD-2gU7WwpOk_#R@mFD zF_kk5a?UKwIWwOJly)efW*8wF?c~_cGYYjl4;mczD!VHMcrnc>kvR$c>GMJaTPMSN z-1H*R`0wkv9&GtB)@oiS*%_G~R~TWrIn3m=(3*+RxP#v`SR3N9CHXW`^mG;Kc#PQz8n`i> z(g^`7AcSSn(zV{gAq-TXXdQM#FPT2m0Vvhm$b&}UZKDWZ_hkr7`qYnFvB@^2)8p+M z$fj&4*cSAv5K=cUwV7(Q8iG=ZpbV(&^(kMg3Pxm(l~ zM71v%*^RHAEjO@r>j&lf@Q&0Ef%g0$&Dx-M0E2RhAtJ`g;Sx9i=s6`G+XvV}!P5G6 zHb#?UTalAc0nZ3Ty^PCuEKv+Mw86rsh?JlN!i|Y7&zhK*_Cj6;f{}*7vBWYHFY#*= z$g0RR*Tx!cC$NEsl(j%bdeyyj-eL@Pas2QeYt?*;1c?rA^pL1F55<^9UT2TU%r@rl zcg8sUZm$3n#7OQRtGroBg6&#aQ*KbHUr9ZK^sM_vAWp+oIWH%gUr98)J|3%Q6<`>trbF1^&|ER~`Jhgcu* z`?7Le0hUGVX?e17EAp!)dA`xETgGxRyU~}nF!JB+q(K{_&I(U8;Sq9LYN#>ecG6&t z-)W5;le`Nyiw3%(qlw`({4>_ITzE}`|6v;3LxVq{!OYLH?=|)z`lq{<l3(3e1cvEF?$=3aCqy01jDhft$ zUjln7yibDtbAtuZK^H(OsV~?Lsj+G7J2QhF1Jl^o zypKUUo|;ah-M>M&fk-5Ju_KLe-y8tKh5u(+_U0lSyPB$lV|B@i-+d3ujMVdcyd70rRrdUqL*lVVH{I}O- zdMnKE$~NKvF*hhCNOP+pZmEgeRO1c0x6>`B8vi5K<_i*7-7cohx6k#mHU`hk{pRV^ zC#SbQR4<|t6lFg=Ryo(Mh*c1s)TeM*S`i;)v#3msF{FoWrqi)0+9CetQZww@B7~&^ zJ*9W-Pc<9CUK-Uq_TO6}|GQ&9dDOoh`+C5A#{Per{cdBw@F_YS9Wc1MQdtj#xz_44KyPUP3_ob>Ijh5+wW&Y-Qq#lOcqsA^ z42eJd7ggXSgbROs*wigG4lzWcGnp-VnnD;(*c~0B4rZLwfBKe(-U(*UQT%%aoqH<9 zaF=ucRRk&KcD9@_2zfc?-LY@qWX*vX!vdp>oxPo@Z5vFI=9eVc%GAR+jiAuh3(mF# zdD5pkw}IOm;)edKz{o(}0-}Ee771blU-~nx?D7u;VglpRaqatWH~!i5oXkxfbI{j8 zALgQ-OIz^wm_6fP0|b>W?nFDGM{!Hp?;{)Zc%Pu#yr8uNkzzn7_drb=K9o>r~v=-2lA|Pr=VOdXfFc{>y&r zr`m7h#r8Yl68oJr&3@1Oq5V#|)P67ik^NqJrTt!hmHkftvHdn(VZSpj;~Q~K>2-U7Z#v`T}wJocTYx$Sl6 zj2Sa=zsD}L7XdY@Tm-~=@MT!~yQTsw!uGw=4AEr1VP7JQ<1CmGd=C)3i;$h+^#>y}IpNV^yoK z)#GpH?i}RZ2q|F+V^K1dfp*=~6XZDRv5jWgY{H|3E~8##qIG|S$cI7EZSGVz7IM?c zJ^486F2`?Fp?w3-RI}K(p!fW+nvclq22?y?43gt7fIj|7Kr5L|jz6FC6aY@>7L&S$ z`#+23GyEv&VH`R%!$41AdwS-W)X*LcHBl0GD@wX6(LZ1aXNdcUCG($uQih6zIqCSx zbnH9wjWp?!Wm+Bf^WfxdQY)~0n2>BrL70 zTxzlD@)iRT(9=y!f?uI=(gTe>MIDB;E?Mg$usflY*riBoWsP%+EP%jBQ8k2(*PfTG z-Kp<{WbHTl9vc5Pr^z4xc0ltK#J;69xuwhL8f!!IoK;^259`Ru$?4>2!=5lIkEJ=K zoz5w!Sf{OQni!?4OV=h&$?e(Ci?Lg9PEBsk@3$aEbF!rahF%)q_zkmpevMhw zCha`)w&eRL?GUeZrO;7_qUW!OO|6}+8yb&m96`6a=4&@9<*w-53}KtO@Hr{-d>_`r zI*sPvqJMca)M)-?r|6*M$QQ_iR>9G3`p0flGj-YuY5r~LedO>|>QwLi15wRvHHAjp zktNNb*Lk4&AKZV(W9kTAO{!aD-*UPor>?5QlwZ-W{2NtVa%6`w!L9Po`Cj?2EVr76 z!8B=j`B{~Z(5S0Eal^aL_R1S(2XFZpB8<9YU2=AQy>r7=QRnZ|di76u9-Er-6mQ^T zpGNPs$fA?VB!()duB|t`bqgM};K+g~T|^=FKO>9E0TUVfH$>aU?e}2Y1;mLswY-7n z<2dvYQ=MbKk z823$N(SbJn6J)6-yvl^<5k4r97g=Y-yHvG|a_%}G5+92UW z6XWtDiw?Ho$#nSJCVVL2!xQ5QB8!f);a8-?pEcpbv1gwcR}yi?RV2n?i1tDbTXm_H z^*6t&d3JDKEekJ$`7T)PG+&1X`CIkQCBi#Kvf-*a=dIL}*ISxq=78O=AzKcI>khXFw#6}DcO0|Zvxu=V&OzI zCb>?J06Vgjjlk^oHM1JD(=NnX{!WfG9qzMu`t?ptZp2v^e2gpFlM5T1Y)^DupYzQ{2uZwpU#^Rr4H6y<#AMN5s)H%y9Tw&$u6Cx91sQy-H*U|dP zYJ;u*S1TA&akTA^gDuD-MRvjs&K6nsMMR%iBo-zHHpum%bhNfuS$kGW2EV z`vCf~9;vGk4Pj@jm%d$zwseEDU6&}N0H)^GH6K>|*!i zd=xs$gl6p)+U14H?oMR!(A`4+KxlO-z+n5|h!9Q2Hac%9bFE&}Q#UJkw1V57H|aGX zearq45h7JICfNRK6Ct!)gqR{M9u727^J3qWN1A}WO~CrT0ehK%eNDjYeFMJTPgxyk z0yg#y_|OC#WCGsq8?ep<>}LYD^bL5z1nh4D*a7wSQ}X?4z|6A zC$d;mqi?EvNL8Hx7;Nt#f|u}VoZ8RE?7Q>WwY*m<13d6fzA!cQy6ez(AF;M|76sd+ zbst>vUcuFSZ0igM+uQNBU{Au=Jd3y5w`3W7X}(&9($4@X^qr8X;o?NJ`0PZ@>-tVg z)NIuE!bHv6`c6sIY|(deqUJ+=&r8&#^gTaO^NGF}Bx<(mdl6mDJ&a7>#-^@{U~xfQ zUwj2?M6~L1DAv4dFp^b^dh*m-r;GDg=zMBH6XdbIqxk^%sLS_&kCFwYo>TF?oS!}l zuSY!r{&P}TmgTib?E0G)33j9(i;M_v$xLJsd31GOezeUOD~YM6;L@_RSv-tqPg!#?DaW+ z`#x0IZJ?VibVNGtYXKE_{N#waocdFo4hqGIvli9;7)X zx3+3|Q$a0jC?$CUOrrKyK6iE1-ozoT4q>~xYH!c-70LNlSM6QUd^!KoRr?r=9Bby2{N?iufBERt zk|V0+%vTm`#3kB+plF1r$Sg8v-GsoJcV_O^riPcojOom!_vL{_+l>89_d6Cw^Q3gc zLTxI#2Qg62#9S*Bae}h_pxii@GkG9owX^86Ou}I#G}Gi1VvvLG2s(NLB>334Tr4r1 zsROvOx@2uuaA7PfmJH|49mvZ)!G(>GJ}Nx-bOIW8dG2i7-+6AXMUm18#^TF!gO8n- zD=wxiTGcsop%z%JVPX1Qx;OQd$va0gIr3wx6IGQPwa=c!`|flO)ieF@hr84d%;*Jj zaOrv!^S3_T5@<#<>c^qU08%GDEhZ8jID4ph;qS~O)$pgUEo3IDhc|uX_sLP?wgr7l z;K|4XVX-)c)JP;l7~wh`X}A~iN@Nj&ZeJ>!5HU^1BSc(u7DY@;_>U%oMdm&dmN<9d z)>H+)^`wcBKLvT9adT?9~0+fxuryb`xdz?t@}2)WoQZb>&jDiWpGE8 z&m`;qOz=GGE)ZPr_Q1pW-y=X3zGpa$V8Z{^_MorJe=)#HUm33PxQ_B2jVp?)+&2c- ziMWpO9gC|1*KxiIT<7A7_|C-DglnwtR9w?=)%ecF6~-0yos4TAT(!P4aFyX2=ZoPg z#8u}z4ObDa@xD{Mc=f(2TqVF7e23xs}sjz z&iuQ`40fZLXV?>EwzJhicD{PYAY7~r*qnIkc0qA(OuyXtHSw9RaBl|~omV$>DRJxr zE6zHkaJ)YcAd1}MI>)L9nkR{59U)9Tf)lstO~tKW2G2QW*-&YImMHzX%xJQez=~9w z$DXuL=l9?BO_VT+zP!z7OnXnvY*nnk%c_8iFyfexiNG2?`OTnj@m7G?U&dLBSu3h; z><9|VLXdj+FVGxb6wQc9e*Y&C>vtlHW*dTOEL6oDE@J=I8gN>dYG3bH=HI=cr5}60 zpW=vYpA#iV{vk)PeXh5oH6Yv-iHmhnFiQ;7HCFnjxxW^C2E1zEJWj(;|tsJ!7W8GfaU!=>i`HD1@QNbYZ3lQy3}~tfIM;<;*L-SM^BxPd$}Y?2h6E zrdI3NHivWO8HG@sF`}u#Ip*Cw0QJ%U2us`ihj&Ub#v-U$K0JgbMVaaazc=jHW+|DD z7yX#Dc8ukBMx2F;T;@ja<;7c>PlZb7_`fYlvm6K)f7%G>3rQ5G!)Y`HjQUd4`5@}- z>M4u=l$UgtNmk4oP(S_mZ$QO=It)DCMG|xyj0hR@nHH@)d^#t8!S)Ynw$#KPZ^Qw2 z155K&qV}65KF|h!;|I=>Iy&~NVmT@$q% zH3R+2w)13Kq881vPv+<8K&K?!f`|g{0DLu%UYVI1dWd+~>9$GNi|ZKOH!_h-WK$z` z{1NGx$%e;ypO0aH=>7IH)+v&XU{$|@3@xWK^-;s=T*0DjRM22p$I`~G+PNjB+32Lr zrRMVzwU6+*7jcOOn|G<1%uelm=lnaO&K2__rSC+YOYV-AZebLr^jzP4 zbgXl7K_s~3pCb~rZ4#%ST$Z?LCd^#4^2#zH;S5yBzJd5eWXkhP5#9%!mJ$PbJ3c3_cV31+H32AYh9kOj9B^LjL%~^d}5YHAUQ0h0(KPU`z+Qp_%Gg zYIkWYag)(9=l$bXwL5r?ziB-P&Lh;xW!uu7{2hb_W-y;d>tbIr)Q*T3do8q8?M^mk zCCB?ybK$a}S#@4EjOvnd)`42yO>{#!yE6F`fQ`HH7TyB~)tdl#orS+9xU>|Vlf#Ld z+9=tXqubtzo96P@+W%vegw9qysC+Yn#YizoJPvX)<6X(t_e=u5S+MK3(jgF zm&&moBM^aDpg_hTLSeqaBiCJ98a(o~YY%4isckXq&N&#Gy0W1yI2r2^hjA6>oVD}< z&Q7|)91W$$K55$Y1FxIdKd|ovjSYU&bShJ1Ft-(W&#*or26~Wbmr=lCDlr?s27rKe zy-Dw!^dv97-mTreuqw`{_rba-od+TZrpxsa{nMfovJwD?E zU(=pa!O5Nksk^BKB!UhQ=rxT7#FF>V2OLX2Gmj7JFwK$aOuy66k{GP(d$`&XgBIC@ z4Q2rtdbbwkd(HC6#$WWkcTdrOJuvsL!ZFA19tdt*9R=jK=qQ-er{7RlaBQ-sXHm>q zs_BV+E484it2wGwiRL2AUSJxPxt4{f_k#YAGB;FjAUX>pb7Bp4T^kpiRvMt&1hykSwbSZKTBAV(Or;sEZ_TrdC~XLG&-? z+&)rcejUB}h1l#6R}hn5rhHKj-pjV~_$^Wo zX#J!}>3BEb0MZzFyapS4$1tujf-rUfc?cR-Yg2vlr@56+>>y#&UR=GZtIBI09COCz z*Hw+<*ylcmwyw3Ki1e}6<@(gM?$}c3^UdlqnkrYGW(0!m%|b^fa2J~svB0uc#+itb z@r>Z96>N-!CTGaeJ->k*)tD5rk(3Nwx{1|U@}Nn?m9XrzOx!DoD^!5tki4k7pf}lB z3k-|Uyb`L^Rl7i>Q^tONCu2WPWr|jIC7JB@+bz52Oiz(L^2+tGuG-gWnoql9n2hzq z_{0*;Z=1Zzys8ys^4hSVf7OhwGfiQtA|+IG(t{j*;*miP0tczMFRx zr)4Vg`uz-I581W;Y`@03=-JI?oki{frLC)w*gbpEBPp_D(rOb;8L^CixPZjI3GO3#Pq^U3%NS0Df zlqm7234*_32}n7$cat5`z1n$bq~9T0otk%^`cBME^XNW^=ykl2TGp*mr&sZ}yrbtD zL&al>R`p~gSeO?a(kj78%wd2Nt&(;+wR01#lIb92C4?p3e>TT{(nTzTSN-vNrfuo! zzVg*>$ya46JGQ%WqDSKG#74Yp*mkJq=-Vu{pCkltT`7tXF|XK*URYHysY-?+6Z?$v z$b_U@%zRGh>Zgt^gu@@79D~3tGUDMJu40=uL~>(Q{(Ig)5p*Ov!3B8kkSFMj9g)m! zA3pR!F?Ura4*8w@(e_OjZ9=S!po#b;B+Q`mnYAl zanFyu2!HJx;SC$1fb=~vFT$F>5mwp=n&-OFWa_yHSg>7+2LRNl#|+>p0EWsprb>}o%a@Bc#9->+mK6ZO%FqYW_HvBN&LvGgX8bVbj8nIqqblr;M@3DL zr=aU(g9&cUh@KO1lZ(%-8P;?3!v#&loUtS09c4h3d18P&c4W^!4;Nz7V{8#X=%J6U zFY>~Q+?qlUC%pA@-}!d^oT7u=OYI`+$qw}~_~6;E-V{p&e#d4?OL5o@EjIJM-_2^E zw*!ThgLUUGy3c)YR!=0cZdU8-#M`J-byk=~c~G^v8I2^mXMZI7le9RaqFR^VQ<&LG zeK|)Q&}#0jQh@q9jMPEAM9dB4bxHDfCA(cK(O@%7u^a4#?sG!(Kh2}qa{_bux}o=9 zpassl)Qwm+NZ--Mn4h^pZa5gja!G#6dX^0()TSdjHt2@(sRHv{$19(v(iHbk5IXT6 z(&)ifv-Iao2AT9?il9KfcUWy^OWQM0md{c}Ta5Ra?jf#-k_u+|GOk^|uWM*%=a!wE+h+&mQ|dL){* zZ1@Nnut78zTX+{szCHsRvI9GqQt2JtC7DNz^bkWs>aam&1Fj(;GuQ)6tkvnTiFmyp zQU7`ui|sh6d;i^FO>WEdZ}=bS!TRpLf7`!BbgX$p4<6+jb3$|s=VQ?HrhU+*7qa|o zy}FJa?46yQJs9rF{`L5=c=cb^bs8YJ%DdE?!qrtcdf=D*PYXhR!?AqChn6c_lSTJE z${R_h(S_7}%a=AC>tpDqwIxwJ>><`o?PMog|D%onVm#|}xGoiM zk*l-=5mc1j;zG=QEi~r7urJubj`&j)B0~|kv$ksO%uX@VDiD>DLXH)1*6DabKHK56 zFY`=B;cyxuhOy1OFj2m_e(GPN&TCX{KWBxfKOe0uXbrY~NENWKMS*oyD`xiS1&w?A zyr2%$piL zH$yM6x-#K{JhPvd%+O~Y1-TYgVZ&A-f@~rbbFK5ut?pLORu?K~`!DbgvbLhda z1W`;`cqu3?Tr7uaSecH}`xhH?(;1nR+hT}9qo@MLk6(rB#T+tG+4Ooeg#60PJyC52 z?bS*ce4_7c6{aZUZus>P9M{S&IsOgi>foVlc759gs)s@-i?!1GI0Nk zw>JTgs>mAt6QCtPn%gL?prTP5CkP0NC&ckt~p~s07@=4cx{XJ4jHs^*JvT^V<0Wy?wRKzerMuzoUAUMMWlPUm@ z^sQE+O5*t0PcCz4op?mtF0rHNm-s|^`#$h1F4amG9k+~vJXj+-=%V9A`;2?zac`O9 zfz>s*T0dwQo}O>Z3gt}tC+s}3zqmbHIn$BV?dFfgxb#gmJVT&wFSMG>h5n*O+=K9H zZr%Uv(L^vNT!TTQZKmvq`)zQu^dVz_sQkD)HSwC#vl5kEeXen<5s$dfhn40HY~vk{ zllPK{NnyP*8l40S)S5T_7O6v+HZ37#PMqzMYRnbgJ#V|d=Ccnn_Lcs?Yt_Vc<+URt zI{9bXzz&_zO3FJ}E*yG%6oAODl>LNQ*;{I%8h(om!c~P2UoR$G&91`a@vE(Gg9-*Z ziZ`x4SG%k2Du$^pM}=scHD@8e^2si*`*xDVA;UXM#&*80eJZWm9FJF7;;#PS{L zbe(}yZm7?~tFzkS9TF?sghOMj7uf4~m$;q9^2ntsB_*`H)y`jHd2$z8?F!}regpSH z+*E(T8@TInSK{7|yB_xr++yEhu212D(Lo4s0YPZBODA9!o*tY%2}rJTb8(A3SLH_r z?{Ul_$Lm6feZ^CvwzSGtitZ)i?Y{zo*h0Z%RnbFR@QyVgAqZU~Q!m!Y%6>0m`IZEA zgyuQaaZR--Q7WWvArYN@^2#5o%J9Hb>r|){VLeiAE0Ugp zx`Cr)G{qd}m=nb094!TcRL>Ps?GKH}0BQ=$3{=QXSo`xK9Y=*6pfc%#o%K30P)LM*kLi;9EpWQH;V50D;a6bYmTkTw* zRGRhV_b^5E$59qnt=LC3=cLjQ$wr-Pxq1qPxZc9btB~(w;97}cN9UU@5KAB6d@};o z{jR}+Tl%eQCxzqy4sMyF189boy#)!tmm19iOL3-QfX#^7sJA_ZC$WR&eY~6t zLv;@@QaLK!Hx=ssGyR`-d`1lAOZ_$$onZQBge5hOkjg31;$H)imP8ALxggtnrbHF~ z1^;dvvpf3SP|nv&wLDu>$}^(jt_mp+w;;Ypc^r|Xv|jj9yVC8(*kKGPK!6@&WErEU zF>*0bz6`;LxX;vOq<4xKLHcbe?itD%CrKx6*gPPTt2#l)pyGZ+N_xpJb%`GJds<*=zKDG{&Q^muUHaNeoC6 z$%o!dn{{o0>^a$|Z)#_PMcWCBJ1`GeNdV5bbQ8 zng$6i^H6`yl~ktB5DwF4d8Y?pTk~>(_xiLiYP6XJiSrA*w9y>>Wb}zXcuU0$XZc(& z<1M3wXo6$TN5)2L`hjSAm8{f9W{s1$N;i^QsT3aT+HMff6BRXxi_aqC*Ga~8qu7{; zluc#}m0CoN1W#d_^`3oEjV>KMrvV)GM+|Xds;vwrlymQ!(%f=+w2b==Z3J<&b0#e! z0Sx~creWga<981^O_9y~f3+Ow{Ez^OFD|c$PNQX@PI@rIZF@mbbaKS~+IvDpBPU9e zsTR?#G=RwI-n0!dz@Jg)m;SFEv<>yylG#9JAl$|TdxzpOpKBIwChEcF{%~4f*Yd^E zX=C}ng1nKT7SNAm$ea($7EU>OtJO|dQogs^q0b8s$m;8wA#oXqOqaLf<>IJP=%8iI z8qhM06uyS-2(dAKa2BihEcRm%k2dKT^)_OY76{1pQhcRCh|S5FPZK<~;F>$iSaEkEyD zBQ~2A$@Y(Mk$ruB+2*Nji(UC;pWffn>al)O%f{=h9-Ag!?XUG8NpHNofAiulNyy6j zEdv?*iK-e}Fzrr1bN!wwix-_VaHsywiaQc`j+1g(KaK>_BQkk5px{VK&ShV7Jm(8> zXwIL(qKOIjmhk^=&ZEgWH^~0yoD(>a^H|`doJUh~{w!G|=Qn7bzYxp$^Rb*i_uu9G zTB-9Z{k7@ojRC4WTWi7KI(Ej-)Uc;g;~lidV__5dZk3Yl7frSesk|J^_DivB|M|bm zcAQkmcY;(5vSa64NQJ^X$mgW}g{+nAcc?t=H7Dz7uR2*zd*#2& zdQfWoT5{7Yy>U>y$3rJ&zF9%2vOUL#T!GNfJkT+SZSh=4 z(`nFF(Zb}n$L{^$W4K{m-3~;YKwT|w)I|eb4+pyLE~u;h0mq=OyZtK|1XK}rWn{iq z#Z?uV#|@;bo5v8xGJM%Z7u@N3`1q*IMVU zn`T+r8+KYZuHWhB@rpx@6L(rSZ4h{)l^uhPgbuqUAwPDVxUB5z#_m>jO=C8+cn;y` zIGKs}e%|i+U6o0jd=yqonz@H!1-r5$vt@F@M*W`^tZh=kG8!ku%JqX&u8hVT|BGUE z`QH{REvZ!h*P5%vF`BDIoQpBaF{$8vR@S8<;yh)FZxv9OFYr2GMS8&DmKJ_jQoK7_nOFmqqio>f3Zj$p=WHK zGCGuVIiqD-aR=myzv^(@HtH?JX2iYN71E?*cTVBEI&J zNZjgh#RcV+0V|K)v5wB$WIQ{b@t;a#GH5K{$B;+5koAN-vVthcBf9`fA&orclF}vg z4Nt_-B2Q`3iA!CMfq&hr$@oVIeng^-Na<`!X#}HIkL$1A5*BeH|Y|0)0i?nW}_Za+}U}Se>l!HmihubzWiLpP&NhMi!Vb&eWE_vU{wm5tUaJFW>|=*?~4y0;>Gg z3RbdIvrLph*RMmep4wL6>wdLH3ZW|1q{LWDjD&BzbH(Ye{4Xgre^RVKU}6~|D^T&I zNHVIryq2Ok>Nb^an-G+Q&(K?j>STx_=z&nq*@9jww_{AQesiW)Swd%LpU_pd$`pMc z2`wZV52Z&!3p9SJTFGQ#ecLK;0 z297l=Va-lhdnT;%Zh?kPdV%-&w^?8M>-2aZA3N{*Pury3!uJ=xyZHXjSH-uSZz|v2 zWdBc?A-;$Ce$TguFBAAld}s1?=j+2aknc*q;e2EG()on$4gEa+=M?(+O(GZUa2TRF zbvns0`0a2aC-`~eH09?-FBz5=%IT}PuYk96ZEL=-KCEJ5aoePNuLel*Xr(%~)mBRrR@mP^8%T z_e+!4C)DS8_fmP#inpt#kW*CE7VQ=1iAKB55XkLoWdWVl!$72cKYK|hWyZ%vT`j~j zRFlC?YO}c!c~UD9w^8XfvPaT=5uV%wGMX%zQS3UgA_lNe%iS8fmccCS${-jdQozU| z2b{cQSZYW~cML$IjjnU~u#2Xeu-&oNxlR(mC%rvU$Q^$*HS|rRY z(Qfq-_43O?r>dmBQiv|>nu4Ky2h1a|*SQ|ySMmVhVg<}`0HUT|yUnPn)6{3OaVbghNjMS2%8|Ub3Fv(X2yo5y1#=(d5h3hTyyuzlxWm`lYZ*Z zw!?TFBQF0wOWJ`H`ImSa#gTunM*bx^BmX`Zmw&OvLIo-^(LtR_Ajw^z>PwY>akA+$ zbT9JnnKX%`f$c^-Bkf-NR;&Z2C8Ze4Wh{RKHGd58$@=yY4ew5t7fLq1C3JG{NFfe( z0(@F@dhD?k+4n$fhZzk{-<|Vju%lY5*i|1&}4eMnknq{olwqS7D}bW z`Efr%ALqwjikT7t{by?UHWEJCc{%~5%%Pm&ss4?{>c5)ui@)L5y){f+KUzl^r*)A% zjJEv|HH4Q-wD?~rXa6%P`HcvE6l&4Vk}=ZXn(BY2_=m3!5`YChszTO>-qbMh^e;FI^#O z^5)b{aTX)bq8(5w=8AooO;W6}vOl)6QI~IM;z3Ou`4b!F zOv}9li(~C|^lEfC$0h91_1P|+5B!)&?UPG#s4l1h*Nr84vq)6*nNqfAiZzPRA zXq8PNp|ILzfy-=-kREvx4Kf34PVjJ~gp4Fm)x^+TG2JTb1rCswOOO&h2id&1W$tXX zm8=K@#a$Z`3;wbVR^4L39f`Tcf?MXi>Ms`D6*0G1aLW!F^%o27xiPm`(!y6vKUOZM z@}xJu982eZ?2zmbdFw`U?dac2`ZO>Eja!$#W9A*M&JzmWuYsy`ND!j{1M5bNfX9pHHH8B5U2bMp4wTBxj z5&N-a6bF$%=>--w8Utn)4>Z7LNx=5S=NjN{Dv+2RYH(tnO5|SwK{B7d;gC$jJ$FZ= zHHD=3I^R8f*YiE-xCIvb{)l}cpA0gleI9=@rG9?{rbPSfkP$Wfh#JSJpWzahH;V?1 zUZ1F(Z-2)MBJowk2{~ZiTr-MASJ(3@J!@)pUJNpN9EU)_r=us7p25cGxVUwQSn1L zw@cjo$fkUrnT$&jyYDiu=48tjzn(m8Gc%CSsr-S+zB~bQXv9f|20;H6-0~624Z3Se?saao|8KX zfoA@`4kGdPsG8!jdbl6s4V5V}-CP1bP9%b|?DaMr|G8n4wu}sf^$q6s(=n}M=g|O@xH9suU`nLd4-6qa56ByBlx>lsFPr^94;J{oB;X{!EBW;I)%s0 z;7>B)9VYwr>dk(=o@|g}^qJp)wnF#oWwnqE1n} zWgPw*qXfiRCfpVN`u?pZ_o?td)894uypjfg$$r;ld3|l*b0P$7v=7=Y=0p2{oaaEo zKPjZ4wVz###oq@KitxVXhveD#XP^8nPEMTy4KCiDk58KSE6Z=zSzkEgh!a=v!%Y1)u z^Y;rX9w@;Ue=qu2`%|p42f@pp`MiGaoh$@QUmkHaVn!>&E?JlfEC`ql_=9CDk|+iX zXl}6|(fqhBeT+b|@wK~J^yYxJOeFOF;J>hauGePtQ-Ue%eMk_m4UAqJxV=hs5>i0R zlOAYZAKTp6u9@XwCu6(I*@VbW#&!enXD4I3%X{Lcz6Rvtrp_)Of}469FbY|$1Q_*q z`3`Wg@dKB~!I0%(=;>g{bubKZFpLrm5&wknfC(J;Dw;i@DA4?fwZww9%3ou(ORnk_ z+6q*362XJ(gdS#r!|0nrD^5k4mM&Tmk-P2fPwR=m)>h|&`hMGHa)8p%s!{JnDulvi zi(ttJQR1xh1qFBMYUv3#)(n>Su4WtoNvvMXi+?PdYOP?JYQbXaMIc%+0@0cgh*ph2 zMin@9BT%UvOsySpd#J!H2_-e$Qy_vVS0I9Eh(H9>D1k^F`JGDgQ%emWN;V_jz$3yR zF6OtPy+DL8+F(K3U~Z)j?AX_oPQe3VS*FiFzz`0di zVeb-SEK2eFFvYbY#Z_e@Tqp*m%#u>Rp{0CYOL^pHSu3EF*U(Y5l#OjnDc^~eGVDD> z3y}DJW9%`;PGjsa#*fDM-WcB*;~QgqDMq|@K2C9cXoA$H09P8|)eMv*d%PIry{F_| z_AXgvvrOJ&>m0wwsd?|=A z6eFp6xt-!qd_g`rbMXM*JifR1`twPcwU{6Ay~ekQ?@Z2Kbm8mCcM;!j`SSS&@mB79HsP3GIlcYsgurt@X+oyd1SUtc~S-w*hI!IzK@V)Kdo3h8rk`R(Id zq?nBTvRsv=W-N|AwV+$_xu&2XvcEuH@#7k*(1DqzT}uyiq{A5vKqzOb4D&@(I8~ok zA}PpP^X-0=m9FAj?5uw1_(udvkF*fKYvd}T!N%`WQJ&|*k8_AGoAd(gwrht9cAl>D zw}$huH+vrXOotB_z=yw)EeafpC1#_`?!}rA&+{>e%k$@`na1l8$1K^b4L@mrl{u1! z{L1kl*Y53(c*16USjFqChH(2NWLe=oXO3{crwa5qUS|OQS0D%7w0SqYhk9ZPq3;6C z8wM*2tsWAea5S~@#=59-0F3c@v;{yLMacKJb)|e%`;x_ z8ZVO%*LUjG#d!V0c=a=}K2Wc=;#J|k#K6`nteL>Vu4^SYs=<@UdJplJbA?}ArhbeE zi0LtW9)oYI!Pm^-dtdSGzEqQX+j#9otOiM?dVONNo;O~HjMrb)Yn6C~T`#Mbdp}-L z?;-Ee^4YmTMb^ZaDRoWDe9ereu|d3HR>IJjTNq) zYo&iylJ*%aBpdalD5Dx~7%4)B`&FVL0(0b0?(83IqMyzEMJD>{yS`Go| ziG|2QvhQD(&Ph2v*JzF_4x*xH7omaS)iJ*IaUo40=bG6#^S&%f=*cua|2#b}R+GnQ ze;z4+q>@xPNVyDyeO!MR>_y&)drlmU9uVja8j>9Q_cm#bEPTqvP3LP^ozqSMY&fj@ zW@*iiJ~$ zcT_fG3H=A{IJ}&~bFM3p8qykFPFI?vd6KEYtyf87KIK~`xh`G35W_itIP6;Ps+0M1 zkl6<1k~{V&*U(R5^Jgg*Y;wa>!b{|0AsVu$JQ!2qsu39F?L!bewdMB*DoUSqoB_f- zukje>fWPR#gTUuH@KM13;=ti@u4xW@0`R{&@TtIWQ+R#};N=R=pAB@lfzAUex2!RL zUI6q816>HT%0OQR>Nn6gfd1V;mjUf(pp`)1G|;s`dmCsy&@~3S1!xZg-41k}f!aVj z8|V(8G8G^X`+%NeplLui8E6Jjw}EGk~ zG|*h2zZhr$=(h$s1gLE21z8a2#|AnI=$8gMj!v*upcSra<2eD(Z;j_vpoAXp-cLo z%)@(wA~p8L>10Mq0Y_@hdwdrMDq6JRwlICDg1jF&abjhIT*n(|z9+yg5lxaUs=NAd zJ(yMYu@rJiJO9$Ce@S}Dfv&|F`R6lttZK|GIncd0Gyi;v#C>#9{3YrAZ!T`}Mtb9M z{ckBg;|&flad3~K`R(D}jDbAQMAy z05M)X&psWW%CB3ru9V(bzLi5GVRH|`vtgX>+DOL&AyTY zRis?fcV=<_JzMf-Pi_vhv0KzT`T^D+oJXLdl>W) zE4-yovO(*I592xWP5_`cHIaZl>C>1;bLh!b2~Agi1rz&Z{*llTER7QqxVaf!SYI1%h1fz0=z81`QEjt zL-h#aAFh>2VPk!Yd=y$PwL#b1TI5_?D8dXA#i7h?5ET3H-tJ5hwD!q-rHu%5Jkg^; zMiYd6a03@cd6uYyBH3trANJ_W|=3=f>@RqS7%!uUviUQtxvvXu}GjK?tu0(1^ z{sNH^LqaRwp<>dCx}q}8z^1p`h^L$+O6R=yY2XYwK8(se-2#8IwVzt$5np0c9+y{xSX?T}`CbnJ%?M2+T&ldtd zp$|mWZwt3IR(NlcwQ}9KB3+>&cZjr$x#5z1umq1y2`+p*wk&Dxzt9CxIXylWYU5hm zW)+vWuoOhY*?Q@mUBO`IK{D?_-(!vWQnc~ZnGF-_7j|^WF&+y+AP;|C(49#_~D9nT72e<0{cxubO zxUBqb%0EImCsLBMqPFp+yUt$_%&?Uh3y}3&`qn>7bjzhVo5}%Ih{^S&R4_e-%jwqg z{=C$^>v6(KlmCFd)Yy%GUZwiq74y&UwI{D{@5wm*5w6-;CEfS3I#y5=%uyJnX$)NUS2VUF?lwPvwLQrb^8| z#4nvRq6P@=6KE~(o@Mmw{RPZ^dYRM`b7#pAjfhgf{WfrO*&3{a33dhzORxtBO|TG#1mmg4?H7nnQ1Zn+uqJG8gR6E5Q8;Rq zB_Yq!Gxpxiz)%96KnV8Ni6i1Z&ZJrVc_`;X@XBjl?(?y5?>D%6RrYmtkmSOyju_(U zR?m%&r)4~Mv4Vo?qQc!$eIF5D_<}o^MEuLPoTG%C-B5+bNB5gVN<}O)SKYPG(W~y< zz2rtTSt6e%{WVgcciy3N(+klAJ{oxZKD0eT<;+`5lmK2a`qTcJD;kddLgtqrXRp6O zsNO33fHZ~1xvOE;LQx}Fv#S8nD}yW{EWw)8RUX$!#g_}W9wo8Hai5mPn%a^Wqtc3c zB;7Ea1v535KV{MFvy@xOESmLA;*iVSn`+D*`a-iqc&^2$C^nui#fV>2oFzBm5RVI> z9Ofa|kihlcM8O*Me)fzs9OM_$xaOWc(8tOz33RxQUO0*#b@%#&78;iL)(%ktm1 zY9?10$J91Ec()Z~=344k(K7@hR}5JtSKHIudqaZ7uD(~aFLJHQ0OUmH-a+<6%3Etx zZZ0)XxwGWKhxY+Dp4lW)QaA}C{4hBiQE%^5NFeGxD*@pGUoATCWA~=ayaXVZPjeTe z+&+y4My}$@b?%?OfGS}20uR$tO0IYpQ*lvLnF^_Des_+P$F8a&mi*HEN@y?cu!o=hD(O_^Rg)P8uczEdx3ENOXfzT z;yi!p;ZkB3`%Kjixn3x_=)?kU3BhdJH<(+*{(A(52iZG=C@hWdV25q|5lkwY6jWRaxbC5o2s#zawloz!qLq1j2?ORyJhskbq=2 zgZDgya_d7Y#G56ZiwNM{j;K3)N&E%&X9J8&@|p6WQ(}Asy-INJ>XQgaEcA~SR}NDt2Cw1 zcJdpZ1m}cj^f!q|>l@C;W^W4-tTYo@F`92J{kfp(XKp3@t{`-THS(p1RV(E60KYYV zHK1lit^Iv3DQYcGjk#7SOX%BaCVTdZsfZ1Bdy13S_xY(rkO42WFIG$b$OrgG>m~9D zc<44Xs;{No4-Gu8->Y+oRGiUo(L9OVk1!cn^1=!aD^%*c4P>v>KqSI!aS})YYq#$e z%f~q+AcZMzZ};9s_QIMyfB2Gy3ur0(ya%OcQ{Qi-_;rwG?%U~kb~>1%^_?x6_((ko zvOEWMQDIPw-&*yt5DX~ttW}l%=%$9x@zM5qdz2Ey*@&Hn)NdWCq|N}K4aT?)dU}au zSUF4aaiMAL)8ag3gMHQ_G(d@Glk;E7i|nvZ0}Z@|-8VQl`Xe7vFPS2aM7?){P~J;E z1wI-X_BXDeU(|KjOL<-MUyTeLB^$p^3{4w@T;9CeAHJ+Z+)a9mZI~@Sk$|v zCt1l~K^91oOQ%+K&Ho!VE}p9Cn!f^DMkK$kYyK*1nGMfUS2U|_n$;@%zLmIX>xS*v zG#_PckE0uI!l`|;yv_u%r|y%6tZf(t3i?UkPTLl6n0CfotNcYm^j($)POI!m>|84{ zSH_?Y>Xk*F_8X<#f8R9gK~MJ8*-K?W0F>2sR=+sO`N2qtSGY zldf?Zo(3;G@_0P0Spl$EWo`NOSCq@~ozT8k)~x#o0+W2_dzfUTtgKI#@W$2A?FAJN zre#yVIZ+}^X+1VCyyz)xjW_m+ikFY|hrN#H>DJPa_;C?o(Mg;svzG3u`m%LtZJKZ4 zq2|9dwh+MB@Cpe+X5?8fdD_AuL`@Qi1wezNv{6#7@X{U9-D zo6_&1WTMzDujleU+YlNivM&@JTHJEgMR+uJDve$$0a~ugC;i5@rO^vIR%Dw>nylUyW;8Q)wJ^bXNofYD~A(9yc#D)y+4xx1WNBkO@OG8 z1r5s3y&X9SFRJal$l$-R20)|itvbLjZ*YfZEInSXi_TxA!;|&a_KZob^ZMRehZ>pw z5Sj6Wf2BOBrir+znQyhOUcry&_AVhyp5ned+cKBC*SK^|9$U$JYbX(i#_i z;`vt4fv*AHa2qIy-pwjs4N5r5T(*t-D<*&FFFjO9z$u*yM!%EWXK_c-Zsg83W^o2- z%_7uCp%o>-(~6siwzJLPu|6~vo4bnGZTg;wAtYzU27i<)0Jnqm%!1J$l&m~iH6~Ws z*9_>9fm8QxIeA^lm(6F-QFsEIRaQ*^$yVe8lA%aWs(vfKQg#SN>Le|aXn0aEY zKpmOvPcEgXDApmC+Ri(mszCQNRw}Hr^23mQ$j&Wl%^E^at6aCK3B$I^cL^hs?U&H$ zX_U*FwHk<3wt-*iR8VKmHR>j{rvd4V-mB=2Ww0|Lc@C39~ei+41USE|X ztg;Mf}HNyd5@=^nrJ_-cP>b@RqEqF$utmc+I5>9Y-i;pN>3knaDDjb+>GoSVm9p}%VdeMIzD_2k&7B-tWj6y?;g1oMoic=Z ztS2dQ($FeH*_I{^&SeVJQZ0BT6DIMI-qIJ@Ke4$Xt4SnJJksVwBp$E$mt3^q9z-PT zdUpjcD-rh_Qi_YgJ)wzY`c*Nw{qyv)6Y+7xU?CilZ7-nCRkrQLT)Sa6TqTZ2l*~ur z8T2f8-owYiQ-f9NY5q*$OCa#O>ITkp2Id+SdESh|76#b&`fX5a2dZe-Teev z{_(|(ByV4C=GJ!sQQ0g|F{wQg4i%?Tnn*cx39H@UkBeQQ-=^`5*~*kj;ODZ3Q(o<> zv~T%~h?OuO;rEexSbe^{{azy>go_viu}S0x1n^q>+@v@kYaB*J_OB2plK&FoQ`h{D zo9A!yr?-sczuFZEFaOi#`Ct3fFKeNi>;`#1MBW9gq+GBw6;G98by?|qL(00el9u1W zKwN8$*n@Q+Z#MOw^E_=if@_*a=9FSBz9O_jYo@rZsg;)tRCv9>AGwNS8TpZ`S}@V{ zM=s0AkF<2Ane9P-)HJgsTl`LL(S; z`df^I=C#+}XLF6z=zV(WEW*^_$j|ooocu-*eS(fXS2waTeLs$1ly2A`4XF=)LTFt` z*Z%Bc;fu5(@2*-8FD46l5h&sd>+~}0u>@gD`nYUuXDNaAwp*$Hwc-3{0u>hwriy_f zF7yQ|%z-T^@_-;pz`y0nEIR4^_SZ=*5ZTLXBF_-W&$_3B_%22Kp8d}@(dgyj76;|| zCXq7_j}iI-`43q9(bWafy21SpTXSxu0s@g6U&@ah4n&IQ!T^TEYE=+BbE(1QKh8W2 zh4m2;TV?Of>tKOz3esp@LBGS(zltR^KbBAkiQG$a& zR*(8AL-VX2YbN!vdK{S43%rFkdD_GMY#(F($Or!5_g0VH)?=is1>n_$JS)3}4+UAD znm5vq1y$JjL`Vr6Q)Xi7`UbB=GcKI}DFw&mSDp_M_DS-nOZgq@>n639>(m+t(GQZP zN+(>JnVQk_jQ5Qi zq?yKdjIWy(gNqxpc|d|&WN{Yx`b$B{{Ck37yzc^lWK3#%jg(i4&f27S7W&v;)@8ac zS3EZegcV+peMe<{OR=|8LaemjaAc6eFGOxS+m}zAt(9XR zt)V;etscKjK3@vW`&6dvoJGlgkFUPdlcZOWb>t#xcFOT_$a5z2Kl+(V42by zKPlY-H&vsZTUug_&nE^e?Nq}qDL_vwjZP=Phpm+msT5ZFO{D}DCV)Zz2bt3yei0J= zRel4c(My4c$*|&iBcd0&0kEUu_Nj1>cSKr#EU1?6l6|(#zph zR*%}rqsT>>hJ~K%sJDq-;D`2P9+2&^e_}`M+ZtPAKRD5iedENIDquEtW#`6k0PL8Y z3Gq}<6w=+^*qYzf6TjiNe&QD__?zrPAsNT7(ar6aHeliWb^s!IPcobdbk4;7`ZR>wHQ2lEn+nlHOS{Fh^~{0 z%k(MVcTF5>g!8LA&)kE54!VmmR z-NnzSeG^?)kI$yGwt9R%`8=z~*Au&`_zDdbenf}CSi|=&^~pqPBpf055!JP6vWru5 z^Q(v;xygkic(Mi4=Yr|8$>)>KL}3v1$~g+T;R6(ftNB0~M+NUmLZvxtA(_fZ%2Y4O z)VW;yA($WwFdm&N#!F>bN!j9EgG_J@@d&O@Ot$2;)`@46iT6ylBtP&(VYMUIQ#3eH zk97_XcJZQ=`ktFGYY-7>E^1WAo5B66W{fYWxTeM6u4{J=uspu%%PZQ$v^^6K(Fhq> zu4!Rq|3D1{Dm=Kdk_vOK6s8NQYH6rjQ<(p$dJ8y?TKu9J*p^h02MB=SEm&hMkzpF~|#58HySNg@Oe6MaC^k$-3uIUkAl|D!*fV9jt654&5ljV>_Zjc7?w1}fvr!@phyH@l-tfb4dW?VZ35Pp`U$Byf zJAh?mHJ!C;vX4$Z`E;zIhaP(iX_hQ=M%`&N(W%4 z+AbiS0xEF*tppO@*tr*?K&O#EPFlDS``QQF}~u; zRk=Js_UvT&=$6)qZ>;vK#|EsKRrZBUL&y&Arir`~4)TK5IBqnb&>=4z$V$9jUiw3c zMC>wQt@7-t!liRxrZm(-mw*T^LuQZ7vwkPH1TgWly1<&nz1|+yPR!?zbNgA?qnEWN#EmwcY$!DE|aX@a;~<*ZNra@{hu|C`66?RC;8b z$X0VYGyfF&m>}%Dgd(wNi>=Cc_9=)=%7t$q#n6Q#jFR14H~B~UZ)6u>!=o1;WIvNM zIQs=KKB4((b8Ez>R{I)l<_4B`;~O7D7~qfg&I{*ukTF>_!ZHy1BU|EfDs4;mXFOK% zKnYt~nKox+w(tMVK^WAMIle^_bqVWqG|oTNKHv9uOnXMxgHdTpDy=oCF#1L|)zc*?!rEpmIw8y6ijBzwzitsTxo1B5Xp~8+rEC=W{iRdxS!&cD9qlg#q?Vvx#$W; zR!BUL`v+k5>04S5K$ux!t^Md!stKRtb2BhUt`*Vl1`tcrXj0FTA<%E(`1O_BBJRs8 z+KLXSMrh1Yf06HzYwcE(4@Q@>h?HjE)R|UV@|y1yG8U;JhaIpysono%Y~1i5wFM98 zC^?5Z#v6%_*`T;`YEI5b+q*yVD@*GS%l-lCsm!;~RPh+!DEh^hR7&v6$UZjv8~qaK z-lf;q((6AKws0sL0;E*S=5X7j%;wHD3exm1Rgg*lN@K6KU8GC7hsz|d z+TPnB<<;_oS*L*{c-~P7J~LBmtlnI0f1VM4XlSV4w7cA9AlpOPbRdedeUO4xUICzK zv%BC-((F|a#hd*(wQ80h!y0S$KN@?rea)1lX7`d4i62hHzeNKE-M>?i;<>`aRq`2O zyj>2g+HPj>HL3a^Y^{pas{hT5rd9v=43mB-K-=H8<_3s;dwfzv? zFH!Z=O?pnP$J%-c>v7Wb(3;cMJ}1F>3GDYMMvtph&7jM;N3M4gzcQ9!M-l|T=`Wv6 zKNz)JUT~0;fic~)3~9m_8PfXDADT={?ktJvs%d5Ag(4w2BioG)EAL5Swr0FSK7mh; z>!7E=OMiGnh@i`aElC`g;cG3tA{Y6@h$f6z%6^p(GnG?5++~b%-toSkhU0oiotVmT zYpBM;wG>U+-=F5dX$$@ir(NmWL7Kt}`yDi#_Wa3))7~H^oOXQ@r+omJ{pRK*PMbZ6 z+K0GazBs{Ycf4U*M3cIRj0ht~g?{Bhcr3f8q>v*j4TH_d61KY7cTj+^*8`YzfcN+o z`}P~h8n~@=5BT6m!UuPq1y#UP(F2JwMpY%E#8_>2nP$AY5A`w`clzmW;Zv9VE16Fz zB_Fi!yU*mb+Tl~HZTr51QPK9x84o8PYhvk6C*2gBjo%&v=h;W$oDWW6oK-22Uq4pl zhI^Z4=z1a>9>Qf*BB4mt#Iw|Jre?_$zMDyBIKJ7H_LYiXrqPwsJw&Y)+-c8FB%r-z zwY>+{E@UmV2U)YN{?496`d>}JbqoGYBOAWzDU=l*d1$BJrCX&Uu9qDJRI4Q%v0hY#J)a-HNHu-}+$>aEJ@$u;(Aj9E>q{NiIpEj}vh*Ng&* zDwp-N|I;e3Vn%1~FO^OEu>2xl2ffKOvfm#udPaZ5j(lS8J6We8gM8OQjd{LntR+Kz zS6fSv-|fSvX@O)tzD@{sM5TQ(8O8Y?-x>$>8$iw$eBF%CFhsZGO4Q#<7E=Cb|7)+4 z9#?`qs>9B)dYl})8*xH#(YBv5n5QrZVb|Mr9JIz@h$V!!{BAI(36R^bhAMm z3YU$}Vn@U8Up7wzpvY8>EJ~2z9aTEb`q{xC*w#Q8tgsYWN7#<@%%-8_R%xo%h}r`KkMaZ z3#h8_8ZJzKgIG|f{trs$3Br?QI+;zLQO$iK!8ggzr?MmU0x&QLiz=7t4cZ@B+>m9D z;QJJY?b}!}0yx;$EsmkSK^RngACb+7Afk~K+z_oLk9B-(8)EP_3$R-S7o*K^&K1nJ2wLXAVBr@rau&N-=#DsEd<4r zxt%(-#vrPS<=(lv*S+QlLtwA}Fv{=-sP5WjHIFg+dHM7j$4pwno1TrS)`(5%~_k z{zMdIGNJM7BUHKzkSM>EWQ9nDE~VcM(lELF@`kSc*)0%D>{P)sZqr~=yF~v_4My7} zwTxkFa{dF>$||9V9)`aLMjt>26o@p0qRpn?t)rDN-=6kduS3VYS0&1xJl_DJW550T zj!;s?6s~65GZV%&gC%5VJ`OQje3u=vt0y4QS)Qwet}kn0FTxq9xSvZaeo8OiYJb3l zO-?@bbk4Jl=VX+y;1uOBS=L-$i`3N95I|&$lRr3t{d4=+KoHBH84K(^bU>0t3&n39 ze6qL6%phG>MdY%5lARD&jx=0OP7*91ekaPb_5KJ;;{30(+HVqN+NK8Sw(qH^_BK}K_|l_Vi~?cDs;G= zPlid>_2V>EvUtD5B(D1xOi{SV>b#lveX2eqtL;a}DSFg`TGBCaD*MX24VphY(ce-t z=zawg^xlUsQ_;=Q5TF}q&=qkPiLUAQo_Raj&VJ86@H>O^8V%`jk5x11z7A7xUWl2B zGuMQ0^;8qw-`yrz4d!$;C?%&a7_8ny_nCrbXjqS{g%fuda8qj0X?r)toz?b}ijBtA zB98!({UC}bnSkmFCaplra>e|F(Fdcff0q7GNz;iUZ6W3gRNr*^E}Yxy_r5R@@A3>p z@$8*&jot&qI`|VMwTL@NqJ-oO6};#ZvLU)JVF>m74EK5oY-f^&QGVTWJhP%tt%rv} zD1q>6x|>I2>t9JPcF0C1Y&+GxQm`z>TnLEl>JW0NeoT}8j-E*uCBxW&t=Xgcry#iklcDh7EdED2l8FXJ}+^&9@qP`!&ZVXxL8d+o8x60U5 zYj6L!1^LUa6i$t>< z=6Iuq2)b6ONzNyeA_%MOyGW9eQtX0URbRX8m+p*DAasJa#`Zd;yGt>6+@%Ji`yS(V z8F>y0ytEgFr|s}dqx+ceuWvFJ_a(R6YV zfDnTyy_TtIwuS{FhM4SyOk{=14IzUI8s=Bd_?51%B*ut_8KaV!8Ej4Ie<6OtohHPH zKQBi7u9Yq!e%X(alP^|>_+wKRqZ1dZiP64vfZ?u=gtaGFhT>0ES@ku|v{1aP@Ce0M zO0p2P%q|05-?9KxC|(My6fY}4(l1LCK$lb!XH?f-rzDP$t0Z18L6Mi5(s$+wLR)oq z*@xQDSf!m+;QZBI#a3otMp0E(s_E1T8ZNpp3%k->R4L815dRSk?=gEzj6GtL`G&)>q<8+k zc}ARLVzIqKHanZK9x(h8F5gVQr$MiZS3M7WeOX+CGV* z`i2yKc4|8v_1xQw=!izYzZ@&=>0YBCHdklw6FvE#6l?~~KZ_l{azOc7@Ma}~YWu49 zW86XafH>SCd|OlQu-A+@?$IU%!JensJ+46tg4dnXsk?$4p0|sRNKUHlMl^wj18Evc znY--HP8u=FTw_1xq|s6l(oE;Lwoftz`vKEY!md-0Db!Zu?Q&q%b_r=pUzlo=OzsQ2 z>_uZ!`@$Og3@613MXxFTE|JnrNh#g!q~yS=?Gv4p+NPxB)L(&@ddvVvOxS^1%hDuQ-Y#iv%T5iS{Y!Uq`dU-;Fq`f3aRp=U|ci8^#csb7$dP zFE3edl{3GiRQk?>v;-vEB2{O=n(Atm$g@Qltk%{*Vn@7eSLo|zkL8>SGKZ|EBVT98 zy1S9D!-$K+&>x7v7->*3G2%{}*p^LDztDdXO?jUMmByMIVtwtD)<$ZK-V~P_7hLH` zjd#YR#ydo6yxq3in!$bPJ!WKl6;rsz3e40I@8oi}PZiZuzkXK|(o zlYd1z)}*G9lyvMo-+hwQz4kySsm2MW3{f?M?w>Iwsg0PaNo_SDT%$r4Etxh9`& zYO>d_(*CVUZjLXcbi!)&16X7mL8+Q^d?lE6U8a$3?p915_cTpQL~fOrh8nPIoSH#b zFz#J#XPROFk(EFa1UP&}^vWyXnR zePpO_f|4Gu4#cT)DkWEJN$XRshR@s z9DpBE&HB&iPfbPNR6osnwz)$`>J`aUE+%Jxn!`I&@Tdm1W2CV`CJ$(u%W)d3oC-&D42tcym%I+}|8H6m17YSb! zn%8%Ktx!)T{0g;@5AeT>e(ebZTtnF4-E7`Normoce7}SYh7&RSS1Vf%Dtsyv$sM?5 z2J^Ex_DN7tP;VonKZ%1~s@e7Ak?C&m3jl?(+b{SbkZt1HD!OO1g;3)hm4hV{g2^VH zDTe02@|bmCymu3Rx5O24W)mUk8YAv5ceG8j4_y-*$ggQ;2J#Do@qv8fr8@e}aaMB8 z{wWcnWkeDg+0Hr6j6~nwuA^S3t(a7eyTO>Q&oP_Kt{=KiCC&BZtI8hCa0FBHzUah% z(ux0fHG}SFjobA&W)nOEz+=YETKhN$%}6KuL?`+!PILngx~?>6VgqH@xRddJm}X0M z3Dnt33Qe}!n)vRM9Xuzh8FU>NkEjFg*W)yIDy+W>9(1~(sj=?{jr|8^d@B7xt4Ui8 zJcLMer6!vWlJ`Q(UW1z&hF)!kVaCTkdUL5rY!UW4pr_lcf*Fj&YG0+?#eVQmY++XT zsa%*_`okz@y>z{o>38h*>XJJfb@pkY_zF*nH0$+x%XltF3jC3+`H}7POXR~WD^$#> zEZX&6QI7U*e;pLkW3M&qCV|pFVAFEWWY$%qT*ca0hV9)GSxcmA*chpr7yCPJXeNRbebI z_$m$LHAh3mJbj^o7SsB@|m;OCz_rp2Y(CNwGD;*QNAAaQs z0iDXVd1%YDWsaJ?+xGnOZ}O}ww-fj#88~F(>gj#bojg3?es?VW0fBtAjI7LOS!?pN zq!-rnv3diGW)zez%n<+?ML4|xEC3c!z%wx*ob2ijZo!G9rN2Y?W$@-#j(QMls{)Jy zeyEl0T6Kp!f<^eChA|>mq1wkt)Csoxs#td)edK@&*4>Zngrh}PTT90K&XT=vMZPn; zvR`(|bl(}h_H5dh7qR`JZ_?xXa>_V#@dPPq;jVxfV|ES7FaObc_)A&_9(AN3a+tOb z9x?aZf+%JEJ=1U*_u5*MLG(yzwOa?+o#iB-y!`!17!`(6cU`qwGQq(9Qwt8FjoN)P;y#H;O=COs*g z91zhZon5y7s09CZebfDJkUY;rY9CB(*9+22-Ru}0Z`Vy~)jU;WjkW7~W3RSLha|OY z9!W{vE=$CJL<0uhPb*0A+-Kq{eLQ5mT@I|;KF{E5Qn#m6t3D%Dxp3WeP3v|wqlu*7 zM-$V!ZD$g2cT$k1f8drxIhv_A)41jIsYKnrT6HY_$+yFrCU~ur;3`l$l(SH=dt7g* z8FU$Ud_&s|lX$fqAVHeVbciQ(c@-7a;24&AF4#ON}^C=F) zGIfrgZTRRQRJX!$MI$%_)4mZd!T9WQk+zJ}`)`&C@VHyy)`<8fTH$9>Mr17#BI1>eLLnmtsl^Phh5Eeo{k#c?g(Eyhs;VD;Zks zwhpqf8pPwiPtBnF4opFIIc6%dp(cbYPfd^>9IQwYAwei(|64;%29MVe9`|XOg6qhr zrnoX3T>J3RvHx%2l0piaNuX)U{H(*KHkWDykGlp_P(ObZ>K9`u3nhEho?KO`N`h*; zqm#jV94zH(2HnM&f^8UPYN4;!5EQm8*qma%f2}EISM~F_FHtk-?tv*-EX-6a9Zd*V zD>cDZImqPA>`Bnponf$gKfKA%$(P1-eXeHE^)6=8dc-SnXSF>MY=VQY+U^aWrnR@} zpsBrki6l9^OL2PKGZaasL949cHuWKgrzLP!+F!!|iRbF;#2c(;(4B)R_&Q;xmiTlH z0iKVph_!;Oj92olw;u(abcN#_GnnXa$$h%Rnc0 ze^gJ8`z1`t)hx_ZG>>SApsQ3((DX5AlJ|@xiOUA zUTz9}QjF+c0IyWup&L!ZdNd?g;$ccQw*ybb^_7MsdryLkQksS>bnq;8@T^rc=w5~? zcotx$;(5-5a6PIf_zDvED(y@M-x&4vxF=u=o*|g2cy7=T?0;7iJn7&u#jCW}Fm^Pp zwww2xYHQ`7JX~ms?mi0jUiAUx>jepv6G16CS&t`Xr?;KxAE_C1*BZC$EzBlUo7+I+ z)L5l`j=|%4z={8RC;o$&f`6>WuS_EU2_}SVl$vDgBnO|+*{2L1M0530Px?KkpgA2g zwZgh+h@h*ZnxLr<#JR`gV6iKi{PkLAFVB;@%QhnUAl8&bMi-^H$n3HhC^9_(%#J92S&*p-<((uQYuX#gXag6DK8UNsYn-{x1ZS3m$t*{Y3su_-f99gZ zza=RrvF38pMP3K7QQ9-pO0T*JIueBOXOR%QCI=j3g}*|FA%t8 zrAVZGX4?By{?6kU0UrR$mqE6d%QPCe`hv`@^i`VTQ;A*5d~e_oDHX>YeLw;W2d{z3 zFyLLlt5KvKeTAGC5pMEv#NX1021OMH9`^;rA@cAoBBg94>;@|| zPUl;k$)SQ)$c%<$%$P4L0=aqpYGw=-?lwl#)79vaHKfUSFDFf_?a&L(oQZizwY@tJ z`G(-dnTbi$Kb=!iRixc*M}GMpCQCb|5WRQa$UFs+n#-6L`!ZBr_>-)|rD1hy_&aLY z$lV*{lFxmn{K3^SC)|O<%Kkv+S2B<#%@MyBcoBpaaa zS}i{!h5bw}e!_tokY8jTe)C`Ehf$l~VJqe51NmW_T)ScI21RlJApJ7i~4?e}g zsfhch>vgBeYd-0@_OjgAq_XXf1JTIS(rdV5$6E5wYq4RzD6cPK{`G21a^@NO&nz*< z94--K{NXaF!+KaAQI}T zbR74lX$l_qA$4;i&CF*%G*0a$PY)zE1jX5K(L@fU5VUnuPSJo zdUq%Fr@`rXi)=v~Hzc3L>GDUxpg; z_!3hPuT!_j{keg=-^B!>(5ZO;IquZ9x)YpWVFR^dmS)R#5HBzYyt6SS<^*+n+|%P2 z6ydPAQxTpFLh`55;TM-lS4izq_t9qs+nENd_e2Nl*#=FLT;Wk4%3Vi?mulpe3NZ@V z0FD&PS7T2n1;O^gwMrRoTg{+*3np;yGR)N4d`m-s^&YV5rV~MC_X3gB=JN)D_c4RO zHBH^@12b^<{g_F$8H_u%@SU8T>ULN5vq(kQTTp8Y>VQGv?Sm54lQ z<@!tF!dZ=70jj1I+T~|cp_{HTMP7qRa_$c?Q;WVzeJJ{5a7uH-c_E}eAeH>gb0WT= zX3#w!Q|hn?GZoQf4FRI=ATmwTM^N!`zj3}n=hr|U_b@es?tJ6+3f!qd#zXHpI3@MA zaj+Kq{oiV_Iip)=KLJLmz?O<3=-qp@iLwn-O4^8-)F!LrPQ?@klNMG`4FXlu3bcPT z6*$kJ^_Dqk=Nmjp6gg9UD0gp@JE6fkdmjv6N-)HUH%85%dnl&V-vyYd^>?9$0MCy( zS~6}f0u%GHTKiRyNm)-ZNW5(f64%ZlrmQUu+`SifQkm=HPA&7};02>-p6%f#d)~i0 z82)KY*K#$3uD@th;jy~7@L=3oZC~l2(PFj(kKLb1F*11Xz6YZXGRo>kIQv2Se>VRddk#j%ook6#n{9J1i6B_bhS)q z{3CCSZ#$R$60(DC9BVg}A)dUKjz=G8)%yhG76F!P#}2Z7 z*T8x&!fwy|jEv9pIng31J7igW@`Dsvjv zbE1r31B?d<8+re!B4A z+bSsdr4Ue)F3Hx>-9&K9MEw z)SlWN+j@#UwTPFN34tVB4TuuOOHivD;w36#KqSAB!)>XL!Me2`lW<~oyP>i>6>O@G3kkI|3UjjD)GML+g2!y83E!j;gE-fx+W^+i-PbYuOq=ezVHlLLH2Kg2Si z48Vx%%b!A;Q}d%C^yA4AmwsIS;UN9^4+@q@WU6}c8ACtZjrGuvRzp9gQR#5{u_eAF zO+W1Q(2ws!7DNbqFzm=~VO<)Wh~i11SsMEJ@JP?O(9ZX8L`1e#+gh#?+VDSG7b6eMOp@9u9- z0`g&N%Hy0(p}op;F-k>B@HJy^0EL?^g3pREs-lJ?EVrc*`yHcNxPWl+mGN6T#V5gC zOqq2LF|DmBmo~ebn7RFt_C7jpkli{#feX@8uaj_?pemUtaSFrmJV{hQ)7;uQM<3Zv;K$C|dQ3>l=wGoB(uqjG3kIhb9+F zWHP)=p-)qSQE=nVQ$taT)z?9~yx^**E^^B>u~to)Z;}hGX;s}@;{nxqato?@gCDrf z5K|-{H`P-$_pOPvW8NXXmm1b=FvZh_G&xMnlXiWHVg{patx&=y{T$%4_<0 zE7J64{dshH(h80Z(dgjzxQW>m!`lK>h#`9t&s7s~&Ux}->G9ELRP=;-(aGO7svs0F z$OQ$0$73hBbYzBYzL8&7r?82{8spwcP(IQYs3D=iA__x|97!w*EHNA10qAY~y+7o9 zbfYt5&6t<{?8Wll(MI*EI_<4Bcf@0o-Vj}H6^HS;iEa=$bih?&dS9e*@&u~ZmbBEa zbei}PulDGbRF7sW2d)439^)~h7_Fjbrr$J9k#XlGHE@?`r+RuI%x1S;8VytchH^`< z&v2y2z+Lyugx;tza`z4|Fe9~yWl;mF&$Z#Dqu&IxW2rY56WomytG5cJJj+9jPqdMp zMb!98T|-Ybj3kdx^Q0VO{b9G6Fs^tt@rZZHSIq|G z#LSP(ev%;Jbc+a?whXzI^@9`F+275fg_z(_M8s@l?>h)Me??!+wm2`bS6IqS*Rfam zltN9PWwvB8*g#t-c11Hj*3TZL*+JR*v$uhw@ z&`o<{wTPuf??xNn%Az*EA>!4P0f1MZcjydeEB^J|NaCw`(fBRCX#CFcmGRnML&s06 zjDH=!TYTp}R~f&vD`-u*1sXWzPB`Exv*3WIT*@Lg<*H^%@)eGsIznyvsk^*P`K7zG zOwkF0EHP6a*Ycu_Uq0x{@Z5f*&kduo)SF(N3;}t;33YqiLrMhBu|ayG@3U{A$!_36 z4tFU6MXS%Nn`xqE)CdiePFpj48d6LWMU8TZYo)Jk&j0F#<*NtiMCg52ALTWa-FI~^ zH{c%5o8WM-2x2GrsbxfF!EIcj?k0}GyL?!+(+y8-+~ccIfwef!&@5rw}NM^9-uZSKJ8MQQ-@NU$&jD{ zYEwEyAN7yZn*lS7pukOveIjDpRwJ1$Gb+fPzMv_&T6b%kvlzt=y2!EJ2y6FnCl*nIXvj;6Si}bNH09pZtiT)k zNTD*=K*JAmx8N-=Yj<6R2@GwJ)$m}44EhO6%$gcAp=CnGu|ZsomgA~-4W7Vxi0K*< zm}fSTjgO&*Lr?M=_&9mm7qJT$Z8PF=b^gs$48CksXlGg9tEb+`pm3e!Gx@6Q}_^QfDy`5;vteU#}3#M$n5`j{*eig1~ z3W6k6@8%E2u}0h*WWeQUCHnb7u%41SAx{!?sAa6l%X5;Xm-va>63x4uxhWXI8?kr3{JzN=Zxb?R2(Pst5@L8Q@^VfC zISb~ZG`2b=8?s089B3iYkLL!?7V9;B_Yh)eq6iJHSD#1^sW@Wd=2Q?-XpjRVGEdRI z9v`jm;!pbEB!5ULshC0;#X|_;d#9TRN%O7FYdpAI*!P`L5|-7qNpuZ1tg`&5wQ`-y zfw>4pp)QJvtO@6&`FF{gi<#oMgsUJl8h4f#-=x4MgZycc!r*=y@15HoNHJU~LW{o5 zU@{EXH1}p@ngv^tqN`6Bx+?m**fijN!vcx{Gt>@xITJ32mOhcDm!glsdALjs=<0Qo zVuPe(gM$51tOlB&MJ7Z?U0^q@`h1a}_E{ zJtR>=njWE420$rJ!Dw%J@6$TYdl_kjVx{KFQYH4_s#XK;_XisInid!kMgcV+Rzc96 zg8PWQkrS&Ui3h4^Zi@eB*V88lp8Utc;2o|^AxKjlceiJ^pWZrTlB0X5lj{%B^pCQ!%2 zlk?8GUXPj&(DcwSCRiD}&-6*RG6}DD&khM!Q1e z-M;e0fLKEbMk(@aW4{{|5CxSwsHNDIYhI>LRg46koMSpUS3O?97BAC(6E<-{peQjr zlLP=HV(4HEzM(~m3b-9+lj1abvtBi?%qo8=e3kTeCjEH^i2>rT;8H^fwFR0(b@0~!8o0hRKr^#a8Y>|`Dro5ANWI_-hWu16`^G zM%qs^JZ}sc9$=?ByQn0ksAGUS`9#=M1;7G6CI!&ZZrduOvq~pQsaN5qmQuIT+I3Nl zwky>f=EfZ!!Iz}uPXng$U-p;;LZd#? zSQx}jCrZOgz|BR0?vqn44 zs~u`_sgnCmDbMcnS2C9dMLQ^)$%(DU}S8B|P+?Vc{A#xR5N>Gwkh#(&p zHTDz1^c0TBc2&Or-fAR|#9o#bc+aNixLRxf{aJHKba8Qh*nVU%mT6UbKkGj$p6QB{ z2lO#_a7)u&eas>r((z1Jp(%>k3ByIe(cHz+@FwE37r(^N>v2dmw zv^mJ~!~ekk-1UYO2>(C%p3LxohQ+94V0;wRS5sJIW)@kK`!mdWXKC&S2Z`zzM^MVw_K`iy>?;KGW8tu=-LVOY%hPFmz(BGaNIsZT0Za(;>|d;@7jBaIlTJ*$3Q0MAY$A8Rb4>+Be{@X+MUP8< zS3HOTDIa_%zKVZH#P7cy!x(Y<0Ts&iAr;DXoeD(}P!JrzccWtf-~CJ!b1YnS?GUI2 zgx5vF>k4KXhEq&8h;7KgfDq)eVP6c9+)UuN{Iy)VE!AFB3R{lS(s;M>gpSYg>Va5P{X+0gbYzo6P zLkomo?mEkpNIVy|SqxuH0bivr37k8)g1W1&yMnstCOf*8S_3ZAb=3Zd*jsZsP!|=~F1H2BbPd@eYDKh{7RGt6z0?G1K2M5gn z|3Xo`nKaVmlP*mXfHLcfDPXAjUzUOFS0-x}HfZ;}veANVJR_^>i|p~Hz^bX8mMK_^ zoutg_?fQB8ZyEwz?iUi0B2JQY=`&(t($PyF7iWO zn9Vu-x{P&drAVt}2;KA8+lK``cmKD||OJz-aW1_R*yQCbxmF3R4T&j-v%* z257;#>;9pYcPb=f=*o*8@1JvCK!7Mpkb3cB6S$@6E;&#<-84Cvwq^Kw>tFNFUvEuR z!-0V6MM3*nJHPwnF$SCQ#b(KLelsHNwcWqg3|cI3d?3u6$K4$+zvoNsNcnHB09yY4 zaUH%h$n;BhqCBTx@XK z3QSprCz~9;{Bz8;D*totbGDmal|6=Mcl(Xmn$j~V{kXyTNtbo5Y2P&G^OWUW(INL_ z9d$NZZqp{3*S`EBt|};(>+ph3FgdESv&@x(9?dml*=F2%}rOD;FF@|>yEZcbDg&vR;oC%8?V<&D@c8f(uO z<@Gw5sq~}D>b#dP!bq0#kCyyazEaa19~~HedcMd@t5WL`p#SZI<@*F))F2IPUVV~xgg3% z1=SQ*a7A9L?2%|Eni)VjgDs{$H;BC1ea_R2;#_h5Q*?;@6dfWz<*El*YJG)|Od759 z+Iw^wI2m1jDHQM;9-;b4L5v1X=O&Xs7Ra-TUVsDM$I|_hAj!u|ezhJ-co*k1p5~i% z9mbtCz1ysn)rAj@F#Lu1=-s4C$~BVp)2#CIUgklgHV;jR+%BnUEEzeQM2R})XC4c# z%Rx|}QB|56WoM))>NaZEytMC((vXOhS7**n5E?uW56QPx2cc#M9CV9i)-nCJ4 zGpJCKe0kR!519FKkH?|QGrpT6-3oDWC4Dj4*_m!aWSyR{QIlUy)Y-hL!+15`rJ5vn zm84NgBS|_J{;Ltm&O4HA^fgFRZY<=_k?qP5M9_DvC zFUe5F)B{0&<-p6wjBqN)G;$zB8iw!|N26*!EKPm5#TvU!9>*QW?}lMNOye83lQ;jU z7m=178S~9fwkdFW3|&gb&i^GZ8G{-Fd1lB5@XmCDZ;|*|W(DmJeWy&{83EVfdB$lP zkfL|hPtdyhyw(Z$yaPTyGSvtnsy7%EW|-jTX`#4VklCt+WoDPhzyny9REmq-*~=-1 zm$KJ0wUnlBWVqC)*?;l~^{Zxl!(7d)Uee#@?&hfk<5{NuF7x%o)Ypu-lnl6*S5LZ;43--J zC&_RRIqBZj0RvA|>YKFK6jZ~}FdAQTGJQ3J4GzkVVpS`Gq*ZN1pOj2whSbzFc58Yz z$G0|?Wz>~Xz)Tj2&3G?;JFD(=J?6RhCljB?4*KHRZ+r$mp&xnhZ}v-&lhEOON)~i zu=2W_v)7ZZ#~jKCT$I<)oc;S$0XX4Nz%SAT{5V~JFJt)^^~DK+5qZ7M*~?M|l6=Z+DeZ+pp89(Z9e<)G$4iQSn+&1Fz z{$FJD_xKw7tj9C{>#Y7qUz>74zZHAd?u;bzmz~B|v#Rdq&T5;K8|n-Ma2o!L}hceEY2o zf!M}{QEM5HjFQRk5G#c$YXXbKy4?=k%}*bEMJH}VcR0f|#_@9!_KJVgy!x^~N7A~l z$o18i|9Q7o6R1|LFwcbV=?<#Mfba1HSB28JxP9y<=6d zvFsunqhdH2vXkMm33Yk>8={RZMdeQ|d9`Om$lleotA0eN?BuW&?u^*8{V}=s(2-33 zZpfu8(OQMek0kPb81cy1lGnMA`0}A0pl6N3!7tf?3PE9%=5?sobHG>*rk8d=bQ@~Y zqR8{sbx6x^u^i~|l&VFYkkG2S&O8x5x7o_crk%g?-6Hu67zG5&UDXqTgY=4w>}Mg5 zIJgByi|cO0>Ejt!KN=S5^hOeBlypEE7}B6g)5j1!-($U zTo>}(FkXNd?ZbB9hhAnGYnWyP-JOEPf1>_Q+VA1>d3A8EIb&8|Y9zxYuQHJxG5ZJ; zxsGEjG=cX>Uu<|2ISXm!kiz6JLxmEiFRT;Xf6oiWD!1=7yB*WV-N)iLcE{q2ad4Yb zVOY@>0qp|iaZa;JL~+bLxS@v{EV8yU#NQilH9+K)l75b`@Wt$Ufti6J1LP3^DO{2i z)@dgDIN<6!#n3$jhy-s4))=#>v5(C0eJMy>I0GdP`5W)Zqb!~BunrJ;K=9El z1UKwyy&nSgc85+sdEXNW-Q;Bn7yz_PwY5 zw0YSD_96k{HYtAp4*YEz0)M&TvWbDA066vS(SIKRFFqaspZ>=HumszG3IMmI0Px~} z002XtC(N)!?A6B4Fs%Jo>;EP!x)UN8bYU?yVN9UrameQPTe<{;MyPneg~55j>*oz2 zR&Y7eSF!YSJ}+}*L}0Kt!WN|XO7~DTDCab%ZGT#|!G;3STGsAs4mnTundC`7>dVni z175gWYqb^iG~%$3urjb(1*cwWv9zwq|KLOA&+g^o*py-UJkaS5UPkOauEGHvH#FPw z-Rqu<1{J74t>71k%n|SBk_Bo^s?f1JL>yOlSk$9dZhtIrIoaagMD5X&;wOb>eC!LOTnl+gAa60Yr!L<9*X(N0C z->yujJ*8^h@@`M3T{M_)K|1YsgZbv9({3BgH$9!!IGC>}owjB$-`I58b%Xgb(rK>` z=6mC-ss5G}479H+owj^1ZDTrZ^k8`prPCf6%y%zoXsSYiJdNU9LbKUuMzq-7Zk9cO ze7^Jgnyid>Ikebk`KG-qreuDET=TUWH}+-K6)^l8DbjTY#^NYs7dG&0uGvF<%>1lSSsO>vW|0{iL`Z+H$QQ#T1 zcevmgvmK}Y0ZbKk+rm{kur_QU2_QByuq|;UprrlxE*b-%sgJw7%{EyJb7}_~jt8mqd&2=Xxf`WHX!+!tF z=Dc$R?kQM*0Vs+k!mFr~CM=;`_!TEWp=y<}wtmGexH7Rk)6>N=OX0j;vNmSp zeau6o7Dl+RhOaIL`KF{`d^Mj%?d_f}=ea#}4!}_?<7A4=WS5@(HI%ZgpGMEVQK+rN`Cib8B?`$EA-?rRSP-dUBQ$TpD!n%YFS} z+Z!OYj8ta9O@E$rGbOX!ykUEjs@!Ci1*|Y>gQIl6 zvXj1ubWrk72e#!{+v!bIGFaEblS8N z2EP6GblTj(w7X2&;1GOEuNZ=_9+!ScD*cLd8LI}%nDGf|Q%EzSsMwh~E~L6tc$?iwp==J*e5!aW)OqOHlQzc~m&J`OUguSt;a}T| zyQEqC@t(R8IxJ>OTmk~(95Ma9Vz{~ocr7AE4+)KC*bcGu<0T=QEu<{*AvTyu27r$+ z>=y^ra&VV@K(f!Fh1TLjND~F#KolOs2a8{i?XR#s2Y25}uX8z#+MkCGN-@jC3_gAX zKW4usSEK^=XsWs4rp;#aCbwqWCfA^K`LmJQ4~>d9X7@*1UiU`rCt>N4`=W7lx@@C! zWt9mGs zXsBRp7h3N6Mpj$6kq)Z&|XM zo4>MHZq%wtHOIQs4;;U)hh;BU)^^6q_be^G6zb28COEqBmBpMgm)CM}BJWRhFGJw~ zqD4VZi>EW%=w#NvZLL{t1SV!piV;j5=7gQ1P!U~%pL(UZ@X@fU65wnI-|pG2?7YY)|!@| z6mQtsM|YEU3pKKXEQ!R(tND-SZ7*Tt zdD!z|$b;mv<|FY-dBrPCreHA*VNnlxj)c(8eSa?>hU^!EWjA}5)yzsv96|ggdj}HZ z*#r8DsC{MM%!GGz&|0%K=-C|XZ;92mutXC(%Ijy-S`5 zF)~S0wAdOnX_0gzEq#%ANhEO{>-$@o_0R7A zkolEMLDRe3BqFn&Ylxo#1&Gidw^GLmkrdYO$LtRDDuG-W7?A_@+wc5$IZdnm@X|!y z@<_`*kMmh_>uZf15T=O$N)}T5?8MmfEA5xqCJ3yACl2%93dJw!izKcbAG9luRwgRI ztPRXjeCDe`JJJ>OY>8juL>qfD>-U6k+_Cr20_X5_jR|`*B8lq(Ja}B9rT7fJM4f}q z@=(ZrE3K~rLx|m?$*9tvassrFVww3MA`A(aA0@$~96XHReipN39%g&XZu8dN5VD^s zyT!X~vF&lkcL%KGMPZS-f3E#R3s$A$Js>5fWcEUn zY{(c`;mZ3_#CrFT@Zh|Z=FOG*1-rQj(V4+VFCue$7VwEusc-phh1Oq2%0A=M+PK+f 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

    !RIG4c@S@47CeX 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�#{nm3Fr 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

    u9)mh>OIwY_sh>Ye~dowY;);M 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 literal 0 HcmV?d00001 diff --git a/pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.lib b/pkgs/raylib/raylib-5.0_win64_msvc16/lib/raylib.lib new file mode 100644 index 0000000000000000000000000000000000000000..7834a84931fa78491f8a474a0ea3086ec7664e16 GIT binary patch literal 5365858 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

    $5xdyVAB-ploCEj;}3;pU5EQFHTB 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 z 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 z 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

    H|`OAA)D6Pj!dMk8r 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 z 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

    DZ#*0Q%y6KC^J5ScB( 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

    uZiJMU?8?JM%dB*oauv=>;md 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

    lMI_ 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

  • {9D>hl5aWbDoILCK1q^; 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%0DZ&0fN9Iywukuv<25H>r$2T93e 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%0DE+kG+}*KlM@~JpXs$IZrcd?vm9zRjf~8 z=9~!6d4hqs6SiYc+}OB2rhK9T3-_ORw{F6O)ZhW{)|Mebtf4K_Hqkg<=e%89Hm<{GNLbvJ(W9~4x{}rUs8emN9>39+>grQ%p&q+YmuY*0 z3m*(Po*5IuWYaIbo=!3duY5Yl&5Uqz&Tss_y@ao)1zTQyEOX@(W!Wp~!g~@GkCH+p zx&V++Ak=?{!B2**Lu`cIZ)9nA5LUH_G&af6WQ~BmtezDo5<2{ z*-s(CSLgonl5t+_5if@E;M^tR5MBzJ9@D6(OnP%)#5K0*F%39AY)Fxi8D^ROI;Sgy zQ|oQGPGeY7+LuuL;8}X*EqDyWDpcjF;}G#!u=Ce&NENNOGG9?jR*A)sVJKS5pijU1Kn(C#{-E8swk^w zWpYoKvG;X?a8BeaS+Jq15WB>>W?M@Lp&U`Z=KM;st~tMutZUA%BkKrO;Fghf&G}Vi zUGq4b9Q~gtk1)zc_A$W)j z#Vx{oy(MHD{Aid>DgW?AZGXP-oN{BdwuOC&XZ-NDVl=T_MQ6;OReJwAKO8}o^L}0| zOI^5S`TE(RWThR+qVTQbgPgFOZ%0k|#Ri@;SRD?B#wW73*ISYI0!;@>Wp7s&q66$! z9%O5onBBB`X2jkGVJ6Pgkxk9sUDW}xK?r(>uja4OJShO4j3sL-?+iGU_OMkuM>1;7 zNJiO)p|vdYJRHa(7B1<+>$G`VCI%Q05zX|m!<9&C>C*H1)mv*!ZMFnxrS;(FfZULl z62PTdZ#BBv4FXe9pM}{*3T3);=()@n53|wa8lBBZpEpz=e$iT9@kRBiOSD#p_Pji! zr>QVhdnM0~o0Au_73j1^Kl-jsqmzG>v#L3uM2H`&sK+<`ok{4Z}hr`NFBq-#C`G6n*PR7^O6k}^Uv#+ zdEbvjG}JD7VGDHa1&16xUZBD@BUq#q!qH+E?lNcj?XJ zjiv7Ub=9Ojx~orS6>^IK?Vcc>|Ri?FNs2=T+0R3 z*3aZNkkNGDOXivNdXNkCDR=78AZtAxutTY?d4WmZS}Iak%T1yt86Z~2Up^t1~&pC^Z$O&^SWx3jLeqW+E#@qqT9t~2c>mz&8y zY)R$I)`CUB71I1G#=$)pT`nYe)aAx4;uVS)U{P;8%vNYwK^DPJ%L=<6>BeN;SnM%= zj1nVDil34niU$*hQ4}=G?_?taan(|~IY055f z&k%ktygVqpJm~;|T}xOf_7#fH)I+=6U}q1QO&0fre69J=)n4!(-G^42){I?4O;cM> zL$M)eC55d^qq~*`Cx_KAI!$ybSaebIo>9xn*+lLw2?k9_BIbCFvMhP2ON^;R=l?qd z7CRA28?|6P1gqMpC2Pzh&{8S72mBo0!3MESzM2||Fq;m03Y%T!iB=p5^qy|JdWY zS$;jtU7HW#mmlXH<{ALZvQy?Y9Zt`uPDS8XzQfpU{D(GWr*Y9Tf8=Pq^32udMGx4s zF78bK%En}d;AZE48LSvw2agi=;o9qB(_nwnAiJERM zSNqnUY6JR!ZdPtID}NP$n6vINR4$cx)P9ekKQieuOV>Ged;I1xe}23cj3dppI1BT* zO}+gSh72r@bf#-j?s8F~sK@V_flaL2{H?T2UxG;q`%;;ln*I5kk;awkXNQRZ;sF!B zmv%rQs3WE;MG`fI;l6{Yr$aZ0%CgXQ+;LMcv;%7HswUV@p!(w?IzZLs`*fg65&j

    <}Ki*Vh1S!|3nT;O5fu7!Q1 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%0DwQ)? z2@0pmkFAx()=ELI%AmC|_Q%BLnP#5-LeGV&ELD00Xrv-Lye~J#zeId!LN2o@?`#Xi zCG+MWn=$U?o(q&^^S2mR`5^N%bV*8#d!^-uPsAPW-0}Ne-#fAx{TCI9UDl{~oPty3 z$2`hv@(OyL9`sI(eSM~tj>{&b^`|u`5;B*T;C{_=Tlc9nV{*gF@$A7K_cV~6!r-&U z7o#>;?)L4M#TI@;F>)WeW3OY2DJA)j z2J>XBjvuKGXjoiCtR;;@7RN)v1@pg3aG$bVy*Kcn9o`$b0g*A{^g4&-_@67M`>g|6 z%*8W`lOuMMjrZP?BxG)KQ16-5{MmAIxHPeG1@`F{RnDT|j6ijUZ>cP{SJob-*)>C>uxG3USGt5zId^?ljL0 zb5e|}oRE1~3GPhKMaVYa{4K^+Ka#ny1or^Toi$^>{btPG&m2Afs8f$M3r;%bWOMr5 zMJFvd=~y#=(V~+VnG?F(JGxe%TUgn3c5i#{xsFoJy)x<_PC9k{R_K)+DDwDq* z%Sz3{-tNNOH62~u=FHRQE}pw^!C8g0{k@(2y-Mgy2pFf2TOD%M* zJ_nV{r+wv&7~!0*)g6VtHC_GfXRqvZy4@oASdz+j3)0=wxw_EPi=W>9b%nnEZuG#e zHE4NnXM4YIN$2V{t2%qz!HKp$ab9rZiOTu>)V(H_E#F43m=X1BU*6w!0mEo#&lQ%h z?CM;-t37jWXTR%@<=tym_oJrM%v@Y3^C7&FuGe&%<)+j0;onko0{+)+dd%5)ocVHd z9%j(awaZto>F6|FtM%*0&I#S!J$B%&>h9>o*f@VpXJ5Z&rYU{Q{PNDezQTf|3sctY zgJIr}G1S%H)xNUpqwW1&-Kz`d*m-Y8Vey)tp6*_?seeTmW)7sC^UK+t=XR~`D_q#s zzoKwD23PlmeTDsI6^>fdwX&lyd)EGK2hS+X>t20MSMRFAy6!c-g$p`+`$+CS$NOUh zFYjL6*VWP4TUg!QUs%(}nJx)#-@cyCRMeyyQ+O{WQrfer`qw5X@-bB zHqymiAMJF}p1h_X0S7Z_MzyoX`=NeJ`^uGeq0i+tmgXTLoc&MoBQ^BcA9KX=cJyDN ze+7q3A670M1qE8@L!<@FJS*FK&&62pU(vqWx}p7DtJbVahhpLEb(wni4=c`8xAfS~ zes$!D7>e^(V{YtJE_b;>I~nx5HN|Ncy(r-Ix{W+s> z+@kr5Pd#Bt;fTVN_@Zc#-qn>X?%oriyQgUVv1Igi_964dB91Ar3J2 zqucx23msj3SXK0Qt;QzII;_u@cVm5m?ZjlB&=!>zbxRj@uIy~@>paSCyiJ{!%nw>s zO)zgo~`#yzsY(jPH7))P(*UFU$iR($M1%lDF3-tFai!~UFg7?zc zbg=vF8{fs+($%J~+ayjl@UU9yLF?MFd1bc@u-3*(!)~tIEoCk5?97!N%Z0@l6g^y| zCPO_)&3lby(6HblWpFST_F~Hgm0*#*E1{f+xv_KQ{5%0n@t_P~2@?p;!X{kGT51F4Mm4rcv6XTH zqFA|0v;daurNlzY4v?Kilt8$$g4vgiWiaMwZD;JT)8zi1z}&vnPVx|~ZWj{i!dByx z{|%nS*g1onkc}xa$T>ojRamkqitSOn6L0LuMJ-uD4un%9P0clRSib->@`y9V8E1KI~W&eHc@3UQ0JOd#;Gqjd2 z=7xfwM+SF&nz>c&J#GWYE`hUS=e;i@2Q5mb9=)b#W#`(N3zLnRX@}Zbv9NqiZy(0` ziuOM2_FRCiS}cT7FSe7CvCAbeMzGwb_F-?p?z0u}SFJRr%_#J&Sl8FJ9Qz1>&$FHj zRv)#lzq9WMtdjRBT+r3aU69jB+F>$Rj=_@YtU@GGt8_7>p`P8jf=50$G&l;J!_k{F92}2n??pe)D70UI z!vH*DWP6HnGXV8i9}do~?qAs6!7YKHF9-KkI&9ahUfGRZtLQez;KsF|gRxV1Pwjbc z6%3k3#4olTGdN?(Y&s2tW%+s9?X($5{?3FHCLB?~eA(045uZLdEmK`K|8aBKKYZ+l zG5-Hy{z|$dna#NMS#&mw%$9@vJNmeJX1Df&WslZ|Cisgxme`47cIl>A63UM5$%H_) z_>9F%=AZZ>EcO0B;@$$R%B5=n-5?;1gbFH%ba!`m2}mQk>5@+AP)blyR8&Ig5LCKR zNhv8&LO@iI4hiAT-t1Sw6ZMfF@^x zdNfgoTiaX60+r6z6?lO?Okf&-!-DTZG6sG(b@ju3Vk@NnNd4Q01s-i%gl~o#?gBi3 z2rU_*wfs}x0J7#Eo&A!lzYZ*l@mK*(?)M9_u3mup5e_w^BMuw^;MR4wM|ee1(j776 zAAS6O{rBlb`h-E>NcSSjV)zSM|1akF2UGdiLH~z#z&GS-g_x5w+}RZk9c;c*BA34apr2A2t*}oXYx=BAA1*PXXNQZ zbpdpC4KHUoxVH!FcMT}Y0&0_nsx-m90rV{E|DfFk1gq8D(f=vg>ye}wTa{28l2gL)9 zr|beK(*#7S3XLY!g$ zMy@WxA_aa~1o!ep+Va#M7B=wzd4NAI-u^y@8KTv{jiciSu4SC5rQNOUfaVL_@a}LC zT$q|XaJh~LNEvbGSPdW?g9Y4fy+n4DBuGi>=GzcsHuS)#07X% zJdi+oYa|GG)L#C;Sg?xR@o9K{MmgFv*4STUZXSn(XiisvX+JV&wO zIf@m}QLK25V#RY5E8e46@p8j1X{c&w>TAF>T&dyi?yl}IRO|?N9?-mjLJU+M zm<)&j0=@Q z_2H=?M)h*B2Zk3+2OtIX?q4)Q4FVxtTwT~bko5p>aC6{taKD0@Bv?vhfRZ&rY4UWn za&-dU5U`Kb2rQB22kPBlV8l-S#_~w@uTY2Io!MA8+dCa>?{6qj)Da5|Zp{7yM9l#? zK4PrjuK_{q0_X^cX#@cPby^xlvq0fO0FWyVtd3u$BQMy1?L}^h9T40wpq?HaqXSFG z)fTzqziX`!Y9-izYZy=}5d;d+$$|3)h7$Zo5kwK_Urx4mW6C)gHX7Ck;;K8iI|>^y)ASY5D5I%O|1`CBaJpNfxoI^(4fD8$b*imMrpQ( zUj3T|cmxc*n}574#BK>f*e-#<8(SB+H8tW$f~W)-w*azU=V&bt-(PB}nRM-K?K}bf zXdz5bYi1ZP&tIBBwaW7H^3)0-h!1&Br{xNaW@zzXz|o-q*cP%9AaS$^42<9FfD8ge zusCWOdJh^7po<+*XAgs&{sRBy&OjdL0|Oi)Nf0&$)&m(LcyQVgbO2_DAQ&*nB^S6a z2u1>Q{0}HnS*7-|102X2`2CT$qHch%9F7@uLnx%`(q<}}GG@AlTJmP#!e8@}wyeCF zy0nJ0qP(`5nx?dznVht)w3*B$1qD!{p(!U%?ci#OnkBH(fRzRAQ4zP#DAZjLfn7ES zA(DqfPf+3n3HAXld-sFeaNy0=1y1n8P-icImpk0q0CMN z9r2I0986hJLmQ^7g?Q4{R)uLRD=5IU6$JQT`qFyxFl!I+9{_Kp<*rnzFxZL4+X6*@kk1 z0j7g6X+;n$%nKY1lrigJ;R45n{fE{_e-?^-{!>FQ)Tuy9Z(NwTI82ruCQA#GV~5Gn z!sOXu3gCZQm?Aq&krpP+4wI&Z$*{vDC1K()ZWs@Y7yOYlKlu6zLGY90k}xiqFo|;AeO15NC*qtUruiS+{NbbeXIs>g{dN<8 zKtXV-{@L(=r~XTSC|U9wIYeA7G7iwj%gMLg4HV0+~1g-$J!H z5LHkUP=8=eqo7C3X<&JxtY#DxWl;lB3C!kyK!KVGBKbU!;ZXogZw<{6g}fEQb@m6| zsO5)R{30|g?F*8*fsIC4{78)s zsBdr>2k-~NIKWv$p0~pkg5>!CfMkp?4p&=S7>A~!;@{f=0IHp{8!wDQU5oec?EnDP z?ux4gjN_uF^xxY7z(G3%7Z9PAL-1ysgV^k&+Q%U{0^vUv9!L;-Y9)U*YLEfBjLfZ2 zt`ue%5EL46ho=mDSK#s$am5NwH!4&OHR|uR`{!$@HAZd0(O&=gI*Jzbf%g_UMQWs| z0F=NjfWQ$E)(9MB2&sV7L=h{2>I4W%5C#R~aJTS*DJZMSBTh8Jp+x<=uY)FktisX8 zzv<|pF*U*?e6ZNKod4$^@M}z*;0*mAemFUieIn*8?IDX0)Tl{=FlcTLZff?wEeDXa zAS~3v-5p$01FOUmaXEenCsdz6=LK9I5%7-)N3-;@^{444n#%D~YituAjS3r?c$0Y3CzN8mcr>RM_*tCQB1|4(ooWuw2t zQGO7eU-Jk3jkO!fSiM4x>i{eZt{140juvWQlOqoi!cg;oaripJIDm!()6vzImsUryB!t}o@vWmA`^a?E z!Jj37eLyt+txy48h|uQ{R@`AOcc|@OSUn7}T@sKt{Fm%Tu>YeVM7%gstRqE&2Ta}7 z#TDF@fPfWOm^ui>w?{SqQ%A5zdg@U?T~`p2e;_LmK6!e37>9v6kb9bPzn0*3IhYdfdblNo6Rbd82&z6rLXNUn;^bnpL|11g zqD~UkUb21YtYmdOon+8iIY~YWRmq_;Q_0KWPLidGZjvVF0wphX2Z6RBlKFXglB*am zQ13NJ63#H34Coj|l_w;tD}RhWeEbF!+ELcq;YxfBWq zsRI}eq6}a-s4@i#PKV0*KrV%PmXjJKQbs-dfjk7H#|LGpdZ}TeHmUa@!H}OGkV{D; z9(zcvK<)<8V~`s5_xHz<^)T23$iINZCjVke(o#4_CP{>h1(SpMHs2SA}ldk5qu@QvPj^t%HICI3V@mI?*|8iyaJ>e z&}Thr&FeuKe3lS-1L6sM8V=T!q5)Zwsz>G%`{NC;{r%Tq;>ZsYhWsZ)60u&t*9?5u zET~5Z=@>|eK@X=8P(GZHU-FOm<5*M*0no$$?Zb}#cN_~7;}|*`jEIl`9}gD?8}W>& zLp&qu(7@l(VqzS}!okMFCBP>lB>LmS`^N{249?2$6bjDA;RIla&#yC5T&yZ_I3do( z;j|fwE_pb;i^Y{ZoNAXTBoC)m41RDney1U88_B~7td`{A%^u{3_s-^NzATcK5cCA4gRcfu1g(+j(jT9LehzR%(AWWW z?ElIS;K(gUJcj%u9o}s4{O1R}QhzidxUjhm*LPZ$;Mfq;X6{KFJBgi#g^-pNrOMiu%6H4KwzxItM~I zOv^dwL>C8d2$A%Q%&d%us&D94pY^n_F?Fbzs8xO6bB z{F-N4GK=b(q+fi>E7Wb1v%g)pM%~HB{jyb#YLTy+f4-KKY3$}~^!+TxDtq+p*ZB|smUEuhP#79dFboL4;P!Ku$!;_Cj2l|Cm!@@G@KTD^y<4Zg zC@F1@7tEiXx~OHBjw2|Hs&uB3RT^nTlEp38XS`g6`}RmBMw!pRZcxml$|CNZ`> zwdbmX<06tr#H)7<$-dqlTotG9W~k6jOEsJ{+6z-?sM&oLo5&}j9YcQ7%%Z+3b)3%u z+E*y2KG)1Ye<^+X;fkNDqro&2R1fWs@R&jFLRY`Gum}VHf*i@Fxsr{v*;5O~;hU7E z(tCwpYnXvS!=z+4euZ0xU%@O|pzG8FSC&G{OtX~zDQbdYbI&RzKVxDBt4oedJ0%&S zP`{4(Ih3o<-LBu{?s{cUx!u0ueA6gCadLhvwvrBuw1|N$`nA1A74|K9uR%WZHI~bC zISTSJ-)v{Uzs&OzI5ThD^62&}yO3cz6&+h+4!-eX9ekhTMJ?Be7_Zmgi8P405~&%@ z-}9bAl*Q;C|1L4l@~1525Mooo_HQncF7$R+z05pbFtpt=_l4GTMfCe>S}L8-pYxx< zE?nVE431EWIaN~bS{4Gq|IDAGQA;f1{TTarZ`PnHvc|__aKUpZnsrr@Uv_(NOMb@c zCEGLHFEU=XG`_xcyC;{fiAoARuQwF_)-n#?_0ku{B9aN$N~-I3Fq)Fxly{g!7va2# zpNn=wc5&x^s-OP6>aBFOeRlMRmKEbcOcdgfY^CtMlEQM#*3@e4t z$RzTcTod<+Ja5jea3ZD4kk~{Oul{q*&nON@SDOBRW@TvW%uxhxLN&99`VE55CUgHlEKq*ICe$;P8^~d^{>Y_U4*zZ(PZ(*)Sf$ zc+bs9{HkVPMCQtZWwOqz^&N83&#*r4b!wK7c5=f$ksYRvbfTT>!c&`Tc(Y8nGJZyl zTp!JYj<4#%ri?86Q?P0k~8j+6a{Ev zI@NWwF!su_xt4Y)xf=wbJNP$Rh<>U)ek|CgeoUF>yX>ch!jJ-el_)0-=i!-}$IT&-0`x z9=*ir2t+T6Rem!{`AY5Ud|d0K<9kcnuTlor?&I_OQkx!r3{UR(e8vqcN1KNVfxjqG#f zxA@?(+tU_z8ri(QR#*mPbWx(AIaoCFi!_|xzMM8?_|RkMa!!##ELU0_QyR7{mVHXR z3Gu5X-%jR-iMGC1Ox{u59=p5pHBBX`L4<99F@a8k6fYsVm^yOr7VqSbw;PRuLvY=0wjZyV=+cgO3<`2d9xwg!s!VZRdJ4YHjuLqn!|s}%RQ>zZ}&j$a3=_$@u^>}Y;1CN=@3TfSl%cR8$J@@A2%EDA}YP74oGtYTKir0kX^y}WZ@`8DB z#5bw}s&LmhEr+2z3vM}6t{KJu>HGr;HSC4Q^`v^ZXB9c)UD|_*)OxNBLAl|@kHvRJ zM(@zYEtBk!0eyEKfG;%RRr^FF?E_sQ5- zh@MV}c#BVUq=^uxck-q4r*}Ggy-{lUJ|J++=6U#9e*RLOt#6LwOlg0H+s#oDoK>4M z>F6URVPz$Q0dK9&M#(!u>l-yyRc>-SMhhx`(|?q*ZjQ5)&b{iok*{55^{p7Uc5~r5 z{Yg>TuNfujcps|qG2gfZLi;vOIii+AZG_Q@Ycv~uClv?Uzt}LEy0jikH>lmh&vkpF zm2$6wwN1$>)vNJdJ!xSh-tVllCn-uT#=~Ei&N-<2=T|2x*I5mE*kPoYI@UWzkHDQE zytJ;KU6X5nUrg%4^IeuA#Iaep&?vk7gui#+%hgXbl5ecl_H!0`tin8=yN0Sa_0$+r zY)4MN*}awfb5>I2?RC4+yvk}>>9$a1UQ^j`<#pat%B5T>Y^js~R&QeWHhz~hfq#g0 zh%1CvRINFK{wLR}_3JPA>YqgkZk0C&Pg@V2$Lq|o;AwjJT|dY8lCkIQg431|JzlQ; zENrVcW}$^Ux>h!}RkCWTYSP>@-~Q57=pj109pCJ!%#+N_cCAzwy4#{Cj$h@vs2l#H ze;|K7G{I;Xhry%RLeDV5NjVUIR zW$4@}Pg8P989S@cS9OgtZ(MCwD2M8y_7~oytTxIr@Lc=6uul`i-Rl1=meDNu`E+kA z!}M{*QM2cTl2ISt@^>X)esD%pYzRH!UZhgy$E8zL>&KfezEB!y>0WAB!BA&W{v<=Z zGmt4TwQ53+H>Nt`TSp~AXt$Tq`s0iq7Nr6AzwJ*@BjqOddJ;|Va6LO$%%~icKd5VE zKL3=HEIl7*JuTO4TcTNvTi1P^XUo8Hus(e%`Oorb?1jZQA3hD`5~kZXRZv}oa{9Fa zT-pBC2!b7Vy1o`w%MklaW{st|inLmXwe`D|85h?k7xUp0YEXGM6)%BD>yt%u;k9!s z`4xnaK60EVIGxSNbfzD!?e4`LXOw-u`fZ9NX~5JznZW13$nUP}4?pQ^yLMgb^V)Hc z`Fa|HU%dXtkQRR=g!N<;bE>CkIP^Zg@-v-=*&AQ+)c|qIP{eE9cd7r@k8R zp_8LpP`y%sF-69xxATJ?uLgV04mk844QA#Y#vs4X5I=F{8Oxa`dX>ZP72C-)%GcrA zW@zfPTQ8h^QA7A=oA9|je|Cr7)O!ZsTPkd}H43;@IGB}il=6W3+ zJ%9>M^CXI_-^}^b%r$-zN*|@A&HCEW7-3v~LH0Cd-3|QB8DC$H` zBu!pj$)BR<*{d{7dJj4G^*2T(X=Trz&bz;z zdig!Im)~cjIs3_v@yLr9@%Q3k$w_Qj{Jt+AAQ^(iCH!-ejmQKIa4$Fp*aUBmm!MEY_ zU9r5qU62q<*zN4%T3d7%4oz15iC1^noE76?R%3lLu*%Wu*3OV|=OsBm#)fcT8{!uY8a87?lkO6H}j!xy& zbgxfM)raFNBo6-84PQ8JFcp~v+&ss6!)l^%d#+F&FEPrjksU?h zG;Pz~VP~yzUz44ubP^;3!5@kQ7sP3bRLbe-E2%{V_*HdPe1>BxnATMD<#C z_RCK~X2iGQz8FtZ0^_su)&^djDlWI3`gZQK(^HqPIy~JA{x-Z0 zkK=Vqa_UJ;hZr;pC6)tNSiRFd#34TdPZs%8-SpBoTd^`-efg8q{Bl)F!MqP=N4)h7kRuj}ES(b73_d!5vS&e9|j z{W^m_Pt0Rw7yP;5kyC1eFT#nRX^<|A&zjB;elaA%Rdv;D*$94Y#xa(eG&JvC-$94# zpC>m_ToSnyCL1g_IY2J_q2=`gZ`?PTq^9I04U=`^tCS_F>^LmYIPrykO84wCE|QTF zkXOzS<|}4JxEt@AXbP2LxhnN(vO)c96fcRKzEOZ3+jPGHw|*|?g6aipOln5QV;#}W zTXbA|?^em!V^v=9*O!(&_DL@1@{}Y0>{{O}{=ri5?83b&jK;8c+-JM?3-o#~Jy#}s zN9H}V=Z}AhjLFmBLx{4&R~+@>^iejZrMq!d^9_2pNpg%P9?8A6!*u_?ZK=6JL^YrH zvn|y~%ohXwL!0R+u=7rJMXj-rai~Of)=m^9_})2zH-o!V`s{~pghn-Kaj@kxK9&jQwyj49zpgL569_j`{dZ$-Brx-=N*u=24(P;Y<4Uel)``_#$8X*i&1+3?#QHTtBm8d6Gy2K0Vnv zCP=d!#gafOyL4RhBQ1751A#P#>$i-8lNZ-j}qQ;QjR+|T0$UA`>nO}q3Hi%eUJ z92;<6>WT$i6QOd8RNs&CA8ud;TC73iT+z2L#;74U@!E7 zPc`;~@-ERBBV)ibTr$Ot`p+jlW}b*wg&VHn-JH=;#u95LiBgd` zsh?aL!6#~8L&Gok@!ZSA#8o?@kNY>*eRmY2M#yo3>11Sb9eoG`suUJ0IYVP8>jkrx ze6cd{Db9;uRyw^bkyvS`L$5Z|FM5_m_VeK4lP#O$cm`=?&yLZSU61Dd%+HSh^6Qr> z`GiJO4byxkJ5mvnjm9R7H)EKi(E67LJf3xWq$#=lng%UX)?SoWw5VNzhQEAq1y9{r zCA;8hQM~&PD@x^K9z14rfqr?%d@Yh9tQ6u+Tnu98&Q3O@U1{~2;yjnYZPkCF`Vq~z zZW5!!KK;*;hxbD~&>nk?daPe(7`w|6^{U;nYfXxku8UQ2Liw3M$p%fy5AH$P(~}vo zf}4KsWw#r*U6~xD3HFNvILUUj?u+#1{Yfn)CG@?o3zgeV6L>&oTDTl-=o+5v`o{dg1BQAgSs=mshLU zqu?*~#_~~|&@TRN&ip!_uDGgVPWZ#^ZI$Chr}fsc+B++ogvQ=B<5Eu3nmpOV#e01G z=Y)qXJHvCw&tt7YD%Vp;%8hgC<$G~dXKu^Ud)GWEr{d~QHpY8-Zb0ws_nYB53fQYlKaIOEuB-bg3%xmb^4;xX?c3~djY0v?i`bCi!hQH-&g`@>f) z+CEs%oWoDhJV}S+x3s$YGHi#F7Aczoavw89!Hz3S$#hIJyv zMe=&A!jH=lJuL8`rgHK5tF!$Ub~P9id3js1V>Y}gqz*3}1=l_W*rpi_Q$Aq8!{*af zpz+TAD(_WiBtoL6v$`>~@YXZ3>8iBx7XMt}G`tq8aJ=W5DqbbmQ*Y%}Y9^BV_NJhNM_ol@drnoQY}RK1HQC%pZ~0}- zY&{ew#3_=#&9~eP)>&M4xf1o>|d5eNMCX0^3VQ#_ddi@)^py4yVE4pVA-p-Jp3H{O9 zUUP>heX6TYSh1+-cImFk3QnKT`ztYOeQ3@dT9qDF*)xyhwu^ZS@B*6xjGKiLI`Bj^ z#3p%*Y0L4&WxAB3ooZt>tJE&X2=0n}r7+~VLGgh2$%>{8O%eOe^R~`jB;|L#zKJ|_ zk?I%4werf|qeWZHwIdYSKizw#(sop*wD4+aPhdx*%5hqz>7UuGZgFAi`bpzG-dWg} zev+EW3^6i&QSnQ=D~dU_eRluh)1hxVJN4C}!mL9Rp%D>;T>+&zZ?#UtqzW);x^_Yp zW@66$$g(t6Hs>H3(o~c5-?5q|N;b4t)vsA#Dw3hi6}37?Cux(8yIhumC7`65f1K#% z&08i8{%!tw!HV>e%wcbiwNRV0R0Li6Uf2Y`BzTMZV)}Wv9PDelVV;#yil3bK@ClBY z*KbgV52q7w2&7~}`B2`HdD;!z7cbzqYuBk=o|B@}=e!hrKWNd!8lopYSC))^ucak{ zX4XOuOV1h>RKsTZs%nvlZAbJDT9eXFR2QWTPuD6FHwn&;(Mx}~@N{vVtOyyR?GpVj zhGoYV>b9cFA5N|6J>ZFpyC(0f`9hAuu*Z#E^dd(thu+|gPvR58#H*-T+@i~No3IRhaVzgD0bhpD9Hbwv>I}ZH^x%wG zR((QScdu9Ulc`#>)pHWt&do2JO-hNOA@@E!d{kXFF5|dx={UZRPMFg4-bx)4K`mQk zM;E8!joo*VQUWzwWEZBUui{LY<;3c=MF;S%89`+&jP#j0rf4cN7VC)}817O+ zmspAB{?Q~^)l}+dq5$o3lLw~D_Xm}+=Ixb(I2;#x?N0o7Va7t(MY?mVuJP8t**Cd1 z*dzGE%Hj}Sk6|-4$yd8yLH5lvqwyz`6L&f(SO$r5Jzt2d2V}e_*IW01?5pT>$AF=0 zjN0d>sI#fgGL>T+#df=&cOf6$c_Y3$M9}bFU)8G8O0DSF()}FlWP-NFm$@80VJa0r z^vz*tg3V|DoBb8;S26!)-sLrfUr8r1rV09&a0oxh{*ttbq)z-8Vh`zK=ifR!ynk9= zX+d3-Bw+YNG1XfqkN4D<%OE@K>S_IZO>nw>$PTOQ=MBjda3r7`$epiriKKw+um-M) zR?iluFX!NWk>5)0Ri)ugd?Y{Dtojzip=680Iuy!rn6Gg?y2#a4F~ZduAYojCRZ^2( zp@ilF(Z%(m`ToW8y=D|KEcq9NMV->fyYdF#5)V(cJ)V$gx1|Q!tayLZXKOcPgVBwX5|j+nceY;s%k>{IWBYRJk7x=!rgaa$arG$s!b)Bf;*t zj$QLI7|;LI1BW{_b#oudKuhdgfZk8ld?C@Bb&_3?eV!a5(f^H38I|Ahb;=GiLUeH3By-m< zR=)(IgForC(GjEV6E+0 z)|noDQ${=4a2Q?a`#Duov`e|h#Ic>RR5BTFE?!g+#>A$m1WrBd&o^h+s&-Z!HZ{46 zDXegrlcQH*AB$ksJaJ7tB*E34{CrjWHz55g^OZ6EYBa6TJqh4BZaAagr(3CzTJNwt zj#Ibyo(7s`mG^@7;du`?!Dq8@VvLVDLw~3V{f+yVKR}lfi~^Cqp@(U5Mzz zFFKx2UI|ao@l7GWpm6OBb2*)DIb{D7d9vK_D@haR=B>_faSAH82$I=fOA2t*y}-r3 zI?`br!+LAl#Gf@WJFLR$43o2#tV|F^e8~-M+_i6XG*RNQQ6o;Jsg!J#o=g=^W`?u& zfAa5(CrO%R=XW-mF-uwU{j}B~I%Bt3!0wF=p@is6ki(E5BB_?mIr){icUqjVp-LfbG@)tt!F!EVp_wN#& z;)LR79y;HhWQ<`x1=)9eo7bn=>hMM(|7XmlCX(@r{%Wfr5*&*i5qZPAO=JDOt6eX+ z_@B}#YN__$d}5Xyl@R)1fW|YlvU_8`^??Mdh5Txm$SGrt!P@j&#Fb`0PE6=qZ1D^P zoNXC*3Li+rP!eEFbL>7R+OUT$*3{VTe*6cc<`>dj*OO(9ck*>LiEt?Wc5*~h)w9T6 zpSV2dP)M3sU$ORPlhUFsIPF-5j83yiHC>S$KDHVqwhXWSutH}%vyb74)1nG-_cXel zDeYcMy{BIlm*KwC>|VwbeEPP5EZXUZ?B(?$^Fkd)T!iWu_gmrFdb4LfD<>D5pC`I6rX>Kboqn2IF`g54Ffs1298;nQAdqI*8PyJ@euT+Zn8T%CSGaJiMa zi^1Xsbia(ZI23ksgHPSHp_40qd3${?B`PJl!6GkV*iat-9ZrFYet1|rHr5hP{nE|K z;3;o2gG#)u8?x@lHrQNBu~Og#qLJ0yI2#4dx;1z9pQiMk(cR8ABg)mQ4WQMg6j^bF z)|Za$jU65SQ>B;f#R)!F6@J|p?VftxeOxEe?2WWW{b^CO6zD$f_U7ixA1>XG{-k&L z2$d8Qp|yh5LQ(A;_6jM8-fw)wORA$C@Q3K#EKNYz>LJO`TbbgQZs$l>;q7@(lSJgE zLG%vE8M(0Gi*AHAAB8pCh1N>hK0xtF2^cfejcHE>uiPl;F@035M)@?U_v1*a&!S=W znLSo+Gl)*V=xy0)#ikI1=e^grX{X*+s{Od$FmtBKY+dY?o#N8-q|(-orS!PW&GYD) z9Z%G&PTMAk-@c(XzHA}21MU4i5v8~R+z-77zu3cbUxP8X!cSlsC?RKTdLg= zQoD1?r=ouD6|okz@6V~~XA?i=GZuy89o9R-T$8e}y=#ea%f{nAjzq26%(l`toR@iR z(0&ffwzbSWfROv64wFr*nWnZfS0=~a>iGe|FF|?b9p^o_I|aqOWX&5(-)dJR_O&K5 zpGcRiOcT(!qnrCP&~>us!%Cu|xAke8zL0Ah--j#}CZCOBkT#rpG0;Gh4m&1gLN#`F zoZ9r_MK0{mak*n_c$XDZ?&vlSgq1E%x>?e7UZUjib2E^aL`nMbSB zH(o5TTk?J)l(Za4`J-@khqQAIO~!z4Zdh{8FS?DjSnTA2x~xr{WEt3W!S@B7N8}K`9`p-*C^%61lu6@ikQ|`dgDu4H` z^OQ(@Soa(3_X1;~vJB6-mGXtOTKX4aGWWYNk3S|_VQ(ad)}vFdvUr-GH)P8q->lyz zh7IE9Qmc)@UJpWP^k&9nKE+t*vMM}#Xeb-#_^9YTCr2C2^eWjGeCLT4r2=1ytKm3F zH`^5WX16)qFG>aQ2GVcVRY33y9Tl4^IWOr2H^Rex^9u#Tf^uix`g%1E7T+7xVb#Vu zW}xV@KNi4g4qL#0N6Is&+{qfBU=Mm`Ca{LXj!~ukqbrYvx^XG}gmeQPxdpgA3XuNR zGi_diyQ3VSC~-^|(syW0Calm-ocR7{`S`8=))kI#XEaz{JY7t5*PcsGCHMLC<&}Mm zg0;ggU`mQ(K3a-x3o0$v#8iH%FZ_|qyvVr0odD8Y4e3T?CD^3G9UFjOCfCqj=7Km#{WU^}5r_`P63Ve7#tOaMSU|Wzjo%(dS~< z>87O2@J%hpEH>+QU$M_Tyb`?PJ)r-D!ZzU~DRB?c$y^Du^e^(|3{>e)i;S^4!|Cmq zxqXOX>efMCq5EaCYN|3`JLgRszv+i#ThaU7x!_m$Z0$`- zu9+X%Ics94dm8MgebdVJ$42G}Cm!30-FO^PhT*ec^~V z32Bia$JF@!bJky;oI$@rCKO?q*!J~_!QiaXd)fG7;pc~H z)Ujr)Z>x@t5QrLd;C1mag{Ci=OH5+1{yBe{g?!=-Hp$b|*>vc!ts=+&ZGMpa`2RYe zN39>2OvH<57vJL7H>sA_sbVxK4Bcl4hUSygKl_#UM(D!Kgz(L0n^kVmJU(8$7$jI@ zRCQM&3Cxqo2V1a`Wc@7Rom z_pc`#KW{^uTi=>;Qh1BM(o5!iP7Ye%adP6oq%x{GsH_-2=%~oqt|E1!N{gKDswQq} zocOaVu_ClB!x2J6UT#)DwmyaXVZ|9^%vF?1-iW_;mB4COb9+Ketx8azcgQAEsou5~ zYq8KpO>!^%X^!FvNv*U^^EvMSb=`RM$4|62UhDdE{oIz>WOaY;f1c}W=5?&W+s>h- zj&8#`nfCwpx}KJ?hH0{p8mTB7lhF!h`~SJlra|~t=R)7|L+dO|{JPuu{%8qbV*qbW zWpBVTR_#-+`HSOwsY%OVK$1a%dzp)#$%=eYxjq~uj&W@1t9PlEgU#aXg%^6IEO#+K2M3S8 zNcnKA|7BrUisO^*$2V;)+03t&$xMk)HGaC>BhBvAn&TIP8)IzQBQA2H=X)cG!Acr; z5*){8bdzZ@(eO;-$?p6Z$Fi@lHtsgRqP)7cDD;CwYb>+b{Efx1)yzwYXYQXyKKNv> z7g60*vAX@8mqkp&PU}nHOeDsM{M>s_GdnQuN8>Wdx;U3Tf3-YqoOUKEwW?rWh$?XA z$40f)Q)LYAjYN-{-e-TfYN<$?LS%qcmGPf>J*=q!uV!m2dJ z431ZVza?P5w?h}sea`p-9WT2)2ph}B|Bm_^19$ukY07;DLtPE~`*IA6u9VfRA1{qBl?=GqHfrjuC-?hYqtRoFH!R_1@a zMnN&)_5@$*6RFJh;E^*WYn!-B?EQ^W=$2aXDxETlQtk zH!`H(5uU^(^&BQ%EE&^$boI4zQ@HK1pYQKx?+{j-`1U&$$d=NUPPd(nY&U1Np+{F> zE#_F{Tkc+24miO%_s&;dsO1!cXug;jx3+++5O9{shc)~o8)PrpL2`6BS`Wy8*Qs`G(2Y3LiKc4jkR znFQ$YD_yLEJ(y=^UCp0V5pZ9;%_TEt{nFa@bogg1FP>7(OVz9*%eeQwtUp{~!~XOs z^!BEhA#oetN5i1#;1m)2=|c3mPw)9Sge!BnFK;x~2v2+-C@VcdMo{sU+o7GaItQoa zkwC}#ljvcwlww1Li5v3AudGqLC209HXUdfC{XM1GwK5#f21mMXAg}z%XZlv77)i`` z`uGB2O|i7g>YiB^i>d_=(ztqo1sh@*2abh{op81fUXzPgK= z?vWB+-jxxJ`N?*#CODW%}Hf56Fbr(qe%6ZK6tfNZxrX-l2~2;OzE9M+H=~MuSl`NcyG(SH}C%};{8K##_J=xnATMz zCOhS7Y1}dVs;%`Mj%3W7&-Is7EqA_7?LB&?x~qpDrOa}M7|yrnmAj(yT`H<@LwbI+ zhfEf$L+t8ACSU8iJP|>wmy%@*I&}ac%PWD)bgyy}%LU3;8Zloe^To}*jvX)0980nd z55SG#A4j-fP?u%4D$4oX9!2MhH~0^q{6E9^aLsxlb+fwbh9ui zC>$GGG*pB?6;x!1cH0>BpB^WsU|G&mM8_W>UZvA|Deqb`va{wEm}o`C5Ezs z8u68A&U^kAo2<5ZSABXaTF5Vs(1^`BGT=yQpsU{~8Z>Ymr+-$WhGwOI%C3WLt@7K; zjFk;vrzdUq!nUa9PgkwqT=001DmzilzNpXo;aQt<33}a+t!ehE+7Z)ve=Ua$ICJh~ zvffYkboi+O>x+zrUEj>`8_CFVwCAE#*!A^;COiJoRxYJAcz5`H zmsd$z){P&u(XlT3ItA^!8PjUogH5+A&8Jq3=VzvR1H0*CDRC#c7@s~Y@8ZgZ6^95D z4#__=B26M{cdR9m64Mov`9^>LVsD`KJo-MJbCXhbNlB{$-;P@3Rw#qrsX0xOCrk#J zad2Tej%e3CEaQ;If`<+~`<&IxVP>hMw|dCT#Y{dX(_hjfX=ruYmlAFdbJ5nCC?6zO zA02Hgs20ebnkSK6VXLV~Q7G*Q;5ffkF|#Bxx7aRsDs`n%c{oM5FyXl*I?XeSXWsfB zXejxq(OSHw7P2fEdEWRuKTUjLEX4p;?zY(FLOTEX$20rSw}|gpXr>%XEt@FxVN;qX zGJd`5J$f^W%sS~_d8ukd#pox=?(6wimK_MGik^JZI+Km}&egG_Spfb{Sc-9@ z*7=llx$l#!#FD!DwA}3^Wgd@4NNsL^)hvjgNn>fS)+ngizEf7KYfav3-CI`S)Wd%* zH2BuSX7BEY972OT=3gfsEZYp=`!Zj{?(S2ec!x4TTeEC>Qn}(MmVXVx-%99q$L5Lv zsgR!i`I3zIDhU68GV3OargGw)pJiqvpEj$l9H`oJ(a`j5X2NNjW4`xuxf9iXmKHg2 zzI3Ut__Xhm%84MF?92TY)C7qqvMV$?CQ^69rGR9RZ`Bxetc zC~4w?vwoM>62Nad4Ie-Kc@kO=f!l(OJ9llo#Ymm6yN=*Ey*xcp;#(?nH!wtUA@t6t zQ?vFNG$t-WR|lUED|g)z6)NU)xvkcAn@e0v+e9OSQ|@J$bohG1sWW-xURl~UdS}T? z2NyC}luf9j8E*Dmvh)?mcn`tv>Y9&GXeEe0@*yC- z@dL*x^TtR<#Eg63y+IQJd>q0QsQnf#|*EO~Rm0IWrsY)kjt#`nZ^s))LvCQFEPR zxO%jIA=dq8Y1oxwe(#PJsvV1yRVm-i2)DI2_(k}Lt82LiC{0sWxf8pecT(l;yk=Fv zyi2!m9`7mrY}reQ{;tcUUG;T*zQxsVIk-EBtqtLm!!E~0nYBGL>QPB%K(*!$;iIRU zjz=qUEw|0fZqp`MZd9eBnMZ>AX5iaGTTHLCmQbDM3JTWE87VR8WG@3!GKC>@(co~V zGBk)EnrMeHCXBgHHD5hfp+nE+(;fFT*=ROhc*8sFgxVE_%le6l(p}dB8Ks!1ckjJl zyI`7nPIkPXd4p3RkZlp2t`g!mF<;a-RjKOSF}9wZk}3bjzpsdP=BWUqL&`CALm1)H zE&(h`xR`>;;ymUXLWThL)Odm0!djC7lhA&)an5CO+e+_epFAeDoO-(f+Mi*9zK!L2 z!_>q{A*Icop(cTM65QQAXz)OAC!4C-em|t@shX{KW@~3ZQNRDW-M72%>C;CWufRr@?!+g=>joZf z8tWw+7t-MR)^i{H6;G&cy$uG|d^?^4i%8wo8q`?(cE8v~G#NlH#)yCKK4!s=xukyIe}rBxfXg>oF<;Brq7p>9 zt7@Ui1d$&q!-CtwjAz!5yU^&7Z+SO!^nVIJtZ?8Dm!*0r1AcgmI3p$)R@wi*iyv6* zcrXZm<&^?{XtAjvChcRT`2RaU^!WavyX}7InHZKrA95Q@PxU}6U=9!p7peU$s7qch zH9g(F$Qy#~GnS90Ts#C8!%83H$teb}2<}mO%b+jd-1({`!`Z`bwy_ozpwS&7s8PMB&W0T6f#Ml2#NFe4+Z)ZG0?voYu11vR zdTKFE4$_kv#8j+dYTDH;!2pzs?l(-+ggSIk;nvQ?d7@hxO#KD25;R3%zmnsdk$jr^ zIY0U51JPnavLx7#4wu_r{^Q4v%10*1b+BklU_WMG`P)+CH?Qaoexh?p5nbvOh53 z%pE@>@wVInGsGilCn7+oYoMIzVA#ZjoONcV_LGtTj{5KT_!gEhhKr5Wp+WMy@28`X zsBjx5h)Oy;puIs58b3e#mkJ<1!Fq4@t@)=@vu=!Sah94uokxK6{*I72@^*YCJv54o zA*XI%8_dVEV+OzFRJQx&$q;QfTYwJCr;fR4e>dt~?z2SC;P*szC@>%6)R)?i0`y=1 z(|m-i+CLL3!ES>2Sd9e*4M!Et+%|g;@)kuxgZa>T$#kIjsqupOEL}^O^Y_;YNVk*h zoHA{nf%*K{*>O9LPfkzRqSePrM^OOt@q^V5f4y#E%wJ3P=`oM-0L*8x0vq4x1%{3Kdb@$I~$Ra)c@imUWSHv)*yB7tUsH5^;@On z=?1M}!(jW-FGq_VSGr70r9l7EKqce(Md(LUyk<;7SZ(c^7;qAX%;Zax(?KM9G%Pkn ze61%y@HAm{wTb;L4(1(7&(qfjzfb9?h2kz07B&c#l_w8Qryf>Xr~`sF_Av6+1v5Wz z%QsQiN`}m$m6#U<q;*dngbG+rxD6f(rRL;TcE;o^@D8 z=w?*QMgl1x2OE3o5TZ4+@CW2PCys~SX`?G?mXcXBvE<@D4{b+GAfk+Ge9Ig49@0#` zqQG3z0s0Yi55{d0n*&xZRxCoS4yWf~z)1h!OJh@qm`{727c@%uWXFx9@3EM8FeM`S?X#C%jN79jwK)tM8I74@MFRlttxC3jm5o0RFrfD#8cde$E1NAU9RkJ0DOrzCs{Kd)f@N=OKCfnc!?lAtnu)tWN<@8S*-(i22!p0*pu-i9pY#5~X+@YDQ@|NYJY|0h219bfzC z(aJN!Dghb({;SFIfLF*+c6HZ00uQG(+&5iH+G+9LedrRX6^EZWTT-8JbS@^m23!Y| zFisp)p*R%!7Cz?0S@bW$mwDKeyve9}4*f2nLn|%RuNp}9gpJZ(=1KVYHCj62ezREk zKw~Le3sZQ)AhiHf?q5CZemjI$Uq-~8W82^M^~9~=f6~+QWR$D(HPkfMZ zF_CxFz|SGiOapeV{Rx+{4$Wpt8rfQZMZGqG^pQ8YqE%&4*5&zDO5WAY^Ve0ZR$qOo zi_Y~`)!nNh@>R7@jdPiSUhbVF*pZx+K3N>6>STp_aASqrgJT~>4^{`UB&kT1%Q8Pv zk>mxM0y#r}QiJd8bmRuGi`A^1o2{e?z+hc*RUNa4QGX&2w->27Kd5>Ey?r87iL>?4 zmb?vXZ=f`|i?LG;?bj32ON~Km#7|;})rlZZ^vU)-$Ue{?kUOCLBw5eBP4SyKV8R-O8vOFqA!tM2c&(PeU`9L2U!dEIn%yW#?vO#I1vvhs8stlxPQw^G$!G4#I}oU^&wi3>wdus?0azTC_o z!@Y63c{*F2u2eD^N3-j+xri;os0a~MZ_)tI13w4$!yZjXef(u8Av0c^->)~o&yloE z)+aIAc~f!8Nq^pgCiN<{b(d~NQ`p@>JEH6@jx=!@5*)NX+YRUs=*eG{HxNG&gg$;6 zGI-5E^TP({!9s4#n+SYVq@X|ZjyH_Br~*r%KPk8(pU;(AasYcTu$0w)fNZin&|+}M zOXvfBK(r6DQDL&YIP?o2P>8=u;s8IO50ya8z($r{q@%?-DdS08Ut0;vXU0ZEMWJjK zV`h7eJ}!dE2N-HjCJhe1f?KE0u*oOCoNF2|t6;Hp?On;REh-e#mJ`){!F*Ilr|sC9 zjnr#)uA?qPyk!q=`+Niut#_WRBH2+Xb=fuoGaV=56quJH-W7kOF>YK9JlX2gFssH0 zZMPymg%MbatNK-fwLw86mOFJTV{mu^HVVh& zmtFSsj?_J^=THiAqPgOwJ%xuo*O@{6J5i?SPw%?LTUWZ&TqMc7G0R{33{=~om5&(% zd9m=lRVn#qqd8)TX84T)J6E`DN~rGk=6N~9CVUZrH|;E)ph+tyyQJ;2mNm5b*hi;^ zTsGwOU0u`ahm5k>c5=x)vq(|gP^6!zCD{fJ+Sx(!0Xogq+%^;9YPrGkQ;=AeRAVl0 zZPS3C8tTKxWB&b4Y5OKD<^7WnnZQpidkjsjZ$q7tb^+Oyk$M!VvN0y;jneWvW(Hqi z%P?mqaZko*nZ`eOI*j&Nyw=$$(x(tlVzJ&dX385``A@*Qw?(5|m-QE_jxWMPQ`A_f zTFB}VlzI}}e6Lz)aTUT|Eo-NJ`QZDY&SAT&^eGabjnz#2SHCLSH?Oi_N_6$|27=EU zvd6c0r3{|Od~g_{mfzfhcJ!E{_axHfbBWl-#tXVRtNOwdrCt@wP&)0lR@guC=HBTFP4& zZaPkpToT$Q#-&$+N>Ccm7Zu@IHVZb*#(VFec1_na1gL43)~zbDpXvtt zpYP;|x#~~^+5@?*f-vTK+3|5QPi0FZ9>{xe{($p9i0OSTjksA0dwU}CSz-H}O0cZ1 zI-9}0Os3zWjo}eebklt+8_Ch7OnbJ#{QEG*1k8}X7iVK{@al*^r^K?n(;QhVxWTS7 zV#{)Rl3J$ru4l|%T=OSAeW*Op>nDU7Xr)anOlsuM zjPG8QdIcsVcfh$12RF-^cv)%+&e0>YeebI!!jbzZ#{s6Y&Oh*xP{X0LQDlt!aEo|2 z2>iWM(&KbS*7LOJXyN%&T5U2bPp?BxMG z!r;T^KZ!K?H@KDUuDc8c+8gubax2t4>upr9^&Llf&=I{Qbz&238&`A~w`KOa*8q6n zj%zbPJ(aIt?WkVwRfsmw2Z4R_Y4pPN0h`2=>eC0G9WK>0_fi2XY{p2DiBx+uIV@=j zrQ>l7vgR+?D%9&@ncq=0wT1S&f0n*_o8IdHH$rUVBFpN;GZpkfB<>l0HMwnyV$T7; zMV9kpkESF>pml6xK+*u2peWNp7EFWx386_sX`0 z*L%=dJq0&k7@w>hehu1p&8?)sMF`vHeh`HVj!Qz&Dq;e*<96JQb3v~v`dju+hhf}e zab&>LMvbL@+p6_pZMxi)4HSq+o|Zlj8Tx6GDaVvKn_pTIa$yrFzGi0Wd8<>(4u3WE zCuK27g6@^vo+lYMLgX2CE}*}5^@pqt4ORf>G>8W(E^mE8Vd3fl`UoG9!nSo9gRk23 zFUXJ)0trnSl9|~pAr`RDeZLY{pI#7mx4tPm`mn7NC>iT|Kkraen~!X<$I(!G3;p|R zHh(c`Pc!Lu(%=7a^cn1P%bz9%!J%aY@5g5%uu$hu!FdDXm<*Kq(i7JTQZ~r?CwjFW zKlt5Kfqg;XM< zRm2OJT(Ii+)j@#lx%UD8_DX;!28!uo{E0?qM)x zsD+L+NAi;Ip!N0`=*59KzJ*F#x}e%g8)R7cT_3fg`rCo$n2OU83C5(kKbr$vSF{Qu z5M`oVlD<{E-2GCe>`sXy{Op%~;ZuLdE}G{xx$;OPOqOiUBa(b*;ePrr8Z$eDf}XT@ zUo$eirf_L1odp#uzeA@OS8`C7yoOkSq+|tjQ51=hhTVCFWt*m)DcS285LbEl1-~2; z^q^c;vDH%Y=e0G?B~mhNtl6XAYyW%#q5@sAG{+E0n{Q;Qq+BOU<|1@wnQ6~#TBC9D zbS2{-~dANg|n`JJo5`Ye$Ki^YDun2}uAU{H&W*_Nwc)6ew$Ijyhu z_a6HZmQ7P5ct&px=RP2?I(z8$enMWdhEc^%OauK@9RIFx2(U){kiQVi8Tdd8e&@k8 zg7u)blK%I1>_KEEW1=@*nCiHYZy#*VuMk`(;H17v8ZCKz!D1bSBPzkg#PeUYR1)gf zhpU492>RPvx^0vHtY!@`=}*5{H`yc&fWLO^(O4jV|MlFIp#PE?TQanf#LsN8{VF)O zjo?rF!_Thwm5RM1du28yU)S_Mp?f3aapKQCX?zMff%Z9286pS!9mJ!+ISKq6fbYwp zRSOUOwrKz#0y}{R6XYI$jIh#)If8M5c)vo>RQJf^HqEi8 zLZL=gXFjm|!Fzyy0x*z6V4Q#sFz{1>=fOOHTn6KOUP;t|9X9gs{{d!I~Iae$xC*r>hhes zq+`~B5bLl%1v(7oe>7W{(|J;0Kqvt{RIn`5Q~thvvk@guovoIg=T>+~MK^mJl3XnG z%fS2N7oc~#*SHzdM$PQZg?QIt*ZYYzX}cL|ycU%KdRFeTPBoKCTU;~LMO3wvoo4*Biw$;@7z6M{35hTYpeD({LcZ___t7uM-{T6utbyZWB~F#-n)dmyH?(y^P?j3ut53WfBM_(KD2pD= z+XND|jYP$UuK|5%hx@xgLAE8&it{(M;s<9!$x5^Z)XY1;4^3CSJB3jQncH5M$lItQ zPZ|#)Sn1|S z%+88^gXd}heU~Cf9W8da%>gizkzvUDU+|5jJzCG0p@_ zFny(Kz@`VuLw!xC%(>NPrt6EPe3j`U)%1RADeZkkpi=1(IQPoY2qjhR8~l}i_|Va4 z89{>lorAc?ZDphKP{6mquI|#pMxP^I(p!bK^~0G4mOM;9Xijp7qhY`6MRWDMtz_YjKRq0s zD2{&qY$<|8f#`Reycw^kSQ)Xy<#LY>G-~es0Nk9DueUk>JSxua8-uFyKN`3AysRg1 zyq)Y0;}gg7VXjVOEGXBH#P2&{yWj>B&r=SL(qj36pGA(8B-Qe}LNoBIbe$>)ed~de-aXVk)(6Xy;{q{-7Mr&(+?m<0QsK?^w`~r?@UWB$%)i}J3yHi5V zFry>J^4%LfBd+fL zAu*>0&B}0pGWL#KWF`7dBfQ3i*QecbrZg3Ga6Wreh}CpPNH{VqPP7a6w(q6CE_)q7 zkQX0@rswNw)p;Brw`=uYl$~h2X7NRCMyLav&xs;S#o^N`GY93>mT3tArh*!Qca^C& zH&n+^mD{!oG;366akPcHZ^85E_3Q;&bPjcMPvQi2Ul|{OeOt#F%T!16t9v#)gQw?C z3QHU3a!r1@>L@g)|=^&_x%r&QkriZ;~CZsFuEJ?h2Y13PQ(<&6P140mp!U%8Te zy0RXW^J|0OZ#F#v{{X$_#74*Z^_Klu(qc#ng_U#s7Oh)p4E*lelAuJfs>TPeTB)@Z z6W=4W4(6Oc&^w59q;ij*_;YAApdTQ=Thpv&pxLm|gfpyVJ#A6nJK@rLUPZG>6j>C+ zuHqzQhx_Vh(L?i_$-pHT-p%`068^0_!}hQF*{-~O?d=r_#?vz#`-!i`@d300eoK)52jsKZ zm+xI-?d^}iuLIVDovawX#H=pM)CU=!(Z;>Hlz@X}FVmEiIVWr|*!^#CGj!>I9QSMA zsBA(+!NUz6x;TwZU{+BSlMz>kFga7!GxgD(o!qh-xM^_2p}9PpFfmg=}DT13Ty z{(yesDb`6XXmUg($=G-Zl{OERO}d$Jb0SO2vf)o(J)`0cI9H#~ElNMSRZj zUu?<~TET&`ExG~B<}<#A+%6Swfgd^0inGJSz?Z|Ka;M#zW$g)^?+}kZb;pD8$G&QE z-e)A0ULPG(3l+B1@S5bCv>N9#DM5RXPZbG4f%oAFYbiq(sa(UzDZGd_W|uNFH!~Cg zwzo)=h!IDRU`l1$x`sRiJxs{SCn1m9Ed@9FGA;Fsa%#Y*=hFY=cj|T>Xq?^JFai6p z!H2^uw??oR%=ceEDBKv`(|9{gA@GA*J|7L24qHOFrbGFMykO6$d-!}_{pT#kwE<6> z&cTm3S6^!8CuPV*suq^HxOh_mG< zBe5Kg31I~iGeKj5xYO|mA_&E$LQ?xe%inBV=fxmy#0L}851**(5I?ehw<8&)w7R(I zr-dph{$~K*H?Dhfpltml2$rB3F}(1`gG2tcqr=AhgRmSi?`#wwM z3{01eU*=woLEi+kn%2cwrsQ#2q{H~X>*w7UulvEuYPO+Uwe&s0p(aMaYCl^YuNYmn z?)?IElLf?nG=XSqAos!kA<`c5)zqGoQR`mag0oB+hB>U;8=FDOr1YpHs(DR%hEt0W zURN2XAaCubF+pZ-k|lSstI8ogK>w*C9=By& zq1{F559_{Z3bSdsd{B%#XpPAsp!+>YtYOOs*RNdeDC9?qXK>9gzLXRkgZ9+HqPY*l zAiuXmSTg!5KII44@2prfocYRqqvjwo$+r6P zhzGEA&04YWT?!0d*N}$y=P)xi!Bt(HKIFv($Py~wL7nk=PIH8ctWe)uww!FnqmweA z@8ORy@5C!9tN^U^bo?18zMtNp_Rb%mCU3i7>)F{*5gE4!w(|ftC z53Khc>5w|!tIMqaZhK%?Cy6t?_q9HK5Bvone*|EZsAEOaYPA@Ef!}aO?uFTRS!e*p z^&z}>4!Nr!9|uxT`QV;$TgI@olSZ+Yz_3N2srZkFB`%Q&(rK48&Pc!mBMwv4{$Hmk z9R~+Hx?coB#Gst)5Oe@raTVJ5qN)Y+40dJaeTL#@W|l1Z)sFbdE(g0rFqWXhm}xCk=aFp zW2MW05Sku{>-105Ii|9K`8?M9?S6A#Z2&!pUT?%F68}NVf!%Ot2ea|yOVBAF zrrf=rRP-azqopf3Cdbmv4`BXWAvIQswVE#dz;F<1Cug6yvuKAM`x@?Q$AZN3HD16Z zksxnE*{w+`dndGN8lq1NZ%{cd{bn2XNtsxIa0Y8_|KzJJ-8qP#0}S*c;6Idx;&6ot z!{P@R_;$gsD*o`oB0{|1IQv$BfVOv{wEovqt6JkV6+kak{V4 zz2)43dGfvbtf)kx45~_+g zwmKJ8<-;o5-D_<8Ssm059v7BlqUS2zKOfc!`qSq0sy$uL2L|jPL!rru$KO?ZGzKfL z^Cd89K^_Z;r<~bzkQ*Hxd4ha1VkeJS5`3#6Pq|4xlg$2Wx22#c-s8JtykVJDTccX@ z-%S*CYAe@T05cxrod5ofjD=V(gS@eJ=Id0sM;LmSlW))0qcYe+JH@^sc7hp#!3o_C-I!R&yJ_7X!E-oz1 zjT9SQGq3saU|zd%{fp}m*X=ZX&_c^UL9||{oJxcB=tlH>OQ&wlg_}QHAJirVeTFO9 z5kTM3O#+KF0e7UiE!oEd&7*Gv86THOMe8i65K_u{ma#9$8614K0n7am$y{!2>Z~P?fN8#C=fkK&As$> z{jBtl9u4N^OhwV8-h-qB{#}qq17FSh!mX$MY(O1!2%UsbVpjW2DrUJ+psBTcLTex4 z06Xsu4B10xGE&T0p5g3p?}wRj;*m*?)yAdgI#!fI{mJBBj z@=8nz**|z#-cx}%@GwR|pAHwBI?yM8y_0aZ8`8+K)@>-ts6inYXsm_56!CfCiB@%^ zjW?^~MjzNeYZ{yLym#vcpk4^b6>1WX$M_)Y_PPL)3@J`60bO3sJ=Kv_HyKToOM6Rc zOjR;<=Q^`UI@aNl2vfNqy}&*qz)!Fiv&Dfj7FBmzRr#84s}tVwjI46A#(M4-#e0o| zE2AD2cUFPjc6mnUVW6r;Uy`JBTBGj8XoSVkIVb8DZCUwg9wA3PsYB&D9oE!F+*V1juvX_uliI=+_}w zNM9q(W=E=<9Uo%%F3I0%uBGMS2_*Y*mu8O2ut&p_-!@{(qcRNlF5-z~lU+vk!K4W> zcelANY0w>NW=o)~S21dP{+y9mrYmejtZ9gnGB9 z$(#nfHeyY%`m9a3aowwmp-aMq(%8p_=+=~&do?4U@7jMIBI7>qXQxE0aIx1%ah>v* ze$Y1jwW;?B)ct_Ck;B#f%+a}LLf()Xk#E5cQS`)GL0y5#t7GYm392g>N2$uAisY88 z1!-REN$gkwYLGwM`g>6~q?(fK|FrQ%Y18pEGeqNnI>ZH1_qpia9))Psk z$viQg#zK3IUH=WnFCnmA#M`(^F_xP#V7)+`^MCbt2FM(HrM9Y>$i!bE^L3r;7LgYk zB`3ALq{(n#_P(soVH@LmW)Mx~B!$`e#rZFe|0jMkv3J}>Fv6mq`0WZ$8Zr9`?6_ODNZZdDS({QGc&^BUk}+R<`X> z23UN%`Hc7G5QxL5V0=lm&9su``^Z!jBKcn~{ZfydI)hXhe=6ng7Y+sSnD6|j@qv6$ zvET2Wn=Z;wLA=p|!GQg9y?Bu3!V7GSZPQM#t-BP&;x*9_@l4#&2|2;s7G~N5G=}Ui{f6RH71r= zg)}+?QO9YPOolzrW`7AC>;Z~RK4Pic33vJt?sxaG{Y5h|0lrb9CqTc_B3+7NFrI(C zeo}!nZK?79G%vT4G9bd}d&F_X8>fBWBNCYo8BR*1ZAm2g7zTsM_dzn>GS_NNDI!Vrb(=Y2cfF}V);ZUwu!g`7 zs{&QUlaadEDAnus4s&~y$d9xb@BygD0Qx-eR|7iWJ3x_nUc4-5cwjOSV5Rq9iJJey(G>oVwT_rWcM_pz&&p zB$X1Ew-O6nkI{*#nfRzO>&GMz$Qkm~2~vEs2{gj}+4?!#_(YlEPN?I!&}(GUhgk3k z{M0u-c8=%d>JcDl#yXKP%xdS|Q;7RS9cnW@K?$739w3BNHyfq1S_mxsp!^Kc5^c&C z!HLLb9=~Ad4{-0?-`fX77B^7j$zdldkjngQhi8_juJ!xO_+x)1*}#K%HfM@@kPL}g zH#nEa>rd&Atj0b9{osu0@4bNDUl{-${0{Uzus;9dNd1+%AQLLl4uw8?^7A`Gu%5tQ z6T^N@mftsV2igHY0I>Horj-g`E-J;S4+59)%rBYcHo z3>Ot^7M~vzBrK*LM$b=ut|! z?(f^qia9p>eiVE97=w_jmn~*6!+cO)_yRHI<1lE9d<+CtYIq<$$C|tr7Z0_B_e!_HiP|I4; zXkx4!c8Dll`5w6-Jv`?paW^OTEl{j;vVYTE z|3{tuN;RwEah=eREEb+Vdh=vL&AUj(-7LM1bA*X+hRHPZsfFDvAM$QqR~hR;c`wE6 z0&Fg)M7x<#Ljo|M%b4cE{~l#i0s8U382k?A_us{qMes*$`28xC&ZmY4Fg;_Szdw7P zZNWr|jR3n>J|#kBIoBe|3fP6-I72?+wj&JJ7D!}eKU$NW`H|ZjkY+O@`^$qmqx}l_ zF!NZn-~Zx1uRq@xQ(X>0eDU8rdQUv3Bxhj^Hjqaz%zjOm=4dex-NclhU_{KmKn^`4 z@ujs2*k4J?S_bcaO+}YS_;>tzP-Fo18o=PYmeW3kl+2^#%nHdkyQs?g5DIIB4jvKC zlgO52eaW}X$s>fmn|}X%&%g1x2(NWk59IfPI+hQbW-i%-=Z);~oB`C4kppg1@KTJN zEMikG(OWsv5Pz>J{vVi$&^3tH>nt1K==VlNu1ck{#*KcYmOB1t(R{GvpWLuX$& zxRnRicY0Rh!q=j^yqn zMsCKNVEy(2qYm~B;3Kdv{?k4I`vR;dz<=y}4-Ba<^MF55XBe;5Y4JucFP~M!%z{iC z#8D*+wc`YbxFi9;PiG>J7}_w@11xPV5Yq7Ok{Dn>|Cj&&#ehG-JpQ}*zq=p)<@bLv z;9nqjINI1#YeEZu3Dc%3AtxApb0taS5u9unA*iSpliV?JA#M8b$ z_>BgQpHL)cp7{qL|LXk?%;}*w=Od8&a#(Za6!&j80S5IRQh~I}=Mp7PAddo^=U_hn zVlaM?w*mAnP(NTwLaVH(VC&y_ijH8Zv`S~CC`{R+g*=?;a?QoM)zR3t3HeISIz9VU z&XECv1o_Taugj38jBVvK5&4yP5#tx2XMj8k@P1%V01W(O0Q;Qg#*qwbr(BY+5$tCY47Le|k&?9Y4kXZQiA}TU%>7E*Wp7Hi)3db$J7UsWwNS zQE;4l*TO-6bUjC$mlmQ!PV)ib)H=dc9m!EJ;uj^oL|IRB&vPBU2k^S!8jaD(_RZ`TLhLBCavW2U*B z;q<07h8*O7q-2>F5W1AV;(R21c}z}cK#-!}9?+I-j!UKy`c|jn319SRWy{1J4DNjs z7nRs%MC{4fshy07VB`2#$ zuOns*)SqUC^klcpUprn^fBQ5w{_C=)b*jQUAFg(x42Df;q;1R8*XLQ%70Ovv4Y8*0 z+&~b}X!i~W75FtD9!9aax$_)By$P)y)nLr6 zbcI95j>t-^im;cbAjvL-yp#OBqBL(y%8gB+Q7(+y{0JO^#SOK6-VSBM4$FHwuZgSi z(DmNMRw}@OL_G2I+@c?Y3SqV_a`_6|`XM*3S*Q zeMuo9`5{#N@IfEa`Nc_7yh z{@d$M*O(}=D<0BR$&P$X3MG*gy2bL}<37(zqu-e4379Xa7 z_lvECd|JY#Ykxb4a{~Uo7H(=_D2;V=MWp-n$N5bVI2WUXQfBu(<@@35TpuxQjt;=N z_{TM)-izLn8ZkK%;oM^t$Qvs#ydD291)B4*hX&Q>!4cTAu; zv@CwoVjY|xku75lW{_zK`{0xdN+j) z?6XkEt^!!2x&_b(%UILtsCuP}Ue80a zf_VWxt#08O*!WILer4=iMaNeTRAKyUHg}hb3v;;Yg)kRq#0(ALHa`D<=3! zs|(f9o(>SBJVs$dfqsvbqV3i`(7S5!SMeZA%mFv$A@m}~;`7+ES}$leFuQQO%l2S%DngA z3gy8<>`j$fM9}EBm|Cc8o^@b>yjs8RW4F3ihLHuav8BfLVQlJ+yH`rwGk^0LCRB+N zToA$g{v8ikheLzY4v&kx9rU=yav`VdYtyFI;hNcZd=AkD!+H98!vv|BxfF)l1_pTT zu#Up0iT^&&#i7tZ(h;UADd#c!QoG*_p69Qb`FmHUxue4|-D4+3T8LBJJVpE9iI|zR^R6L>vVYy^5{WROt^WTKMby^l!FUXV4+-xF1M0KKV)`IY;NrUb- z=4^)}gR{}e%%h0adZf_~_*RwZmtw5VV5lYboiONOX6yl%^dNTEp9kj0fIhDZogK2e z{fM&F&vSR^GTUc(=ey5|SCDzwE#89If#*FlVp@OPpE5cWL&JaBf1z{RHhz^Pq^o^2 z59l(#4@^rY^|HV{wpVfnqxfy@NuW*yw>AXUCQxAm*s;LQ1sM1*!1MZ@$r9gB9%Hzb zTGV1h`KG{rxTx$ix+?d)I)Hs2?$*8f{T|w0**gQT+%0TW{+FD1txX()lJPlvl{NEC z@;gH5mcK8aj$iJ=0ZT%io#pmd- z$CCUSO}5!;5qV=c$YEyBu9J0ENbziSA_cA$ZVb?M35rOW<_cI>tA&SU(N&N%)jdj#g+7*8z;D2s zK_pw1X@nsvYN7=9&47C%N1d-HIrZjwKwTzlOSxJAYk(G&vuh)6!SooYyBs;$plO)j z!Ezs-siuD%R;3k1wuRK_*3UW+R8<)cGo+iCLw>Vu`}N-^=Zi zqYM@9&U;xm&-dMFwE1XH^6k!DpK7w;MQl`xT-(ot4CE0XoG>GFQ5*3`4;+sB-rxsT zE`Eg6vTI1)M*buDU>5H>w$$<7N8BR=E}Dj?ga7ZpS9qmSCyJ_px;1$jkiszE#=7d} zn5``frYEtN_s8ZJ)svy9VH(Fi+KkYoRp+j@;?sTw{Y{NMK2I99D~9#b4F+d~?he{p z%M0MYq|42zi}CtnWzvAQjq0P-Jx7DUxR+*-KBJ|3^FB3!9~_&;F`g{{PM??->a zVrz|t!81@7cI}eW;Cwe_iU4gsE?2@m{E>Hny~!M*8_=QK;1Qars4jtCF;f&pvnmU{ z3HX!R+$lUE)-O-#-52h+3NrmSQPP?HBW+I6YFo<|gU_*W(uQIEUhOepef~>d_`mNx z1aZ7Vxp*bGV(&_D?+Ce<%dfB5N(_sWv6FORAKbpldM_SZ6NK3x<4V zk4Iij)DMK^=5$umQo{R+#~-6lr!X|H=5U|hnQhd?oi14mbuE`_a7+1$Rt?T@hy2XN zCfA@?Hl;!>JeS@giN7bFT)mC|E|k*s@PhbU{rG9TQx#?TIc|_yEK_9MTt5-)b^v=Zd=do@k-znV9zw-t6n*hBVzXon@%%BQ0gnszIky_s^#co}yPdA@|*$$sNumgcp3b z_|pfxoX_5t3v20Xv&l$-md6CjZtIW4(`AQXzidwKYA~S=bkNWGBVOop2wx+GS6EIA z4Yu=s;e&s2jx*O28kWyozxWOPs@Ce{fgS9RAHo@5{J1m|z<9yE23v`QSU>2$#fr#|vp-M+U6r>})_ud4gNv|SJ=|!m`0s_*Tbm<)d zQK}$Hmns5+N|O$Pf(X2```cX9z4!j_d(L~_oU^ktPrjcdlgT8RnM`I^yF@>WN0IBC zRv1l9(JKy{;qESS%$)!Z{xay=s}X#sfo@iAOX|JeC*9iUuwNS5bWg6E9FeoLYS(9f z&FxC`P0qd%s8y2T_2`6s!xi0dyDc}pUi&YW)4lUo*Z`9pj>Qb_a~p#@im+MwQ=oF#k~iPGOapJf@f6eT3y4^ zlop+n{k85hJQXgwkXg0;{_ILn>Gz$r&CwF=Z)7>s@98kzdWnoyE<>Mj5WamWKFl^a zcCDKk9FPC&J+cRj6>X)ZDmmaivQCyuDm`9~``|q?(@NtbfdyJ2(B9zR>R6}4V4wug zZNPh^--xlF#z^qMsR43ng$2UZ^X0o|BbA$7|=eby7_W_p@I6i60otv$^ zrYq6jhikmOqh#Rz4Q(=(-J?t+NlHx2ws?(h+(oj7Tpf;07xKa;Haf&@8am(YwxleL zuNi!|DQ=0jz**q2saoEjORE=ml5-@+Z_IYY+g+5?A*XC7nAZR7%m(7GlDwSK^9w&3 zlo#-w3g8dwU7dlC`zG{5qP@=b$_abEWjBl*8bp;v2wqD|HsYg8jr>q` zj(lTTNQp|*k@;~WZP3iZF+6z2dhvN~X}U4% zTY^;qdsjK$EP*ovwKe*UCwikVPq`T`;swfC<*jb0_*%x(IjA#IH)nm8-;N0mqne~# zG5&nF{$aWJiRRf)?72c*`&TR?x#k_eUYL3#G;s!xRfz(JD#}eHa{R@R^2@+5i&fEk z6w!+F_&c+w6&aP>&t3Y z+`AGOA$I3ES?Xgkc>)Sv#|OK@?}UF&VRU@$E__L1-jO2TIA-lU8D#XdyieyX)gD#O zQ?6Ad>a6_HcHQ0R=t}p(#xA0^r}yUjhgq!%>ti4K3Vy~?dckorx61#~pjI0p+nPn< zoax+6T6&GWrxNR(L+NLgKC1Ewf&4GNU$pJ5yQzOwcMx}PcQ|QgPxp4j^y@Y7KDyuA z**iWfeJcjWKGDUcwi_qBSif`!XHvk|BsT(8d+5RY>4RmL+I}tu`>@2%2|V#-`qw-R zaMx48V$aLjFIn}c4OO$IoBVAeX}BO+4lU*^4de?v=_&F^M)r>xdyK0^+^nb3Fvym)+RJFN|8=9I~yi5$fA9Suw`sb?>nQ*1) zdaWc4sT>_Tb4rUhpNvl@>{{vnTHyB%8Krz7A$7Q#O8=(3QLN!D*`f$W7D=%=6a#G!Y|QSn2fA)QN?c8%T-ZARorc8dpN)GN1 zx_O1>V~`4b_$qCG!7KC(HLGZF2E144BJlrcbn{mG)6GC8%Y7bc+_GHoz79A~|9(FV zlo!x{Th67PkCO;8E_X>4^5)dX0rgrx-}n|*%~?C~ytJ92xV!Z&oJp2V8q^;IwA#-S zr960aHvEw9G{My<5FU7c0E~YLzp;G%>Q%ILG!juzZlwam*7&898GcJLscUlDG!^&ul;b?)a%{cfC@Ftk++F>_5HdHDvG=L;rC9H^mD$zIxt$Pi7Vu79+Lh zUROJd-Ey>mDPfPB<=9^lgZq**nz(%68F=4}>Dif$oihsT;%>D8eYVRB;5|Oj|AL9W z)xSAHwQjMv{iD3Tn@RT56o1F1R6dOuk*bKKbT+U}7*isMX`HwQwvA<5t!7Pf5D0TDq)?`hs>K%dc+jDVL=LyzaA6wqIM_gSuM< z*4zy5A2(tgGE>C8Jf?l}^%d{cmFYkA|)VqKCWT%0zEeg&8KOjZtw)L}bZYAE#N z9Z-J2JXh*11X$vD9P4LwU}Sx#pU~EyuhdQWE>Y8)MxG(J+!$YxFk?=!8NLqgyQ}+l zmKa2g3YHcexJ>lXfA-3H$oFy@etjtZZvBDIg|p}lcU7vq&<_<}4&5PDh$$c9Uu@NF~iF7{ey)%Vd!kKq1UeZ%<<@xvygd5W- zzZV&7i_A`b`QKeI3sf$x$9h$-FK(An(T?bo8bcS+0j zDdz2&bdrH{Mw^e`9i3a1JfIiTTh#Q$2KRFu%G4RB&HTeo5`-j- z$DAUFPllHzB|cxU<{=E(I#~~=!b=1F# z5sY^P&nf@c`NhHhZ)yK3uIfIrkJ&MdxVpzWj+rYkc zc z+X4O{{HhdkBiw3}N-$q1@c&=+pgx%-;0imuOA!aQ!Sxo{w!X$M$nG@w4a}DSo@at> z(B6Sl^*K*@{M03s~xZ>H3DZszL?Z5jr5stD4vV`+rPTMW8kNtcV*#v zB%3hLo;R&5ty?GN`7uA(yT{*NZukG~|M&L)rMD5aU*}Td%iN(66+0DtaU5(rYra|F zew(xjwt>Ii%q@zXtwOuDpPEIJF+@fdkuSszm2feh?&KHsGS^%h=dE~a&FB|xV~5Lh zdp*$$v{PW-60i-*lXlz2KzQ->3t%4O;DwAtx>ZUUX8sFVe&bF5`p(xVCr(bLw)B}m z^PU@+Um4SZKIqm7i^_EUo{)$H7V?X2ePCYWDNm!c$iS?By6-{Ti#Cb<4Wm8v2s8(i=0Sl&+0vOoAT!z1( zKPgUfq(ZDtOSybVyT)V1zV+^NthVTF)#|^ix!Rbx^@A;P#7TkNflM;52Uo`N$`$|cIGpoS3)syX&DJeJ zM`z7gwy1kKvHRFkB@LUeL^~v$3;0;GHC2CpuZ~N8?)A)O&YY8|jbPQQOGfnYqS_nv ztS6fr9}aYw#>QLwn=?wg9KeO%8~1v72f2NO!c(}MVe=0BL^gzxO~Wyg>ZH`d`- zyxq+B8iFGh=bM=<^P#%ZAjU@AGvdO=y8KD4%OwIwJ{Sujw2YE-Cwv{EIN0y0Y`ByX zSu{{TFYVs9iewn)tbV*aQsI^|U=eZEg_en3o74XA&9@(PCAv{J8L*pHO*@?PFF;?X z6L-(#bhXRH{(Na?SeB7xN%I1A_KBxIYPEJEjg0 zYp&S5l#Gd&?n|LUYWs^7IbsiARJQYtsU%5w8_%z<8mlG`@~E$!<*j~qH@A`WW2#x~ zUdVH|1x{HoPqy{1w1ny$dI@sB*r_D%xmi%(CG!k&-GA?rLr^}rRLk`Bj=kUg8_Sd@ zyOuJW@m#u_jpan z2SiDjN>o$zE9KPN#GWr(?E3#Zf7|b*(A^Foz6|cSELC}T_{-h!Az@weqsiYe1<%W9 z2cOt+dadg%%J(qtoh#LL9^=TnLNN8Q$Xa2T@5jz-2XdE6xi>f0dcW?P{AfyJXHp#@ zd3WyGk%JqFE8)m?qpR-Lw=#vV6CL6=!ni~iYhK*ielsLNTJ=yz?AurSh7NGPcLyxF zxIfP~zD;fzP7C|M%`M(!6{N-fG$K)a?&hZb_k!C!Q6XD#RcdW9=R^*;sloYtH3EmG zoZ5%v|LgF;_${`aj=UezUpByYjj}%Bpe&som{$z6kD$H<&yNK*FTVZ~y8QEmO!aJ*ROw*WTxCO?H)UCltD(fpC3i4@Q$`5)11%zE6KgZt=CR{ zo|Gk-w}|%GSD_w*R}rVfYpa>qHkCT>x+Zr>LE@-S&wBy9Rx zPA17UPewDxHjqDL?iUjdVq3m}apXdwH?^kL&M&K846Tu_5w54=seG&!Da$2wCL!{^ z)pg#RW4)>*67QaTAo%rFxwPSG#l!1Hs%DnD6KSvp(xSXj@E*=ZC%;48EWSX;)Ha4d zo?9u)ule(=m$pWigIH2kf@o$BIb9}+DY0m-!LT}6CsTEre^qYqP4gRq?^uK9E#P>8 zapsGscMZ;T2P%N~T0A!w!#{AnyYKQK@BYZMuZ%SJd@*SiEYyv5iZX0SW*y%NU`XrW z(97AG*xLkgezswzjKQ9`uZFFo>Y?dks8tEV2gh4Au6570)5r;I3t$y)$hsVES-@5a z{8FANS=4joU%M{ub*nQ_Y5xn3F`LC%dxxmE3L>O&gM(+y9f>Y@dcMWGOC3jCVR2NDgZAv4-F|4%* z*TXG7c+}YC6z9&TYdoPmr@{@cheM{wH}RW2&VGxU6LH~z8-eSA8>IvOCU;re@KXD@ z-o<27gZp277#8oFKeS_-hleuKb2K^*oyx3#rcV-IL40#=$8DQvK*&s7b?QR<{0%MD zh0~O`_Y)T=yB)1Vs8u@42}s}Q+hjT=wRlmJgLw_Wd~RZ%B;lIs@H}Bt@x5_U=UWSc zGB(-e~XCm!u&fhCP`J!LIci{!2M&A7AGdf%g;x~thQ=$PYA zkow6bjcbzF20g8I+tg)N*Np5O7q+;XwIkaN$_JP~2lVf>JXPKk9^7vN+u-|fV0+|% zrobv%8WZr~z4Cews%x%+(sk$ElxHB|?D!PiXuL?VCs z-}d|TWcLA7bUHzP_|s~NQl#os!L(9!SsNMghTMW2bkC1)`w^`#5YDY`esdqj&yb_S zh#_lWo_5Fct(UESye}(xI6*Xj|5i?wB*;&W7OOWZHP62{VYsY{T_{w4^XkEtfv00( z_vVZELW4Vm`Yb{eQMBq3wtNXR3fJ5}@8+?G@4tTA!_<^gOy$^fP{Tn;*@@3{i?)gG zde5)4{UfOc-{ygw7;t_iJk94X=m^WFR!mRR&z&s+=Tn3HYZ;npN`Z72z4hEn!q!!) z??0yRyy&Q-p-i6`I`|2mZ_9+wmi#0wYh+PWWaBhbI7*?U%Jn+3FrOzbvL#nfa>eZ0 z+pnG1!wIPXy1uu}*zp{e-!H@@lDFV%b2>ZHMYg`h>kDUhIim9yrz_G+?}A zeCG-4BP))8!T>yqX>1ku$fJ()Zp2f#yT2}~+MC3uZVR|M3ke8Q3FRr~DM^2Q3f|wm zg4Z^1$+$FT5c__8^OF-5;CYwN87yZei{c=I;?tT^7z{Z+(tV^C+&%OLJD0{|Si78H@cu3PJFdnFOtSm-xzE}l(&yDi^X!_K4V{8#A^Qz}hK{sI&k@E|a zzb3)>C~*I8Mu#@t^xh*Xoz3?5s^L0!58dW5QYST?%UaeQV4K2n!e=Fe6O7JP8=#N}%bYpc50l1nt6wwQLXZCqSnHURerALL++9yQx%&3%4r zpp$P+2hGf`GlbK7lv+I%tw`E z*;c{1CrF0f-~h8=FqH)VE&JlK%px^B`TTMU2JDR ztX{wZ^K|~`IcLLGKSFV&qC58aqGd;-5NmInylv4nS`UmHByFwW{yygVRovnkF#?OL zi5Yo)3si49(vuwCP%Lnjhz_T|jrl=P|B-*^Za|&bK-A#PrP>kj9j3Ia=V;73Sf0@w zc<>!=-Puvp{go!F4if_R-NE}9U>n@u1oxM~c$UAnLH`Q8|0xfTcD^FMz6Rcpc5mlC z?fo>$!d5M7O3m!TeBxEnc$`~w#q7Qq6e(SSC5F+vYh$ue`k?&*^Lndt3}~{!q_{x+ z0j@7V{Ri$ZgKh9U1oZ#Fe4LRx1ahBb-o(_ZkNYx9mPTjH&_2zST+|Z?ifiU+y*LrR z;4ZbM>>`n&UfXK=@KVMvLgyYg*F!2$U;n-RaD8L0;dvkH3#$|N`qw&g|K1+sPcK-d znoq$W4Kp$nl4bmR8+?Bhe9xz3`i}OMM^`ozLgV?^;+|E1m<-L#N;pys*Q7rEtgPiO z*gw2EjqUjS_o3hGwipcEY~oz|o@PL;uw?s)m* z$@65#c;3fWW2eBp5UG>c_`7>9ul+b<&%Qfw&W_I<5Ku9O;Fab-aVPOCn5xk%C~IXVN3=Non~+j`A(#nj1G?5R*YcP<#e7c8RZ z(5d=$DETm+5|`eAuR^ zem1*a+p8qFNGwsyZfs9q(X6~3aG`VdKuIgow0AEL%p0Dz;(b56tnTD5DvuWOQD+q} zZ+HjJSMGuljv&$G1u;{YV16juVJYr2qP4D}i(8#Zmvhx)Q{EDcr=0r4rn>*aM|xTA z6mMGl*YLh|y`p;&uV0OT^lh6cJ&oS<@pbx`wn3~ucMYV^&j|O8W&GR40WJ-q+0&5( ztuBYgs+ar}zH~4p7-SW9yR) z-8C~swxpM23EL?+{90rg;QN7Rl9aFSGnU7(VsF;s-CGdqcae?VB=vSoPb>IPp?QgD zVE?lbwdjjz@EsHI{OrW-{3%Dj5>fCR6`YUY{ubz8fcsO#~BKh*qqHKH+9vJVDZ7k7psk*Wc^v5IW>Gt=;`I9ES zpI(@GNG4UI+3>;t)xt-t((|YI&XtFGR$#p{c_`8ij<1w*+KH1Z$^qbgy<1)(EF}8v z60z|w>8@t`e!G1g)1aiKJtiy7CaIeJyuLNIZ$Y7+N`rrFS9Z)q)0J1E9+6MVa*CBvE1XW6BsxgV`J4P$k!dVS~W5HG)lQU%)$S1V%EwK z*^>ZY%SLCX#?yoO#kpIdMs{q|$=Hq4RT|)V4@ZaKW_^p+1lN8E`HDwu<%^rqdJl2c z?LU$<9%99Rqo-=3U@5N-@(Xsl??2H@Zx5aaHFF4_t|%yaQ50yj!r{f41;$tP_0EYY zn~u+$RMdoKc`u!RB>Tvpv+LXYFPtO84LYmWCeDkhD;Wf=nEK4{eIh^Q4#rQNoZ+lW znT3;|XTHjuTyi~f$ppWZnEaF$sPDk|Ggb14OH|q|B%r?=*f~#~2CeHoT%i1c_8OFT&_6sYzmX%KXO#}#x4|YTOVGTh-p=_3n<-1BfC#+L zqHTaBAW{;<4f;P|{O1PG&DwF=*Zkr#FI8qOZ%^S)DbKviPq7wy-qcTSe4jk1alON` zjd&gA^k##O_XX1?IZwaBLsK>Iyvfn#MR4$iK!uPeay-)n-cujJ8ET)mW5nE{rc+mVA$w@dPAUgp?pz6cY8`G^fBJV zFLxQmw?w)dUMMuoxG=o2-`n%L9Mb9i-R20?za0ks4yU(7xxsg3z;|E3w(MBB?8bs1 zX>-KBcoz}Z zQq^$>u9aFf*5obAd=yPj#`;72eeKojp!kjEUp8wX)yp()9z+95qG zglo82aIA>0Sc{mbTG~B;y*nsHlZK=nv`@)CmLDJRSM>~4eVm%n#oq$o1-Wc7rGAMF znkNOP?QI%tz^J;PXY}gP`_YmN>bIpD4Lj4PuV!EQm8Fp>_^x-?@>v-8Zir;uq_oJs zY1QJ7E++;GdU8;I{NflI5GBBPKBO;XZ-8ImFliap>mh%^IWJ;Y@67JL2BAljO7m|769i%@FhDz&$n<2nhkepe1nj2wd-bu!n^k+BKZftPg8=Uwy7QoRYeNe{6j-z48dpia<|AEl3p3 z8+y(Yb9S|JuulDZPx4ODl zgZo7q3q)43rkC$Y3RcXUwsBu@ynq-0WnT-Q?3cY&vkbaG&1}d0 z0^Cn(4JF^L7J-w3^B26o`rNeT{>ptG;WK;Z_!#!^Rl)nHm=ANY#GRcZFt1TpMQ*Yv zfq5fF<)WI&p{m7hCh4N?XzHBWbrLNPV^>=l&w05wYBe83-szu}Tqn~PWYauCzkKf;i`kaPkI4}Kmx3p@mRi?$LT@CdlQL!8z&?MF_-Hcb(G`wD zw}1n(Jd&XYUWR@V^ojDBj+wrDQD8iwq@e$e9o}Izr>qti?R$4Ez<59^Dy#4Qg+}M; zk4`!BK8F#|tFLaWX(cy-akk+70x31W$5W-;Lk)!0JbuadJi&JopXl@J>(lp=NJ~92 z?oMtU2hVRoeu4MVz&7Z=i*3+kHP)S+1oKZRGHI-u+Ppr>$GSH!+#nhzTaIOBpOavA z`tjs2EJ*Fd7)G+zmnRzEW<^v)x-GQP9G>3~+DXd@No%rry zTh?5|rQ3Fg3u+wZ2R^+?)n8A>GaKul77U+Fuas!6ekLffswUcy zCHsT0{(Q;D5AQxTaN2o!I+tPOOOHwGun%849r69Z&j5yb1haiE;kY6`8y*C|#C-z; z#VR)HHGe7r%2TdSZ%JUH?;)9GjkoA=x(m>JOGiw(P=Hd0}!F zmt=NvCQ|uvU8DC`-v~(Myf?1u#CUw|)LE*{d4l9&L9ISbM_8ufWdWlzUB>ni!`p+U z9@26j6jQRkX?k!N7QBZWsjs zR(?PB<%wkjzs>u8cV`+Xcb>Uxk!|9Oj|8I z(GoYMP;4LgIC%7dF7{c|TIol4tSlW0j!HcFUX)ZsFM0U!ZmmxDj^`v0l95gM`VkX- zy{df&dxUChm@35d19|7?p^2Gl_nI}Pl^SJ}iB$Oa;xgQNxKwP2gOLLk3bA{A?YgX$!UCTScsjRzJo5gDt%jXk4-P3uUb@Ckx&gu8kNn>aM&Et)fa@48tqkcNVtyu5B({3LO^L*8Aq=F@G+> zm)w-+vcXva*M=v%+{Eugg057Jn&RZN>k2+2nd$lNr7e>G3hP?*!mikRsRfB*&Wl8x z3kq=&@2=37S@~G58FC1Tr|RrX2V2*Q+1{N<38$Fxd7MA-{pY<4<@>@4Ub|nN)lU=a zixS{Vyt$HjX8qvR!!qWsFYiA{WN1b+mdY~6w7=k}wWKtYER=s`9Q9*$=F54~DHSZz zQjwxd!dK2kyYLf`Ms)sKk8pAq!C8D7S8`kKl1y`HQo2R|c>BS&i!k1)L=Ev=#xh-9 z_v8Z;%3o4X1YJ{TdG3%pcYafv5SN=#S@^c}$q!>Bf~eRadN04`+WmqOlF%!!xK&$l zn^aV}FN~(ePrNlQ24jjL|U>{`i@9c(45* z#ZV>1#L_1{&{LeI6uLTI{5hvpFrjT>?*xa7b?MCninFfeDiujR60fb^FBy~xam`~` zjN7>Wq_NvOFeATpJ!DSdY1$}7My?B${X^*~njgAN`vwy?-aZL=^i>DGO`yB|wdmt4 z<9W=K!h;G=6P*hi!naB6qjeID!e#^%y=%r z^XN@t0LkZPuNQPY^z}u4nD08D98VtpI0e19==<=-dQPFF^?;5UVS04J20oU{>t^bZ z)F?Z)0z*P&r!O57idWc~y@hftbul+^6Z+lwlju1&i5K>Qiyt0zOlQ6dIi!EH<)=Jp z8-A0!`3H<-0%pfxtKzyQC+Vjs(6`!1^xo7VZX}*FN?EIr&|8@=Ikm%C<^EK*j;8G8 zz>^A_4=+%<6L=&E7rzZ6_4hH@Jndc5{q?f7-Od$*6|Ym8Jj!h9J;Y;Kd)8e($%Xav zcrx$;Wr+Z0%-yZ@+;dggMa52e{O+CV&D;lfuDOM8kCn(jib<#}eb(<9;x|T96#f?L zg^qQM%DwnRuAg1B%DK+6|(y`s`w?s-A!PPvkHU`pO6{L@!t zdlMo97GiINxD^f6YBXVgI;>+iiLHxHmU{Wv$tvF|s#`)<*orz_dgYokiV_Y- zytPr-T9vW4-g_>2w(upBr2T+bKaE=q$lzNJ?Dg_pUc~XZ(-4$>+rlJMNDVWK;?eXy zv1eT?{lR9fBRyDl8ok^CF%x1DUOatY)6=NcS#~E>8n3&?`rLPVo>MDbs&;kxZV2A! zst>=%u(yzT=i}H%)oagg$ar%`WPEQ_5dHq+B@ufD!BM-a2pLn^nh7n9q@hk|T$JR5 z)=7*0Jp1q`ZB4h-533?g?%DG5&hHrJeBqillMAl4(dCwzU+GW(B(zd}K>J*PmMKOp zR6{0z-AXXTpYKAz#YdsBr_V_R{iu2Glq8<|%G=4|POefL4a)%Uu$9_eMpO8Ye)2qh zJF4g5176i%9UNTp$e2=*OXE4}jojkZSU7c|afskq=mRTHku0+S4%=J}E5kEQ zV|E00vu~O%RYCRR106Z0vm^8^)Rt3!z_gBi4>PQMdcK!#YvyCTk9_K?V28A^_<(*f&-Vx zG=s=m?C$Mv3&|$LD9p0Nsg!H^Z*{)%m3e40S{tU#>8DL*L@NGGz+jm-q56BjFx$_$ zlM`w0oJ&Q6UpI3|?$y0hIR7J5Fmcl&OyyzkXarf4yu0i>SG}(JiwgTsZi}a^Z*{$h zS??xZ%&F4(d?1tgVN=1=@sl8?-t64#tm34aHl^JQ-_wRH9tN0DF%@)MhK)EznfjGJ zHaAa~I2XaT-SV~S&Jj7c*`t{_S}EI8{PFt_UK@8NW+vWDFbd%m`sk%l5vg2%%Ci0b zRMv-481L8@oc`q85xP@e9^GkzES;w@O2maXIC=Yiq+y? z;tu82JIM0&ycx+Y_$i?ltV8qT^%wE)G?b%17U5hufle+n4f3Tsmpo7Y)P5=c^T{Vt zc`o@Vj7!bomo`evNqS}tmg234aCM%AImZmaw8>q??bOoX?c-TS|u-uk68 zb0O6?Mg0PXF-_roirr1y{)xfwM1JgTO_CwEN>y|#f?+{@rq&OwxF?t*R+n2AmFPCi zgHGY!!q>+#CeicRTAeb^ybxygeVHewe+N5uf#3=6ThEtgzr9tn8cS0USvNF?tKYrv zFG3Y>rg9c;Nh^P2w;QuzHYi}6x+_*k`Fr`3qgQ7OHr*+|J$j*}?w&zuKd7QD{@u!Q5Z&@i^ax;jqO*35XW>Je*`nl}*uoRZ zM+)Xw?P5f;cBh@9hD*-!Wc-X`#^(%cx4b|kaY*VE_yp#}KvJY$|CFlOukHnjSfaq` zz#@Eo^Yj3Jd)9iQLCOi11)16J1h`Mfz70K#Bw0*}=eaOXMc?IOFHG_M^_=gk53Qqj z<)#+sHV9oKhRgi28R9wT?Whk`b@p-VBZas4ENotK#ma0dFJ#9#&v|P)?$P4WI%#>` z$);9u8uYOanS%ML2M!K9v&GlC-zu^eJHzz+=}CUK8kZi%9hR?-@&)}HI8wn;Jh!j) zZuno6`&20)!*wuxTb^cqB<hE8B8{Lb*cS=Z>&5iVNRGTWmE5~ zRWd(F2YjS(2x8k?vX_j1D(O}+QG?OJrX~?76|Jx_yc2i6eVIN#DS0>lsZeOE=ks$< z2&>@|_xZH0jLA$lbCLC(e{;9sN9nw|k{okz{5Mz8qXC-nlLS7cc=%+DKiG&2p7c~q zT>U8)IjeZ@nj;~J2}xqu9EDXm-PIejH`>x*ZPYZ%n=rF@pWdYN*X-0aszwQW@o~CI z_02!TlZjGA4Km=w#f7e&JGDcYy=XLftp!)1-jdzh+!DJy>s^1ov_Z%N_M4wljjYr8 z3N&*avOKqgPUu|z#hHaWWY@zN!@m8`@WI(hhC~* zq`oc54iyAX-gv+M150>HFPDPR9_MJcRZq(ih9jS>T07BO_~h~kCEeLK>bXNFS>b0S z&QGcYQk0u|;b+$(!PSz2r-H&>*Xr_1zGm&p%DXq) z6Ph)L!@X0!PAa;epJ-4M)L$LA8oC*zsO%= z?>{}f`%zKV{B%eqqx$QXpgtuRqlKD4bZ;#C zGE~y^`Q!xrB1S090;aizO49QA9ny1}}mAPvD8hj5N*~*sN zpUt%658a=&sF}6F7oslb)C(+x<_u=>sdPQi>_8w_oiX#p=ahQds#S5u=0o zW~YcxIP4t0s*vyPm{V=P&Np#lZ?FVO@!%W3kT-L1A>|C>87US{vr8(iwq{qzUzQ3q zPAsLIAvAt2BN_P3No9n4u~oZ0jr5f9$O(lOs$$dA*W=HSzTC&C+wXZ0q4LvEs>?d| zQeaAgx?RH9om(P;j-$_BIe1xmsLhi{8PgVxnUx21(Y@Lv8tq;@A=yB2!_kOjj`@AW z{Y}HB94m1b+?EFuJbdBT&UgAzZ%qogKiFf$^Y(N}GP=lg+4M1E<@UODt;P|SvERr` zx0ts}mt>>y^mO0a*5Xm*+X)>CQHNR99C8{CiVd>;5*VFUS5EZ{zi%P-D~FcU=4laS z2ajpIyOCk{=Zs<{HC3E5Z}Bn;Rc8*WR%j0GJ7Xj-jQ@J5=`MIpL6Cq5Bcn5oFUrx(GpEOUwL;|69_(jW$K%hW6#j!D#$qDz$??EDHdWomvzYN zt7N|@lCPGPf7X6e;cJ~K5oX4i_WnVTIA7nzrxlbYq(l|>rtO?DpW`rNCk!U_*rvZW zvOZyncckaJQ_e^m^BD7)&je*F@0DS%VMbVz(D`_GN1UkD-k2`>d90L2FEE96HEikm zYNqbsJm3v@)+#S2(#YWb^EGo!c|h$ut+5mbGyPw0o1Q%m)JL})s){J9*)e`$P zJV){5>N{rBY36X2$M!;zkxhC%wkj>IGH;!2TyJ)T)V!myeKL8vb_ndB&*_zCZ?hutyYQOz4!Q4eVnX>haT$TCt#=obNw%$6+09uODz`Yhh+);PfdwayJD`FL;vGDh5(n%(~z4UpD4w`Fw*e zxZjD7wiS9L+Z$q65?F#s<#{N3?YY!E-M-_iiKse_P4TKkIwYtz?)a93!Efh^>8U%ub=9yY%Y?x=lljAGx}}a zd&W;L4mH8XIYFAC4^2q7MSZ@GOcRsck;f~%ne_Ngr`q{Xm}-fvMQbc0>I;%gvud%@ z1v4IGjHgx;Y1-sQGf$Q~TsPTp8*JEN6T;uxyr|eOiA|{z)bfz&at@KSq)kTYCc}e! zj(eVtQ$aN8l00WA)mLv#WgCrGGh7Gts)U7;gEPCGrJz41?C1ys1CAkKZDr=l&dC`K zgZZN@?oPMZ9V{_UK+r!HcFWsV7Ow7Ah)`hA4-Sh%tp4HHEv?MmY#6U0j0h4AOZ&qg zvBB|`k;D}gC^$@L?a8qB&40p1_#rF^2gjg;e!o))A2meZ_StA(?3@kJX8%Zfa5h3=+{A!ivaa>^Eu+b%F_$T6#x=^j%ZC<>wZGdD;f3mnD_EfI%wX>0xcaoIRP zQKbLm#&3B@hNMv580=E4kB=z^RK-DtMv)__C(sg+%>xPbJjawOiXum&&Lb&%D0v9U z_r(iP9zq*P=Y^uqqfr!)KO82DqG&%B&L2~0D2f7&qC`@O&=Mg@hHFn9Q>`e95{;rl zQWv2m6deZn+!j>*Al49W0Yy=vQPhwx97YE%5iU}5a`l)ZL{yfLqei1>AS)ckhV;e2 zcy3E9e@uy?C>k`17D=h2s5@kEx?{=-MbV;BkO+#)7e##z@U%ImN>CIX8byz!zN4s{ z5)O*T)DnuK|A+dm-nf9I5XTzfmOM&4k4rBhq7i@`Li1;tXMikl7*rsTPWw>>lrf01 zg>afE3ZeOvVuUPk7@{;HT>mrPhGXgxib81qJX4q;3mgU&bmXy(_O0AL-md`^#e|j{ z7m?Im6s0Pk^IQA%14Ug#qY&pK9EK<%FzBalz7AFVh&6|7`e}l0s3OXcVF~fy0!bC8DHb?VCM6rtDD^7aGNlq{5*kB9Z+IMYhLO9E#%p zhx+ZTgeqt#t`@|}06Dy0q&5GnA(n4Z6jFmU|AH(Cfj*Gvtx@jWI+UXY{`Kv zh@3dKOhA_CKP)Gq?ve(S@M8@hWQm3{;MigbSq7lIJhr4k7Ea9HEiWMpIn)RqYo;KJ zz#o=F$fEIwg$_FVqW@+2y)VHFr4kOagi?m6*zmn9t&ek68ln)6_n%z-t@XSLS>Z4r zXbFKBvGzA^A5-Qi>MD|gyfGpm%gn!GM_6hhi!;=4|Fajrr-u*ng~KGEB_iZYhK{|* zArGNK=0i&lKav9VVGAL9*)jDCMe(Ci0!YdR71ssKR49#zSP_m1(dC4k02(C-S>Z4! zi;*sXi~asFrH`Tn(I}xmsG1MiP}K^EabpVc!au;Ng_`@;v^a3s7?cF4z+s$j7fC`t^C5=T<9MRc_oCF#r30eQs^&kU^l0>7VkQ5aZ5hCZ`_x3|4 z6SRSJ(kMy_jgp4^;V@J+hOx38^!b=_L{ZXclnj#k_xlxxqGZr0StNx>9m4&271@BI zWYH)&NDGIdvKYe-U*OVl3j0x%92$isGRp@fRX9={na;rV) zn0kbwl+Y+;B((@Fq3Rps(iwx_YRFa;rHn?YAgLNCHxT)_SoLQAIIe9JrGiGOBB}GR zf9mieY!0YmgEo+k`OH86s%VrNx?Ng)V?`?Ex~peT)hsNdRdsG|v`5C_RXeMsY*P<4n%E5a?HD1_$EzOfc$ zfy1Dx5a|vrYoR6%P#9wZlQKe5pzS72%!f`h zK%F`Vc|s1M`IEWWy<6Ddvh@vhb zfSiMqpcF1z(4~sHnq5H#P16er#W%<3-*+Rknr=t^yhzoMI|K!+j zWz`O{{wJyyMcJWIH~$N@f}(DsQBacx#RXl;B3)XMTHNt5rGt9=2xpH*-GZ!e*b8V0 zgMLqBUqed78p7Q`QMb@22gnx=gPLBXRv23z%6~wmpeP44$`MH+YG6bi9pil+x&Q)H z7m9L3qnwZwRCysC{}?WGQUYoVMLD5S&Pa;x9|%L2p`Q7eI!F4C*%^&;K~h1`64CZd zd(BP%L;YS7ZX-3&B?PkmxgXZ;fv&lO)ZB%Zh^E`@hc#4eM3hTfS$*SI4!xlk2A53MylR^3F`KuLs-*EdK5WjO}EAwIODf2YS2 zsX;U+2%oTzyawnR#9qT;&3+cuHB8VF;eOqeiAUE2LO#cF{rmI;{STU8q=pe%BHVCE&NuY9 zLLi^xE2)NHQRo2vo#y*UO%7CPlR;}EkL|CbYeJElS!jvqPaKq{L0SHHIEa!Aht)s= zME!MQCmJgHe`~^!8ds>pia68yqCWGWYaSvs&!O}nn##2oob2eDaHQrPv_za2JC)Y5 z=$Z(m1_ufUQFlBaKBtAQL7Z7|7$Ub3HPRBs{S0)?Bc$du6cLm$7#cBC|3(vq)L=t# z!J)OyV`P-|Tw~QiC`LAsL3&Mt>}NIFFH~`_kOmP3!jbAy3ZrYF;`@JU68;BGB2sf6S|VJeTl6*bxRM|r zIE)IZz`$tCVa`O?BqKH4D2)s~_Dgh43R3gm!%0PIG*HJvu{nMcJ)AV82IS#P1Zz3E zCLO5(d3fCh@zCS%WAWsF&_G4%w|xHh;bbB;*ii6@@-x7E=ik)NSx60(2xKbcg)yN< z=I``mBQ^RcP44yAP-pOOO%75+2rUurIb$kR+Wyw$LO%aou_Am9omi^THF-!4$e+E? z00{a!oTo?)6SPG5$V|P4ivQo5e53~2VWdy0>Z}5~rU0oyoI407_j67YT>~{CP?{0t z5D`OX^AS|#{T){kQuE)_Q;gL7_w%YfUfzSF}3xgwQoz zNDT`V5hAW|4JW9PL4^2wn!AyjlTapOLTlGfyL+K)dXSnyR5D$cM0wu+}+(Bg1fs*aCdii%de`ft;cTl&!NwM`zw5 zo&JAOI|bI#A|YuK+|B&Q}gnCidJR$Rxq1UWXh zX;2oZapdCFd8^2j_*n-}`sc z4opcG~?XSV)v1!+Ic`u6nMlq=DGJFIe3Q~`^LOt z(_q;|`|mOMh@5xqMEq2|gmxa26Mk7w$f*O5Si+4oD--HCa2RkdAcLICd3{@G2c|7> z@ahSZ|Ag})+IbE+Hn)uMh-E!YyFQ+FUXT-honMlZ86Gi(l>1~@cV0mbe9{s+5BAmB zZg(o{vY^|6gP*&^J~k%vlT6ydRomuv2n6gKIa-Z?VqMS0TXNFCBjz-_`|P-O-jM@? zisD3$bKNk$-jg$loyh~DB-L>~kTZpyLP-W0=I4*(41h;W6@N@fq~m;o9Glx^e1!ih zC;6CPJDKfs~ar*}+0yzud5sz#4o&<*Z8C%%q zb^-G7oIdrA2@5PBr}-x$Inc2vC(Pq}M(so*$MMOVqK)6e$#IQ?SCnwy1|G4jWTjKj z*G?32R&iN3N}b56ov7q20|(Fh*m@QWNq7luZ|6Zq!a(a&o{Uw&CGz2PSC;cl&VP23ijH z3D4h6fx!gGsm}4q=>lcJL0e%@C$85{0&+ay5$F0N$2}WqCm}i5-!WZi64`Lx6Oj}C zdXbo%Vekn5v;0H5X4hpU`G+|8zQ4__HN?O;iJL}fspBLgryUG-7@$_MMEQNRlboCZ zkdJ9dq2p_`L!Vl4!`%y}B4=B}goLI3y$481aU5%Rs{y|ZV=xst3E`FaYV+Einw$oZ zk174AV{pNW_TOcBkTZ%5=tI7}3}Yt^IZz3DwRwF{OHLJd#4)(ow?ungRyuORud^pP zy`axyoWOXUhwC`$$r%9xu5mR^J}{K!Mb2F4@NvND_boka1_3!8dj@g}LL4mXTHQ-k zwUd#YM(~LJ^}*%^JGGOEoNDlh{k3KHu$9`$OimL%t{pQj8ur*($O*sCXC((F0!rIn zmMpK!%0>>(nV7oGU0}G5%T7*PXdEwadRG6uN5{b#!{)Y?qQJY`IUB^)PEK-g*MV(V z`^4Q-+Q~(ZqyLQE@XoOR$xTiXhyhQm;%|@T(sA;T1B*JP!8`87(hlwV+;EIyT5=$y zu6FWKoYZ#3I`#Tx0`24{r#d@{j_=N=9dB~NFRQ>mlvVH_$|^+86li4ZA05WEH|$${ z$msx&crId2*;rcF*_RwVI!w7sOoC|!|MB;nP?#Ki?*_~I; zc8Zdd9`Z4j3w=9UJH^N;Y*(yBJ>S5;;eSr`DNarrpqOLchnFBHFUPq(b5JTBrzAO^ z>~wt`_CY&-jS%knAZQ9{=z;2)gI6gG207s$S50za z!y}H<?77R)t8jqHCuvIg2>X zw=`AXYNsAKaIsBsrksjCOFQ++DbCLCU1bb&Zv%4hiWtX*b!&MC9j75VcxKVbk$J*q z?KC3i7_7^99T&gEwVT>$Ob+&HjMM5|%i`K;LQWTU$~{>4Qaeq_Y0u7^pvsH1(~O)? zP!7(k=Jm8WIpMFTEyxLfJ#9%&dMF4^rWG1{zF{xXikwdH7!{m1G48tSI=B7@Cy1Oz zP!?<=tT?l~8Ll1LI60YiKCGh4YD>-%c*J#gZjLT6b;3WK#%Vhzr^Veq(44Lgo&}p* z_;GM0{m(JS=}1l>92fSVduJmW_9WPPHn-LAi0vG%JB;+`H&bP9_)^IA?kt-4U$g z^dM&#R0f@k<9`|E%%1-crx!Vkp)6=TD_v~&1G=o<NygBWE2r*yo#G{8>pm!Q`xfW5;t^Ve^Hv+UZZuE$$nUwp|F* z&H!@0!TG|u_d*x=s*pNg1IZZ*2ZrY>>)aO$v@_@*>NA*}M9|Jy=f&F^7SwTukdqAR z39iS|1=RFZCZPCsMau#qqA1X2n zmR3McV`n5eS-`=5_@~hX!}>nzAIcg{j-x*xx-`tN9~(msekKR|>gz}=M(O&DB`5r2 zA4kqye1tgTQVoR5Ecl1hag8S@{QGPZ$e99(E;0YWVE$u``(*crm4BDJL7|UaZM~-&gm6svUaFfxW!;+)AB~kwKI?6Y=;Jf z3lwYH`@x3!XFfUUARp60tB>J)Eg%Qm2A){vdzA~x*^NOU`Sm`XP1gr^eKxm}aNr5R zxwo=bW9=*^2L?H%W-E&s>WnM0&CPK=Skk{{P90|{Ib9$M_McC8#}ClXGIC0>GjLYO zXS@A(e_l=w-oe20)wRu=^g7N8avb~cwWFUJ#?DG|%0UcxVl@j1yshJ`B4;qy=VOX% zhVhO&1e+UP&0&3l`?oRN0|_DL0X*V)Z#{b*6bt`w8mDW>>B(jFE&2VScGi-!030kU z|HRU;y12$!N6t&cklr*}1l`2dSx-)HJQ0v;@4GTpI~&LegozHdqtW9Vj(sCJS1~*~ zm1oV>aW;{I6~;c+_-f;d+SyFbR@fZk`V}|V3&Zu!7IMnMBmB>*S1ig09cL>!5Qb8s z+}#>$XB#<3V1a`}vo4%FT~9mP$@u~KczL2joLXuP8`UGCswIM5sPZ)Bss6( z5s&}rgudCegR3Om?}g*SI!|-=H(aNjCTAh!qqEj878DD}>DbSZvw)rK5i^d^&RKFC zYi_FrPrS7g>g2phJOrj;*Rsx$lL5-Ybl9tMfOgK4gKHe7&)#QY`f!bNft<#8P>?ze zc?_4SuFger@SI}`KCpg{b}l(Nvj^8R?0+shIlUv^f~}crS-6Y%?>l|n%eStk9h@!y zb3SEi*g`wk$iev%)3VE1Gi&EMImzsbwIZ-Vb?w|B$Ag`TtIDp?&P{Us**X5hy_I%u zk#i0loDS6LRp{3sb*y5o2iQDLK>aiZ$}f8W>1S;Oe|4=OyIeTDh!3^+eivLk_kNzS{hGt+(WKfP75Bd#1G4 zao+tyocI6Wd?2Sklmkz!;#QmAx~z}nK<6W8+UryoweyLbn(RcbG#?HTBmUinpUJ^B z1#_;PdQ??AU&zVGPUGXzp*daSd?g3h6U<3)>y=@y`}Pmc_kVDH{DbrJADmz0gn#V6 z|H1k54^G%WI5-u+@Bcvi;hgZO(00T8>_!gubR0Xw&wez_8xhDU0{J-q+-qIMTc0l* zIk;9r#jM~naawC9B010@D9*5_)mCUH5;-tgP|6#%cyaB}x0c*+Ud6KVX8B{-&*QhK z{`;MQU~3gr4eh`CDtB_aN z800i&XUYB`SY2G5nB?H)u%v2!yY>^IgWE`Zs#QAgx`iq z$w>os!BpjK$t}9hct_O!eGqiwpD*}KJITpu4Efk9zgPW)kofHH{*2!Uu(|C6ipRcZ z_(8)tO-T;j9R=sb__4cnoK)l_fqYECqeiyXPHJ*e*cGco)p)(M<3SGA1=D}O;`n!+ z(~tuTHl=>^BX`nq(mK`WWSb1@w3CjUau5YurQe6*SGD6wPCv+pC)U6rxefRIuy_6U zeImb|ek*hwFLF{s3{3mK_8G374CIuyE0*u}EtRyBksRp6l&TFLo>x1W$ie=OY00%W zWwnFfyny>-aNszHzdZFUw|4Ljw*5O$@Wk3ZWSZf<(X8aa0aIGD*k;(PXCue)dpnhW z7Blpp?Bv9RD0nW4cbWe|*Cz)#Qz0Mw$E!F2hCY^)oQ`-pegAs?MLOFJ0$BzefeT?ag|5@(zP!wBua`)Xctu#aKNw0Bij?c^f|_feQ$ zEMEYZN3L=5lN0_q#czw)++Y(%?Ne~hNa!Z6aSD(#2r$MPADY;(Uf?ItY;KM{$%Xb0 zI_fxu$jJn8qC%X&2Bi#p03UL~Z$n>ld>{sAK|bab-dZM(c8ZfT3Gy*r-}VrSb&XSk9Go+w zfD;sLRR`^qBnPi^@zry#ChMXdKXTqdK6dHSiH;1>PAPKEz{L*y&pP!xgJBGoCdaW> zF5Pnt4$-yFWytY>g0LO;ubkRMJ7vjP5Bc!Kx|y?k3GI|4rw)Y2KK3Wu%V*lbPe=dv zJFY3qUoza^C{GS_EK0o!`kvBpDv;w?bASB08>*d(+rg--1)(+RjzT!8?|CPQ61H8Lq9Wl9M0uF-6UP z2`)ojIo=sjEu0iUMgYO7n zUp@LYf?<8HOHM)FOw?TV;i;}qJ#z3jLolrlK4ZA|RiB)`P+`>kqlftEI1R|j3HjKD z$&y^StDT1A{DfI29yp#ylCIQFBXXX=q=9?i*hv@6&`x7=#=#?|@^4lh)ehbl4_dU0>}qB?tFx=$s9>2U8k8`+NOrMh;9&_VeyuE{%4YlQWLvtnB-1r*>M90~>29 zA;R;0&~07IYDo?(ew4G|>2?^_u1+g*ny|C&ebN`&X-&?%$nd>M@D99O5l1^gJuh&i+a^PU-*t_}G`K6t<|>J)4>ar(I*`*FUW%^{D_jUJ!Cm8YBnS6eczs@BdH1y1=|m2`D+f<3_s#ncX{WO| zI8K+fDGl2S*Rr~h1Dj?_r(fEpXa|qg=2n}X@jiiu^VN-~FobgLg9Rzb6BlmHEX=!}!8?7;SEo zAs^3I=%VLkb(}ur9EW_Y&y1JL0=3hZ95?}VE;3#Dxk@|z$Z5*Xx%Kg23yd}Udz=Q7 z^B5?$Pme$=Le6f;$0MGRKapXL8%j<+5U|eHkmrVeIE|FDcup5jdQ?Hzc?3Djp)6c?LQa-1s-2PKyx}-2<6qdUol)eR z0tee?_r^#t#o`hEeNIP{^BF3W0CHw8&uiF2jv)s>U4ZAJPt~hxSH79ya3~|-@Ko*fOf`{Qw$uebKvPspt{DHK#mO_vCn7nIb2UW6Uo87D5ka> z<8IW>Byx(w2`voHn`PzlXlF7xo8U1AI4PqKHT1(NXq-ym1THIbQ9C#@+uT|~K5TfcIjw@=w7It7 zOmeCK#yWScvDeU_XOTnw9i07Jq8jd9%qHhLxCGnX9f z7nuJ0t=GT%>O68_P|+BSJK(or{hI#|Wi23Q8N|U>DO9hNVJ%ol4&G6T0ZxLLrwr$7 z5jiP2PU=+g4cF$2$=L{xc%4%7L8K4**q4xl@2X&*@0_G!f9)(KrwBOk#7bJMU~=s& zBc~77XJ+2s@Dz{m?>1ac4)zVqxzu*~Z0)Qd2j9)dbDH|Y<)+$MNe-@Y7$+bfzGsim z{w`}3Im3YBINephMTmA*lY@H}eD$w3ziw+M33}(>=ke?h2uP)FnEY|aOQzux@ITBke{ivv)LYp%ZeW(2;LHL zEo%!oj&)~zkEXS>vz43?5C@)E4F)wxrk!o%3}7eUq8D&_UCY`|PG@j1oyub~tb;qq zfrX8d@0`SNS>qaKCpp#FDfBSZu#ehB4(?ZR?0Ai8yI9BBO^z?*V+pH#7v|H>9&%tZ zrL`&8ciR>1>?H>l2}-Nd&S|fmeNJ(Xls|P=JNupDq>tDiPK)cYA0WqZ?7y1MG91@I zat=dn@YwJ4T0B(8IYiD6c*J>pcI|GJwR4yp+(qMhk*!xO!+AeKPI)K@o}q045ujY3-C#IwA9WyavrhMet(VB+Br|oCvfoC`;09Dx42x}`2snPHe6D35;TLW zbCDd!^;hu1PNTJRi5!@iDBbxM+)g`}$#EQe>))+PXy=NP)40cmQQEocR95=y?l-k_ zjhs?kp9k00)zr>)a&WJTDb=c_hB!CKscKiO+-0Wq*Kux=vlE&P`}4$H!wqY}EppOw zoE-5JKGAV*lLM0=rTIti80M%ufwIL5pAJ;WE} z+=V(vf&X&6%?Cr)wXB!qWB?4)oi*&m_Nm%=MNSTOMr3&kw=rDfye6j>JNIpt;l9=z za*lz6_4%H`H&n-YOU_xS4DNgTKe*aKJMYMu0{K{r?>CdcGUZyI_vFk0jBQkT?2<{^ z`9RKM$j5ZDPFlm7`;nX-kdN&XXR5KRcD|6) z8p7lHRqjaC@!I)H&M?Twl&$*1GTQk@&TzY8?R~%YrFOoP0}~3REKe(U*AA}QHaFZy z;SrbLv(nH$Kgsd5hq0FWoocD${30hUp9`O!-O_94H#v>5AV_sWerM6nA96Z@gXdz0 zPl#b23nK?BjOYEAHLIbHgIVx^xNWrpK@?4ovt zHjF_|Oo{^Ul}yV3!`d}YOmgyr15d2lr^9AxCl)y{sHm(9y>VW1jpI(vEpTvdvBisV zNjtI0*$DaA)*CXPfMwh@PMm*m;*x{o9iCYJdA4QOapI8!2TWycKhwZ)?D5Gtz|Q1I z9)|fa0Xavxtg1uDp4Me0Bxf{^4)8h*-q=Pv_$|f%z6Ug|`PP}*NlZ>`h=D0u*b6`H zByn;gt#9~DJ4u}!w{CgHXeSvtxc7r6mgn-*>$QWwd}#k|RjkjxVU^!%Cj~ip{|D2j z?xl`tC#93~t>8OD`{3W3{qOHr{`xfsn!&Yiq$VdOv@_n<`hDxq7VUVDgJT_2$k+~s zIU$Xcv*6&38#+!}Cud2Nt$VeTj+{wQ4m`0u#^yBK5BDS|HXaJ3&Nr_>_jf(6^yJ{U z!L*@L4j3M;j+c|O$8FXM?PPFrb{zg<=&KpY$qeOS37I!W>8Io1x1?=u5nz*vb8qmq zzVL6?`eY_21=JMlonT(|9VxOlY!ci(%jogCz>g-6h=9@#2a*G^7y@YBLrpY8*q57tgD za(ct=68qug8zT+#SZ;DULq4|L#dOoh={R}FfsH;ndk)6RrJcOw%#RPB-2ks&K+ibZ z$wy8J$cLu35{;~DC@ViXPaz-A#qh_0p*oH?Iga(B-18N1`d!a^0dm$t40vLFI^WaK zpYa`Y`|ogqVr?BZ3N9aA;}jw%9SV@THMsI!J3i#V%`7S_G}rAM+QDDWw7I2*@X%eY zA}J5}Yo{>lbKBlpm z2k+EQadIZcgFQGn-Kw|ipq&!r;9vX1Yo`ryrVr9iNpc3kBkqq6Ozc-dJAULmflIe3>0$NL}e=MS_KNX`PNFqSpu z<441BRU;=kgvayl^S+4T+NwG^=^!6d<}Tgf(X~D`$O(cRcw&8wu{DEsYLb%~UW#+? zhPS8JX{Q!BS-AxNEia~Pr#3nGIX$d%%yAi@Laz0xLryDbAMA^RBDOZfsY^~ycqxwe ziZk~Z`f5FL(s6y#j56KZsZUM~a4=4e-mMMuY6Eic?>s`L6(d2v1(AXFcEq;2eq2-!R@Alam}OgHDgAB`fJTO~`?b8l?pFCtcD`Q*wrZfqnkY z`&)Ate%fhH&Pm9JCsyF&Kd-dYf}AW62OYl(pYCXwC~GJ+G#^hD|Sw% zJG)#vZOLf|;jwSbNS?r3JMG8`fPAb)lGMN9w7J%&JvmSbiZi=wpA_2ZK#rpglMm>7 zT{|7g!SRJ@?9JiNw9|>F5%AtRa$)=p<~vSAQNN18|asGTn4{DFL&qY}6M)m}SY z|H0`-PI;&d##wdpXj&boJ2@5D`4neGU+wfD2M(C}*xoZ$!Nw!}`@Hug2WL2VVl97| z7?yBXrx!UMkdNtTldHeAgTI7tbIS+$`0DeKGKFcU4>>q*ptHR|sUzCKy*Yfx5Cn8e zN1I2l<#Xc-J??2`0y}=6?MB%dmg$PflEW7^`#hSxa#YLX!Cj5b&C!3R>^oXjJA=u=af4~=`wC69gKOh|f4^z7`{+c8Z$ ztiR9!Z13rUS{LLcmOdImNj?vu@s- zqMaG!43A)6cXCfYIY>J*$?=6aSc3WU*t5tv4EZ>I?mS#GQOB80&S_ZOVZpKfJX~(L zMw>&94K^f+z?s;>W1EgMmz+LOXIxVg^%=ENJM+kS1o@y@y?2j+QeE3;J~>e#A9JS6 zylhyz7m$+y4hp?mO>>XaaTb!(mg8K0TMty%vKEnpYaBeW0#a72qMgO$q=I}*+k-1z z(#{fcO4t>vUx5lww6pXd;w&Qv*9%Ms&hIXx<17~kk0##6KkK!#;vbxql&7a&WGLCsv;wL!pbfw&7}W^0PBNZv7$J2_Xm99elOEAImD{J@=w6YbQCSARo&r zUA%X7?d&24*CrUw*4oWAnrmk_IcXpt>l3wJHA6e^Atxr}V=})FvX`6;cEuW6H!~I=;fWQ=zk6cs93bZ*>qhE0hshZP`Ix5HuLh5<$904pm?$Y_IgzQ8c8-!0pPh-GgJH&ZjdP5g zoZw(i^&uHy`{wE#CuacU!xJmQ%O{5RIYCZp%!mKp&p!!MtZST;N~!wXE25oH zayCOgrpP}J@6*mXa$tg^wC7u|z1lf1Wuf%K_m7Dmjk+WB$(UHFBV%Q(D()KrJ2T zIyt$ZEZhT}`1%TN@41$BgPamvpBCFLjMvUha;8EIc=CU~FMNv}$Gnm2V*0Zyo0zIg=nC4$aDO-b4q{+3e}DNgIgT~g+@GJ2 z<7glAchaAd6MlbwMow2a@aRyV_ZRa1)W`Llobdbe3v#kT9IR8%KXIPwI4{X@w2!$z zzaqym-p$`%eoYRXNJ_mTB%iIzdP9z5&u{)5>|1gibNK9Sb1LdM@5p%qC1D?1;BET6 z)_ZbblR^E*J77*99p?i%*bgz8zvKLooFM3jcrL8Gi|*(+pU6oD+1OXj-*Ns-PB9Q7 zfz!NvE5knF3pv?fLVy8kwOZxXN|*JOoLF3z`8&?v$SDLt@cn?k=fnJTobTjdh2e=6 zI&REb?ff98EgU;KA*15L5Wyq-`#Se0IgNng+BE#bNJCk_{=xZ8&O3;KDPh^gRdrc^ z$SGu3ti=g;`D-VP98YktrVS!?>ZKj*Hvjzwj(M-;Mh;Belxq7<`J>}RAg4OC51y~` z@w~oj$41UpKJPg@1Rv2(L~>SeI}dMLD7$tdk&~F6&v&i|XeTl`^Pn!!2=L>Err*$x zLJnT1Bi_N(sX90LcQSX~p%ucYI|Cg&66V;i=MGdGQP z;*f*yzhmlDsZs~+#3cvc-+@zRH3+mB=8bsd;PpE^v2uhAOQPe%C#NgypK;#sA3ErQ zb`sd*u=BY8o*?ZcBnPjau&iY-tBuo6B64sCh)$<~ZY8vnn4G7OkLl&8J43XCzl3jd zO9%PbL??&+DX*QRuat=X0)_K&nClloUG)8zembO&PXT+lX=gd zot*IZ{P?*lo10_LU$*Yd8M;0>$q9eYpNpJ?_Uc%tnr1QdpWNi+VJ9T4xnZ2E+|Nj0$&Nq%@ zzP>0;PWbzcGUUYPIOgk%vgAAg2cG<&>kIsLn9VH<=#~<>stTe}x!_ap^^lUBdAQ-_>ekdJY` zE$n2tmr|D;{LK(tyHEPhJ*DH+BWDN4N%$uDH0{(U2j@&o)kiKd>=PQ0b`i`RXdHz!MzWrE=QuntyZ-E-v2Zq$1y)A%71i; zcA7fHF@IjPnUmAQYSBl>X--a7str6uJkeA;Ey!`yXG`g(OSIFH9LKu+r$)M;+G#~j zNiOSHwo}ct)0!N|oO$qO9Yg;KA_wnLW7_DkX0ndch8*nkn4YvfH9|XW$w_Wkti}N` z#%iY>IWRaWnLoeLo*cYSfT_vGYaMl*4&*r2%3l*Y25JX?`OxNu-}1)(aeqUp+S=(v zP8}W>F)Mh$w%)b>bS5Vi)#m@bH`;}qAaHPe%{dijh|`sv>yQsmtV3a0%ILDXk%QkJ z#p{b`C5jo&S9fx3P))4qm#in#=r}#d359%2z7tXn(@sxv0%0L?pVMlm7dd_~ zhsOrzS=f7M2G{oKO-^ns2-2YL4~J`~4>^u=y7)|Q&|Ty7CCAZ!4mR!kMLYe-iDxg$ zdVg~*EaR?mg2`zB4xS71_fPwiQ-I@CDpVK_&o#~fa_X_OVride+8Ia=o(pJ3t5M%m z3A8haoCr`EtWWTqQ?R9SEo(42nc?8E9mo3bfUTmdGlU$+p5({w(&M!=lpIGpyWKih zLp#IBaqJ;K=Uio22ZxiBAL@d&Xq|oIP#tFkIZ#nbYX)79p`DTBIL4{@T5pt7eaw5> z(d6KIfqnH)#rIouS!2k-@0LadCuRR;unlx=!?EOqzo#8XP8@hCbbITW`|682&UkXd z-_uSYXB@=9T4ZfqY^RPhksQZwV}7`K8MeT#b)G~{Hm*<1reFGLXEHfcp&aao=HG*z zLQV_F$9|Y;R3&I8*RrPmgENgBc%WqdtlD&P`htNa^q*e!qb_R(IgvrYSSd=hfT_{7 zJ~PQFO(j`Y&Wyz;X=fHW*bnj5Rp!k#ocGz};CaWC;lYJZI?fz&U_zlZeapj^+L=oZ z?t3v6c)QBbhV#h5JwK-N{eCUdapsfL9`doyV=m3`)6N2N(qIrs=HInmNKP5MV!aK! z_)f=JL=J48sI2W@LPl$6F*)>COTddZd3P`EEFtFxmvuT(C^UoX`C3X2_CZYM@0%|p z$FY|v5bJg;9cMW?j(wf^_vcrTgXU?JrD=0v}brM*#5g7*B)|w0An8;>#_EncJ`7}8ysxIYMw!cbFq({%aD&w zAD0sDNi(y5_2UF&m^9GF%qXIJ-n+q83u9Nb@HiavG24DDPd z=eu38LVrhwF5p_$6>?@lWpF)c@V=j6j=D-tU3e+Jx>9dX7;3I@u94#gao~w{>R7$< z+PO{+mV>X3dG%;w?c5*-DnY4Jv&9v(bCVqWYgt%U!(X*vxpS@0EpjFU#&#ZeGB7|p zx5;VEb-sGy8#JeDoIB+B*sEjtugc`7ox9|Ozh2xU2Y+=3k3V9Xr|)%~`{Z2Xu`MT)?Igb8peoylwIk?xtIJ-ypzo*OkL=H@*)Q0`X z$6cYF&*Y>62UGRquMO9FU&w*QhEncB0kd?RujJs~2UE?i#Tsbm8#%C$P<sKjeH6Y$Vsmpi5i3tMl;uVa3}8wfdbJv- z%feruu(>5;Ct{4uhPBB?j$^GfU++XD2e!|Y(s^Zyr^|{&4t{1E4$!K-bo2x5L?)*t zJE;eKFwFB&$SKTat$EkvqK*@loH*=k>EPW)JJHC2Mxm6r7);^nTtp{lH9Hv!#ml0d z802{Kt9K0^*-|?($w|RZiV{)lXeSmq1-PvIaaIn~jypL=*}0mmYentECdaYn4qWLD zr^U68#UZCU*C+AWt(CMBmmE(nYx=AXue1}-$w{(%%opv%cdAd)pbm!nkO|1abrAc; zx^do6tZSVUl5-#OVac$1j9v>(eZ0zKy)1#(#l8`f+o%G&k z7HTIcIU~WrT8ub34=(v!>ywO}p6pa@6LF_@l9N-M%lekGt)Y*lAZHYW#}ce!;|=Rq zN^+V&Hnvad8c{CmvQm))gPhXR%u8=;Cp9@$APCNz>ykaHs~rz=c0oSYXI`nJ3AK}k zoEhwFsC4D2cG8lA-^9fI@yQ#%3Th`EIa@f+!bZ^z`#Mi@Vz3i0^w((}Cp|gt(7|AG zvM%_B7{-?uIgUCvDBta{j+22LjDe}}qmd7^laU_dK789B-%( zI;RdjgUcsZCo?&vAr7`rX!JuLwUdRMnb3yr;FQha4$a^iCo4HyAs;%aHM>Xl)Y{2L zP5{0X(&T=HmuV+EIbESF+()HIl+VzHImlTGap2Ibj$Ic_)^T!@1D%G_*4)>i30&)( zi<}K$U{0Nvvs!2;H#uJRF#qQ_E%T6rzw?H5{?o(Tu%6~6XDZ}lpO63cG)(8N^~pz0 z0WQmTe&>bS$xqH;aPZZAybmnUjyE|l>5$XOz3UY16d(tG9~v@#V}a?UW{`1H{3x(=ZZ7 zgMT>98)e8D2o=WMJE_~H)J|D)xAij`#g9_>^mCkfjl30^slPdwNsy*qmYm3QMdAmwbOtcm{2HvJb0n5b{dlN1PrWmh6S~UXs6LX z)Tc2ygCGXhdBU-|8Fic{`+G$4)jti`h`Flz2 zot#r;s=-o^_TS^8gOg*9)6vN>$LT~)S?Gj#jd45b`t!Q1&g3M3D&XGl`k2;xwbO;1 z5IcHBJ!VJN!B=}!)>xmaF` zE*%W(&H!>CgI+x(;7KMOXCOH_+39!M=b&~5kpmM7rD~@)Jk!o#a%OX!Si^1|(asQZ z9DCZ=i|RvnbUm)2 zs%C4aoss0k!)ihro-2}Jo*zX{A8@d&!cnuqmecjPMw5em71PbvozH1!3^_32(yQBj ztp&r(HO^Ra@E$&%_q_ex^Jr%rIq5l0oSXhJwKJX^=nzyw*!9wJwKIVnN1ZFJyxT-O z6Uo8r3rvZo=WeT=N#y*rE7r4fg9mD7GC7yP!8Qz@8|I;%Dda!~rSUCS7><3alk?#5 z&$~L#G$-fN@*qF$Om}kfrY#wwof+gL;reV$QlW%)W;!`*@=XBS^_NKmRNzrz4bw{nd7XQxwrPGnD7PdmHFaU7R<4DKdp0}Mc1o8I<4 z)kw$LLk@m6701Q8sJXXlXD>O;sK)U5@CJK}YiA!hDcP~AmCC7|{p8^FAf{)9R&3MG z0dnwK2Gf&+wG8{!gXF*k45bAhR#wn)4v~ZRZ7{8$Vj1SB!%mL>qEUwZ*b#CXQ54ue z$9@q*mvxjJA9n6X*#pxs&U%0EGmklymAacJT++BY$DN$SVZTGQbHd4qUufcL?VNOS zo(*$1?AcC{lLKmr=Y8d&$a8d@)8shLSK!7Ga4XTZ&S%K+fEbuk%w1?`=dost=PPnXJD13b&QAH5n+*Ha%T94}u1O!D<6Loy6K~3jx7xW%j-!3bhve#|oonQr z;`+q+?FCzD*WCvijV+##nc915|zg@fgE^Fs8IgWY0Zt6`z+Id1w zIyfdw`C6Q-q@AbaIL5Mh?tMm1_;c@bavc58JommJ$1w)YbMH$h$2|AGA}6!`u&mw- zf?;ds+Mi#O(}*4O{QQQT@aN~Z#|o5?Yt+)i=Bj#{J&}E z138ZNF|P$5ogDL8@X5(BuLYl-9P?W6g`Du$g0JK_`j2@n_(qNgAG>)i_)d;vT$tB_ zALKatn0YPu=~N%{TJVb;M?0I>g5TtXzZU!`oZy93zG%mb9LM?kP_kQ~b}~4{c@{OxXYFJp2PR5Nb&vW% z)m+beCUS0o0ZnbSy|r(Yb~4-R1M?4b9BbG2C5F9d7IGYY_5A&DhB#TtajdzK#%(X9 z%gRPhcd9XbrYlLpb=t{J4)z^P%?E5ZjME%Wac*3T2is`ZW6w#BW8U!pu-bjE*`}y4DIF4&Umd#$etUTo8g!*DFY_%VRY9}u_-=RXu!FjiS?P<<7nqxR|>$k!nJ)0kmJ}(EX@$ZaPOj^lhZKnz?nKuA#zgN zt7G{b>-ShYK2C9>AI)L7m*VT>M5yqkzm8Mb$%#C27Br>naTRfLe&>q>-PYA9N{*v_ zelB`{Ks&|Aah!`KJ7b(oQLIeAwBa?cGD|lqM%0J6^S-m)A}ia%!;?&m(SC?UW^_FH|!sc!8mj z>S(7NISn8mkIVd91pefl1_7O%Vbcv`r#v~y*!j^p(GOi#1#+-`FizYU-rm}&NDfq# z(w)@PT4|>eIdH&~2As||L^}cG#Oy(Q<)sdptR)kA=pa0p3^GiG-79S*H^u@ zQe8`SksG@lNQ%;nvj#0-FcCAT9bp<7dH4WTlRsav=c;*PA76;vY?b_!3M*1Q)hA<{bzjRhWB-xF63nAI8nbp+O3_g

    J-W|7sIw9}0o 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