From c4d2d287fc0eac7348951ce275a1f3d80f25ef3d Mon Sep 17 00:00:00 2001 From: gingerBill Date: Sat, 17 Feb 2018 11:54:08 +0000 Subject: [PATCH] #complete switch; Removal of dyncall --- examples/demo.odin | 56 +++- src/check_stmt.cpp | 230 +++++++++++--- src/check_type.cpp | 5 +- src/dyncall/include/dyncall.h | 143 --------- src/dyncall/include/dyncall_alloc_wx.h | 47 --- src/dyncall/include/dyncall_args.h | 66 ---- src/dyncall/include/dyncall_args_arm32_arm.h | 46 --- .../include/dyncall_args_arm32_thumb.h | 33 -- src/dyncall/include/dyncall_args_mips.h | 42 --- src/dyncall/include/dyncall_args_ppc32.h | 43 --- src/dyncall/include/dyncall_args_ppc64.h | 40 --- src/dyncall/include/dyncall_args_sparc32.h | 38 --- src/dyncall/include/dyncall_args_sparc64.h | 38 --- src/dyncall/include/dyncall_args_x64.h | 45 --- src/dyncall/include/dyncall_args_x86.h | 59 ---- src/dyncall/include/dyncall_callback.h | 53 ---- .../include/dyncall_callback_arm32_arm.h | 46 --- .../include/dyncall_callback_arm32_thumb.h | 34 --- src/dyncall/include/dyncall_callback_mips.h | 43 --- src/dyncall/include/dyncall_callback_ppc32.h | 43 --- src/dyncall/include/dyncall_callback_ppc64.h | 56 ---- .../include/dyncall_callback_sparc32.h | 44 --- src/dyncall/include/dyncall_callback_x64.h | 45 --- src/dyncall/include/dyncall_callback_x86.h | 50 --- src/dyncall/include/dyncall_callf.h | 56 ---- src/dyncall/include/dyncall_config.h | 47 --- src/dyncall/include/dyncall_macros.h | 289 ------------------ src/dyncall/include/dyncall_signature.h | 72 ----- src/dyncall/include/dyncall_thunk.h | 90 ------ src/dyncall/include/dyncall_thunk_arm32_arm.h | 41 --- .../include/dyncall_thunk_arm32_thumb.h | 36 --- src/dyncall/include/dyncall_thunk_arm64.h | 42 --- src/dyncall/include/dyncall_thunk_mips.h | 38 --- src/dyncall/include/dyncall_thunk_ppc32.h | 40 --- src/dyncall/include/dyncall_thunk_ppc64.h | 55 ---- src/dyncall/include/dyncall_thunk_sparc32.h | 37 --- src/dyncall/include/dyncall_thunk_sparc64.h | 37 --- src/dyncall/include/dyncall_thunk_x64.h | 40 --- src/dyncall/include/dyncall_thunk_x86.h | 40 --- src/dyncall/include/dyncall_types.h | 75 ----- src/dyncall/include/dyncall_value.h | 91 ------ src/dyncall/include/dynload.h | 66 ---- src/dyncall/lib/libdyncall_s.lib | Bin 25454 -> 0 bytes src/dyncall/lib/libdyncallback_s.lib | Bin 7254 -> 0 bytes src/dyncall/lib/libdynload_s.lib | Bin 3342 -> 0 bytes src/exact_value.cpp | 24 ++ src/ir.cpp | 15 +- src/map.cpp | 14 +- src/parser.cpp | 25 ++ src/parser.hpp | 20 +- src/tokenizer.cpp | 16 + src/types.cpp | 7 +- 52 files changed, 330 insertions(+), 2328 deletions(-) delete mode 100644 src/dyncall/include/dyncall.h delete mode 100644 src/dyncall/include/dyncall_alloc_wx.h delete mode 100644 src/dyncall/include/dyncall_args.h delete mode 100644 src/dyncall/include/dyncall_args_arm32_arm.h delete mode 100644 src/dyncall/include/dyncall_args_arm32_thumb.h delete mode 100644 src/dyncall/include/dyncall_args_mips.h delete mode 100644 src/dyncall/include/dyncall_args_ppc32.h delete mode 100644 src/dyncall/include/dyncall_args_ppc64.h delete mode 100644 src/dyncall/include/dyncall_args_sparc32.h delete mode 100644 src/dyncall/include/dyncall_args_sparc64.h delete mode 100644 src/dyncall/include/dyncall_args_x64.h delete mode 100644 src/dyncall/include/dyncall_args_x86.h delete mode 100644 src/dyncall/include/dyncall_callback.h delete mode 100644 src/dyncall/include/dyncall_callback_arm32_arm.h delete mode 100644 src/dyncall/include/dyncall_callback_arm32_thumb.h delete mode 100644 src/dyncall/include/dyncall_callback_mips.h delete mode 100644 src/dyncall/include/dyncall_callback_ppc32.h delete mode 100644 src/dyncall/include/dyncall_callback_ppc64.h delete mode 100644 src/dyncall/include/dyncall_callback_sparc32.h delete mode 100644 src/dyncall/include/dyncall_callback_x64.h delete mode 100644 src/dyncall/include/dyncall_callback_x86.h delete mode 100644 src/dyncall/include/dyncall_callf.h delete mode 100644 src/dyncall/include/dyncall_config.h delete mode 100644 src/dyncall/include/dyncall_macros.h delete mode 100644 src/dyncall/include/dyncall_signature.h delete mode 100644 src/dyncall/include/dyncall_thunk.h delete mode 100644 src/dyncall/include/dyncall_thunk_arm32_arm.h delete mode 100644 src/dyncall/include/dyncall_thunk_arm32_thumb.h delete mode 100644 src/dyncall/include/dyncall_thunk_arm64.h delete mode 100644 src/dyncall/include/dyncall_thunk_mips.h delete mode 100644 src/dyncall/include/dyncall_thunk_ppc32.h delete mode 100644 src/dyncall/include/dyncall_thunk_ppc64.h delete mode 100644 src/dyncall/include/dyncall_thunk_sparc32.h delete mode 100644 src/dyncall/include/dyncall_thunk_sparc64.h delete mode 100644 src/dyncall/include/dyncall_thunk_x64.h delete mode 100644 src/dyncall/include/dyncall_thunk_x86.h delete mode 100644 src/dyncall/include/dyncall_types.h delete mode 100644 src/dyncall/include/dyncall_value.h delete mode 100644 src/dyncall/include/dynload.h delete mode 100644 src/dyncall/lib/libdyncall_s.lib delete mode 100644 src/dyncall/lib/libdyncallback_s.lib delete mode 100644 src/dyncall/lib/libdynload_s.lib diff --git a/examples/demo.odin b/examples/demo.odin index 3ff904d88..85868e35b 100644 --- a/examples/demo.odin +++ b/examples/demo.odin @@ -729,17 +729,49 @@ explicit_procedure_overloading :: proc() { // add(1, 2.0); } -main :: proc() { - when true { - // general_stuff(); - // default_struct_values(); - // union_type(); - // parametric_polymorphism(); - // threading_example(); - // array_programming(); - // using_in(); - // named_proc_return_parameters(); - // enum_export(); - // explicit_procedure_overloading(); +complete_switch :: proc() { + { // enum + Foo :: enum #export { + A, + B, + C, + D, + } + + b := Foo.B; + f := Foo.A; + #complete switch f { + case A...C: fmt.println("A...C"); + // case A: fmt.println("A"); + // case B: fmt.println("B"); + // case C: fmt.println("C"); + case D: fmt.println("D"); + case: fmt.println("?"); + } + } + { // union + Foo :: union {int, bool}; + f: Foo = 123; + #complete switch _ in f { + case int: fmt.println("int"); + case bool: fmt.println("bool"); + case: + } + } +} + +main :: proc() { + when true { + general_stuff(); + default_struct_values(); + union_type(); + parametric_polymorphism(); + threading_example(); + array_programming(); + using_in(); + named_proc_return_parameters(); + enum_export(); + explicit_procedure_overloading(); + complete_switch(); } } diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 1014b8c46..840df6ad9 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -454,7 +454,7 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo case Entity_TypeName: { Type *t = base_type(e->type); if (t->kind == Type_Enum) { - for (isize i = 0; i < t->Enum.field_count; i++) { + for_array(i, t->Enum.fields) { Entity *f = t->Enum.fields[i]; if (!is_entity_exported(f)) continue; @@ -555,6 +555,52 @@ bool check_using_stmt_entity(Checker *c, AstNodeUsingStmt *us, AstNode *expr, bo return true; } + +struct TypeAndToken { + Type *type; + Token token; +}; + +void add_constant_switch_case(Checker *c, Map *seen, Operand operand, bool use_expr = true) { + if (operand.value.kind == ExactValue_Invalid) { + return; + } + HashKey key = hash_exact_value(operand.value); + TypeAndToken *found = map_get(seen, key); + if (found != nullptr) { + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); + defer (gb_temp_arena_memory_end(tmp)); + + isize count = multi_map_count(seen, key); + TypeAndToken *taps = gb_alloc_array(c->tmp_allocator, TypeAndToken, count); + + multi_map_get_all(seen, key, taps); + for (isize i = 0; i < count; i++) { + TypeAndToken tap = taps[i]; + if (are_types_identical(operand.type, tap.type)) { + TokenPos pos = tap.token.pos; + if (use_expr) { + gbString expr_str = expr_to_string(operand.expr); + error(operand.expr, + "Duplicate case '%s'\n" + "\tprevious case at %.*s(%td:%td)", + expr_str, + LIT(pos.file), pos.line, pos.column); + gb_string_free(expr_str); + } else { + error(operand.expr, + "Duplicate case found with previous case at %.*s(%td:%td)", + LIT(pos.file), pos.line, pos.column); + } + return; + } + } + } + + TypeAndToken tap = {operand.type, ast_node_token(operand.expr)}; + multi_map_insert(seen, key, tap); +} + void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { ast_node(ss, SwitchStmt, node); @@ -611,12 +657,16 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { } } - struct TypeAndToken { - Type *type; - Token token; - }; + bool complete = ss->complete; - Map seen = {}; // NOTE(bill): Multimap + if (complete) { + if (!is_type_enum(x.type)) { + error(x.expr, "#complete switch statement can be only used with an enum type"); + complete = false; + } + } + + Map seen = {}; // NOTE(bill): Multimap, Key: ExactValue map_init(&seen, heap_allocator()); defer (map_destroy(&seen)); @@ -680,9 +730,48 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { default: error(ie->op, "Invalid interval operator"); continue; } + + Operand a1 = lhs; Operand b1 = rhs; check_comparison(c, &a1, &b1, op); + if (complete) { + if (lhs.mode != Addressing_Constant) { + error(lhs.expr, "#complete switch statement only allows constant case clauses"); + } + if (rhs.mode != Addressing_Constant) { + error(rhs.expr, "#complete switch statement only allows constant case clauses"); + } + } + + if (a1.mode != Addressing_Invalid && + lhs.mode == Addressing_Constant && rhs.mode == Addressing_Constant) { + ExactValue start = lhs.value; + ExactValue end = rhs.value; + ExactValue one = exact_value_i64(1); + match_exact_values(&one, &start); + for (ExactValue i = start; + compare_exact_values(op, i, end); + i = exact_value_add(i, one)) { + bool use_expr = false; + Operand x = lhs; + x.value = i; + if (compare_exact_values(Token_CmpEq, i, start)) { + use_expr = true; + } else if (compare_exact_values(Token_CmpEq, i, end)) { + x = rhs; + use_expr = true; + } + add_constant_switch_case(c, &seen, x, use_expr); + } + } else { + if (lhs.mode == Addressing_Constant) { + add_constant_switch_case(c, &seen, lhs); + } + if (rhs.mode == Addressing_Constant && op == Token_LtEq) { + add_constant_switch_case(c, &seen, rhs); + } + } } else { Operand y = {}; check_expr(c, &y, expr); @@ -704,47 +793,13 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { continue; } if (y.mode != Addressing_Constant) { + if (complete) { + error(y.expr, "#complete switch statement only allows constant case clauses"); + } continue; } - - if (y.value.kind != ExactValue_Invalid) { - HashKey key = hash_exact_value(y.value); - TypeAndToken *found = map_get(&seen, key); - if (found != nullptr) { - gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); - defer (gb_temp_arena_memory_end(tmp)); - - isize count = multi_map_count(&seen, key); - TypeAndToken *taps = gb_alloc_array(c->tmp_allocator, TypeAndToken, count); - - multi_map_get_all(&seen, key, taps); - bool continue_outer = false; - - for (isize i = 0; i < count; i++) { - TypeAndToken tap = taps[i]; - if (are_types_identical(y.type, tap.type)) { - TokenPos pos = tap.token.pos; - gbString expr_str = expr_to_string(y.expr); - error(y.expr, - "Duplicate case '%s'\n" - "\tprevious case at %.*s(%td:%td)", - expr_str, - LIT(pos.file), pos.line, pos.column); - gb_string_free(expr_str); - continue_outer = true; - break; - } - } - - - if (continue_outer) { - continue; - } - } - TypeAndToken tap = {y.type, ast_node_token(y.expr)}; - multi_map_insert(&seen, key, tap); - } + add_constant_switch_case(c, &seen, y); } } @@ -752,6 +807,47 @@ void check_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { check_stmt_list(c, cc->stmts, mod_flags); check_close_scope(c); } + + if (complete) { + Type *et = base_type(x.type); + GB_ASSERT(is_type_enum(et)); + auto fields = et->Enum.fields; + + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); + defer (gb_temp_arena_memory_end(tmp)); + + Array unhandled = {}; + array_init(&unhandled, c->tmp_allocator, fields.count); + + for_array(i, fields) { + Entity *f = fields[i]; + if (f->kind != Entity_Constant) { + continue; + } + ExactValue v = f->Constant.value; + HashKey key = hash_exact_value(v); + auto found = map_get(&seen, key); + if (!found) { + array_add(&unhandled, f); + } + } + + if (unhandled.count > 0) { + if (unhandled.count == 1) { + error_no_newline(node, "Unhandled switch case: "); + } else { + error_no_newline(node, "Unhandled switch cases: "); + } + for_array(i, unhandled) { + Entity *f = unhandled[i]; + if (i > 0) { + gb_printf_err(", "); + } + gb_printf_err("%.*s", LIT(f->token.string)); + } + gb_printf_err("\n"); + } + } } @@ -812,6 +908,14 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { return; } + bool complete = ss->complete; + if (complete) { + if (switch_kind != Switch_Union) { + error(node, "#complete switch statement may only be used with a union"); + complete = false; + } + } + bool is_ptr = is_type_pointer(x.type); // NOTE(bill): Check for multiple defaults @@ -935,6 +1039,44 @@ void check_type_switch_stmt(Checker *c, AstNode *node, u32 mod_flags) { check_stmt_list(c, cc->stmts, mod_flags); check_close_scope(c); } + + if (complete) { + Type *ut = base_type(x.type); + GB_ASSERT(is_type_union(ut)); + auto variants = ut->Union.variants; + + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena); + defer (gb_temp_arena_memory_end(tmp)); + + Array unhandled = {}; + array_init(&unhandled, c->tmp_allocator, variants.count); + + for_array(i, variants) { + Type *t = variants[i]; + auto found = map_get(&seen, hash_type(t)); + if (!found) { + array_add(&unhandled, t); + } + } + + if (unhandled.count > 0) { + if (unhandled.count == 1) { + error_no_newline(node, "Unhandled switch case: "); + } else { + error_no_newline(node, "Unhandled switch cases: "); + } + for_array(i, unhandled) { + Type *t = unhandled[i]; + if (i > 0) { + gb_printf_err(", "); + } + gbString s = type_to_string(t); + gb_printf_err("%s", s); + gb_string_free(s); + } + gb_printf_err("\n"); + } + } } void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { diff --git a/src/check_type.cpp b/src/check_type.cpp index 47e27c27d..ebcd297db 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -794,9 +794,8 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod GB_ASSERT(fields.count <= et->fields.count); - enum_type->Enum.fields = fields.data; - enum_type->Enum.field_count = cast(i32)fields.count; - enum_type->Enum.is_export = et->is_export; + enum_type->Enum.fields = fields; + enum_type->Enum.is_export = et->is_export; if (et->is_export) { Scope *parent = c->context.scope->parent; for_array(i, fields) { diff --git a/src/dyncall/include/dyncall.h b/src/dyncall/include/dyncall.h deleted file mode 100644 index 28981472e..000000000 --- a/src/dyncall/include/dyncall.h +++ /dev/null @@ -1,143 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall.h - Description: public header for library dyncall - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -/* - - dyncall C API - - REVISION - 2015/07/08 added SYS_PPC64 system call - 2015/01/16 added SYS_PPC32 system call - 2007/12/11 initial - -*/ - -#ifndef DYNCALL_H -#define DYNCALL_H - -#include "dyncall_types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct DCCallVM_ DCCallVM; -typedef struct DCstruct_ DCstruct; - -/* Supported Calling Convention Modes */ - -#define DC_CALL_C_DEFAULT 0 -#define DC_CALL_C_ELLIPSIS 100 -#define DC_CALL_C_ELLIPSIS_VARARGS 101 -#define DC_CALL_C_X86_CDECL 1 -#define DC_CALL_C_X86_WIN32_STD 2 -#define DC_CALL_C_X86_WIN32_FAST_MS 3 -#define DC_CALL_C_X86_WIN32_FAST_GNU 4 -#define DC_CALL_C_X86_WIN32_THIS_MS 5 -#define DC_CALL_C_X86_WIN32_THIS_GNU 6 -#define DC_CALL_C_X64_WIN64 7 -#define DC_CALL_C_X64_SYSV 8 -#define DC_CALL_C_PPC32_DARWIN 9 -#define DC_CALL_C_PPC32_OSX DC_CALL_C_PPC32_DARWIN /* alias */ -#define DC_CALL_C_ARM_ARM_EABI 10 -#define DC_CALL_C_ARM_THUMB_EABI 11 -#define DC_CALL_C_ARM_ARMHF 30 -#define DC_CALL_C_MIPS32_EABI 12 -#define DC_CALL_C_MIPS32_PSPSDK DC_CALL_C_MIPS32_EABI /* alias - deprecated. */ -#define DC_CALL_C_PPC32_SYSV 13 -#define DC_CALL_C_PPC32_LINUX DC_CALL_C_PPC32_SYSV /* alias */ -#define DC_CALL_C_ARM_ARM 14 -#define DC_CALL_C_ARM_THUMB 15 -#define DC_CALL_C_MIPS32_O32 16 -#define DC_CALL_C_MIPS64_N32 17 -#define DC_CALL_C_MIPS64_N64 18 -#define DC_CALL_C_X86_PLAN9 19 -#define DC_CALL_C_SPARC32 20 -#define DC_CALL_C_SPARC64 21 -#define DC_CALL_C_ARM64 22 -#define DC_CALL_C_PPC64 23 -#define DC_CALL_C_PPC64_LINUX DC_CALL_C_PPC64 /* alias */ -#define DC_CALL_SYS_DEFAULT 200 -#define DC_CALL_SYS_X86_INT80H_LINUX 201 -#define DC_CALL_SYS_X86_INT80H_BSD 202 -#define DC_CALL_SYS_PPC32 210 -#define DC_CALL_SYS_PPC64 211 - -/* Error codes. */ - -#define DC_ERROR_NONE 0 -#define DC_ERROR_UNSUPPORTED_MODE -1 - -DC_API DCCallVM* dcNewCallVM (DCsize size); -DC_API void dcFree (DCCallVM* vm); -DC_API void dcReset (DCCallVM* vm); - -DC_API void dcMode (DCCallVM* vm, DCint mode); - -DC_API void dcArgBool (DCCallVM* vm, DCbool value); -DC_API void dcArgChar (DCCallVM* vm, DCchar value); -DC_API void dcArgShort (DCCallVM* vm, DCshort value); -DC_API void dcArgInt (DCCallVM* vm, DCint value); -DC_API void dcArgLong (DCCallVM* vm, DClong value); -DC_API void dcArgLongLong (DCCallVM* vm, DClonglong value); -DC_API void dcArgFloat (DCCallVM* vm, DCfloat value); -DC_API void dcArgDouble (DCCallVM* vm, DCdouble value); -DC_API void dcArgPointer (DCCallVM* vm, DCpointer value); -DC_API void dcArgStruct (DCCallVM* vm, DCstruct* s, DCpointer value); - -DC_API void dcCallVoid (DCCallVM* vm, DCpointer funcptr); -DC_API DCbool dcCallBool (DCCallVM* vm, DCpointer funcptr); -DC_API DCchar dcCallChar (DCCallVM* vm, DCpointer funcptr); -DC_API DCshort dcCallShort (DCCallVM* vm, DCpointer funcptr); -DC_API DCint dcCallInt (DCCallVM* vm, DCpointer funcptr); -DC_API DClong dcCallLong (DCCallVM* vm, DCpointer funcptr); -DC_API DClonglong dcCallLongLong (DCCallVM* vm, DCpointer funcptr); -DC_API DCfloat dcCallFloat (DCCallVM* vm, DCpointer funcptr); -DC_API DCdouble dcCallDouble (DCCallVM* vm, DCpointer funcptr); -DC_API DCpointer dcCallPointer (DCCallVM* vm, DCpointer funcptr); -DC_API void dcCallStruct (DCCallVM* vm, DCpointer funcptr, DCstruct* s, DCpointer returnValue); - -DC_API DCint dcGetError (DCCallVM* vm); - -#define DEFAULT_ALIGNMENT 0 -DC_API DCstruct* dcNewStruct (DCsize fieldCount, DCint alignment); -DC_API void dcStructField (DCstruct* s, DCint type, DCint alignment, DCsize arrayLength); -DC_API void dcSubStruct (DCstruct* s, DCsize fieldCount, DCint alignment, DCsize arrayLength); -/* Each dcNewStruct or dcSubStruct call must be paired with a dcCloseStruct. */ -DC_API void dcCloseStruct (DCstruct* s); -DC_API DCsize dcStructSize (DCstruct* s); -DC_API DCsize dcStructAlignment(DCstruct* s); -DC_API void dcFreeStruct (DCstruct* s); - -DC_API DCstruct* dcDefineStruct (const char* signature); - - -#ifdef __cplusplus -} -#endif - -#endif /* DYNCALL_H */ - diff --git a/src/dyncall/include/dyncall_alloc_wx.h b/src/dyncall/include/dyncall_alloc_wx.h deleted file mode 100644 index c948f0bd3..000000000 --- a/src/dyncall/include/dyncall_alloc_wx.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_alloc_wx.h - Description: Allocate write/executable memory - Interface - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_ALLOC_WX_HPP -#define DYNCALL_ALLOC_WX_HPP - -#include "dyncall_types.h" - -typedef int DCerror; - -#ifdef __cplusplus -extern "C" { -#endif - -DCerror dcAllocWX(DCsize size, void** p); -void dcFreeWX (void* p, DCsize size); - -#ifdef __cplusplus -} -#endif - - -#endif /* DYNCALL_ALLOC_WX_HPP */ - diff --git a/src/dyncall/include/dyncall_args.h b/src/dyncall/include/dyncall_args.h deleted file mode 100644 index 4379a53b1..000000000 --- a/src/dyncall/include/dyncall_args.h +++ /dev/null @@ -1,66 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args.h - Description: Callback's Arguments VM - Interface - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_ARGS_H -#define DYNCALL_ARGS_H - -/* - * dyncall args C API - * - * dyncall args provides serialized access to arguments of a function call. - * related concepts: callback - * - */ - -#include "dyncall.h" - - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct DCArgs DCArgs; - -DC_API DCbool dcbArgBool (DCArgs*); -DC_API DCchar dcbArgChar (DCArgs*); -DC_API DCshort dcbArgShort (DCArgs*); -DC_API DCint dcbArgInt (DCArgs*); -DC_API DClong dcbArgLong (DCArgs*); -DC_API DClonglong dcbArgLongLong (DCArgs*); -DC_API DCuchar dcbArgUChar (DCArgs*); -DC_API DCushort dcbArgUShort (DCArgs*); -DC_API DCuint dcbArgUInt (DCArgs*); -DC_API DCulong dcbArgULong (DCArgs*); -DC_API DCulonglong dcbArgULongLong(DCArgs*); -DC_API DCfloat dcbArgFloat (DCArgs*); -DC_API DCdouble dcbArgDouble (DCArgs*); -DC_API DCpointer dcbArgPointer (DCArgs*); - -#ifdef __cplusplus -} -#endif - -#endif /* DYNCALL_ARGS_H */ diff --git a/src/dyncall/include/dyncall_args_arm32_arm.h b/src/dyncall/include/dyncall_args_arm32_arm.h deleted file mode 100644 index 92fbd9099..000000000 --- a/src/dyncall/include/dyncall_args_arm32_arm.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_arm32_arm.h - Description: Callback's Arguments VM - Header for ARM32 (ARM mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_ARM32_ARM_H -#define DYNCALLBACK_ARGS_ARM32_ARM_H - -#include "dyncall_args.h" - -struct DCArgs -{ - /* Don't change order! */ - long reg_data[4]; - int reg_count; - long* stack_ptr; -#if defined(DC__ABI_ARM_HF) - DCfloat f[16]; - int freg_count; - int dreg_count; -#endif -}; - -#endif /* DYNCALLBACK_ARGS_ARM32_ARM_H */ - diff --git a/src/dyncall/include/dyncall_args_arm32_thumb.h b/src/dyncall/include/dyncall_args_arm32_thumb.h deleted file mode 100644 index 07b6d39ce..000000000 --- a/src/dyncall/include/dyncall_args_arm32_thumb.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_arm32_thumb.h - Description: Callback's Arguments VM - Header for ARM32 (THUMB mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_ARM32_THUMB_H -#define DYNCALLBACK_ARGS_ARM32_THUMB_H - -#include "dyncall_args_arm32_arm.h" /* Uses same code as ARM mode. */ - -#endif /* DYNCALLBACK_ARGS_ARM32_THUMB_H */ - diff --git a/src/dyncall/include/dyncall_args_mips.h b/src/dyncall/include/dyncall_args_mips.h deleted file mode 100644 index 4cb0220ea..000000000 --- a/src/dyncall/include/dyncall_args_mips.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_mips.h - Description: Callback's Arguments VM - Header for MIPS - License: - - Copyright (c) 2013-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_MIPS_H -#define DYNCALLBACK_ARGS_MIPS_H - -#include "dyncall_args.h" - -struct DCArgs -{ - int ireg_data[8]; - float freg_data[8]; - int ireg_count; - int freg_count; - unsigned char* stackptr; -}; - -#endif /* DYNCALLBACK_ARGS_MIPS_H */ - diff --git a/src/dyncall/include/dyncall_args_ppc32.h b/src/dyncall/include/dyncall_args_ppc32.h deleted file mode 100644 index 46319ec28..000000000 --- a/src/dyncall/include/dyncall_args_ppc32.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_ppc32.h - Description: Callback's Arguments VM - Header for ppc32 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALLBACK_ARGS_PPC32_H -#define DYNCALLBACK_ARGS_PPC32_H - -#include "dyncall_args.h" - -/* Common Args iterator for Apple and System V ABI. */ - -struct DCArgs -{ - int ireg_data[8]; /* offset: 0 size: 4*8 = 32 */ - double freg_data[13]; /* offset: 32 size: 8*13= 104 */ - unsigned char* stackptr; /* offset: 136 size: 4 */ - int ireg_count; /* offset: 140 size: 4 */ - int freg_count; /* offset: 144 size: 4 */ -}; /* total size: 148 */ - -#endif /* DYNCALLBACK_ARGS_PPC32_H */ - diff --git a/src/dyncall/include/dyncall_args_ppc64.h b/src/dyncall/include/dyncall_args_ppc64.h deleted file mode 100644 index 208e2c65d..000000000 --- a/src/dyncall/include/dyncall_args_ppc64.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_ppc64.h - Description: Callback's Arguments VM - Header for ppc64 - License: - - Copyright (c) 2014-2015 Masanori Mitsugi - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALLBACK_ARGS_PPC64_H -#define DYNCALLBACK_ARGS_PPC64_H - -#include "dyncall_args.h" - -struct DCArgs -{ - long long ireg_data[8]; - double freg_data[13]; - unsigned char* stackptr; - int ireg_count; - int freg_count; -}; - -#endif /* DYNCALLBACK_ARGS_PPC64_H */ - diff --git a/src/dyncall/include/dyncall_args_sparc32.h b/src/dyncall/include/dyncall_args_sparc32.h deleted file mode 100644 index d7e42581c..000000000 --- a/src/dyncall/include/dyncall_args_sparc32.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_sparc32.h - Description: Callback's Arguments VM - Header for sparc32 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_SPARC32_H -#define DYNCALLBACK_ARGS_SPARC32_H - -#include "dyncall_args.h" - -struct DCArgs -{ - int dummy; -}; - -#endif /* DYNCALLBACK_ARGS_SPARC32_H */ - diff --git a/src/dyncall/include/dyncall_args_sparc64.h b/src/dyncall/include/dyncall_args_sparc64.h deleted file mode 100644 index d238d09cb..000000000 --- a/src/dyncall/include/dyncall_args_sparc64.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_sparc64.h - Description: Callback's Arguments VM - Header for sparc32 - not yet - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_SPARC64_H -#define DYNCALLBACK_ARGS_SPARC64_H - -#include "dyncall_args.h" - -struct DCArgs -{ - int dummy; -}; - -#endif /* DYNCALLBACK_ARGS_SPARC64_H */ - diff --git a/src/dyncall/include/dyncall_args_x64.h b/src/dyncall/include/dyncall_args_x64.h deleted file mode 100644 index cc10f6bed..000000000 --- a/src/dyncall/include/dyncall_args_x64.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_x64.h - Description: Callback's Arguments VM - Header for x64 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALLBACK_ARGS_X64_H -#define DYNCALLBACK_ARGS_X64_H - -#include "dyncall_args.h" -#include "dyncall_callvm_x64.h" /* reuse structures */ - - -struct DCArgs -{ - /* state */ - int64* stack_ptr; - DCRegCount_x64 reg_count; /* @@@ win64 version should maybe force alignment to 8 in order to be secure */ - - /* reg data */ - DCRegData_x64_s reg_data; -}; - -#endif /* DYNCALLBACK_ARGS_X64_H */ - diff --git a/src/dyncall/include/dyncall_args_x86.h b/src/dyncall/include/dyncall_args_x86.h deleted file mode 100644 index d679dcee3..000000000 --- a/src/dyncall/include/dyncall_args_x86.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_args_x86.h - Description: Callback's Arguments VM - Header for x86 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNCALL_ARGS_X86_H_ -#define DYNCALL_ARGS_X86_H_ - -#include "dyncall_args.h" - -typedef struct -{ - DCint (*i32)(DCArgs*); - DClonglong (*i64)(DCArgs*); - DCfloat (*f32)(DCArgs*); - DCdouble (*f64)(DCArgs*); -} DCArgsVT; - -extern DCArgsVT dcArgsVT_default; -extern DCArgsVT dcArgsVT_this_ms; -extern DCArgsVT dcArgsVT_fast_ms; -extern DCArgsVT dcArgsVT_fast_gnu; - -struct DCArgs -{ - /* callmode */ - DCArgsVT* vt; - - /* state */ - int* stack_ptr; - - /* fast data / 'this-ptr' info */ - int fast_data[2]; - int fast_count; -}; - -#endif /* DYNCALL_ARGS_X86_H_ */ diff --git a/src/dyncall/include/dyncall_callback.h b/src/dyncall/include/dyncall_callback.h deleted file mode 100644 index 6d599df61..000000000 --- a/src/dyncall/include/dyncall_callback.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback.h - Description: Callback - Interface - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_CALLBACK_H -#define DYNCALL_CALLBACK_H - -#include "dyncall_args.h" -#include "dyncall_signature.h" -#include "dyncall_value.h" - -typedef struct DCCallback DCCallback; - -// TODO: return value is the type encoded as a signature char (character of the set [vBcCsSiIjJlLfd]). - -typedef char (DCCallbackHandler)(DCCallback* pcb, DCArgs* args, DCValue* result, void* userdata); - -#ifdef __cplusplus -extern "C" { -#endif - -DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* funcptr, void* userdata); -void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata); -void dcbFreeCallback(DCCallback* pcb); -void* dcbGetUserData (DCCallback* pcb); - - -#ifdef __cplusplus -} -#endif - -#endif /* DYNCALL_CALLBACK_H */ diff --git a/src/dyncall/include/dyncall_callback_arm32_arm.h b/src/dyncall/include/dyncall_callback_arm32_arm.h deleted file mode 100644 index b463549e3..000000000 --- a/src/dyncall/include/dyncall_callback_arm32_arm.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_arm32_arm.h - Description: Callback - Header for ARM32 (ARM mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNCALL_CALLBACK_ARM32_ARM_H_ -#define DYNCALL_CALLBACK_ARM32_ARM_H_ - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_arm32_arm.h" - - -struct DCCallback -{ - DCThunk thunk; // offset 0 - DCCallbackHandler* handler; // offset 12 - void* userdata; // offset 16 -}; - - -#endif /* DYNCALL_CALLBACK_ARM32_ARM_H_ */ - diff --git a/src/dyncall/include/dyncall_callback_arm32_thumb.h b/src/dyncall/include/dyncall_callback_arm32_thumb.h deleted file mode 100644 index 1e4651f37..000000000 --- a/src/dyncall/include/dyncall_callback_arm32_thumb.h +++ /dev/null @@ -1,34 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_arm32_thumb.h - Description: Callback - Header for ARM32 (THUMB mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNCALL_CALLBACK_ARM32_THUMB_H_ -#define DYNCALL_CALLBACK_ARM32_THUMB_H_ - -#include "dyncall_callback_arm32_arm.h" /* Uses same code as ARM mode. */ - -#endif /* DYNCALL_CALLBACK_ARM32_THUMB_H_ */ - diff --git a/src/dyncall/include/dyncall_callback_mips.h b/src/dyncall/include/dyncall_callback_mips.h deleted file mode 100644 index 7814638f0..000000000 --- a/src/dyncall/include/dyncall_callback_mips.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_mips.h - Description: Callback - Header for MIPS - License: - - Copyright (c) 2013-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_CALLBACK_MIPS_H -#define DYNCALL_CALLBACK_MIPS_H - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_mips.h" - -struct DCCallback -{ - DCThunk thunk; /* offset 0, size 20 */ - DCCallbackHandler* handler; /* offset 20, size 4 */ - void* userdata; /* offset 24, size 4 */ -}; - -#endif /* DYNCALL_CALLBACK_MIPS_H */ - diff --git a/src/dyncall/include/dyncall_callback_ppc32.h b/src/dyncall/include/dyncall_callback_ppc32.h deleted file mode 100644 index a252b1a12..000000000 --- a/src/dyncall/include/dyncall_callback_ppc32.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_ppc32.h - Description: Callback - Header for ppc32 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_CALLBACK_PPC32_H -#define DYNCALL_CALLBACK_PPC32_H - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_ppc32.h" - -struct DCCallback -{ - DCThunk thunk; /* offset 0, size 24 */ - DCCallbackHandler* handler; /* offset 24, size 4 */ - size_t stack_cleanup; /* offset 28, size 4 */ - void* userdata; /* offset 32, size 4 */ -}; /* total size 36 */ - -#endif /* DYNCALL_CALLBACK_PPC32_H */ - diff --git a/src/dyncall/include/dyncall_callback_ppc64.h b/src/dyncall/include/dyncall_callback_ppc64.h deleted file mode 100644 index 81fdefa2f..000000000 --- a/src/dyncall/include/dyncall_callback_ppc64.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_ppc64.h - Description: Callback - Header for ppc64 - License: - - Copyright (c) 2014-2015 Masanori Mitsugi - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_CALLBACK_PPC64_H -#define DYNCALL_CALLBACK_PPC64_H - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_ppc64.h" - -/* - ELF v2 - thunk : offset 0, size 48 - handler : offset 48, size 8 - stack_cleanup : offset 56, size 8 - userdata : offset 64, size 8 - - ELF v1 - thunk : offset 0, size 64 - handler : offset 64, size 8 - stack_cleanup : offset 72, size 8 - userdata : offset 80, size 8 -*/ - -struct DCCallback -{ - DCThunk thunk; - DCCallbackHandler* handler; - size_t stack_cleanup; - void* userdata; -}; - -#endif /* DYNCALL_CALLBACK_PPC64_H */ - diff --git a/src/dyncall/include/dyncall_callback_sparc32.h b/src/dyncall/include/dyncall_callback_sparc32.h deleted file mode 100644 index a9cf762ef..000000000 --- a/src/dyncall/include/dyncall_callback_sparc32.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_sparc32.h - Description: Callback - Header for sparc32 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_CALLBACK_SPARC32_H -#define DYNCALL_CALLBACK_SPARC32_H - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_sparc32.h" - -struct DCCallback -{ - DCThunk thunk; /* offset 0, size ?? */ - DCCallbackHandler* handler; /* offset ??, size 4 */ - size_t stack_cleanup; /* offset ??, size 4 */ - void* userdata; /* offset ??, size 4 */ -}; - -#endif /* DYNCALL_CALLBACK_SPARC32_H */ - diff --git a/src/dyncall/include/dyncall_callback_x64.h b/src/dyncall/include/dyncall_callback_x64.h deleted file mode 100644 index 6517ad21e..000000000 --- a/src/dyncall/include/dyncall_callback_x64.h +++ /dev/null @@ -1,45 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_x64.h - Description: Callback - Header for x64 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNCALL_CALLBACK_X64_H_ -#define DYNCALL_CALLBACK_X64_H_ - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_x64.h" - - -struct DCCallback -{ - DCThunk thunk; // offset 0, size 24 - DCCallbackHandler* handler; // offset 24 - void* userdata; // offset 32 -}; - -#endif /* DYNCALL_CALLBACK_X64_H_ */ - diff --git a/src/dyncall/include/dyncall_callback_x86.h b/src/dyncall/include/dyncall_callback_x86.h deleted file mode 100644 index d2e6f7288..000000000 --- a/src/dyncall/include/dyncall_callback_x86.h +++ /dev/null @@ -1,50 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_callback_x86.h - Description: Callback - Header for x86 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNCALL_CALLBACK_X86_H_ -#define DYNCALL_CALLBACK_X86_H_ - -#include "dyncall_callback.h" - -#include "dyncall_thunk.h" -#include "dyncall_args_x86.h" - -struct DCCallback -{ - DCThunk thunk; /* offset 0, size 16 */ - DCCallbackHandler* handler; /* offset 16 */ - DCArgsVT* args_vt; /* offset 20 */ - size_t stack_cleanup; /* offset 24 */ - void* userdata; /* offset 28 */ -}; - -int dcCleanupSize_x86_cdecl (const char* args_signature); -int dcCleanupSize_x86_std (const char* args_signature); -int dcCleanupSize_x86_fast_ms (const char* args_signature); -int dcCleanupSize_x86_fast_gnu(const char* args_signature); - -#endif /* DYNCALL_CALLBACK_X86_H_ */ diff --git a/src/dyncall/include/dyncall_callf.h b/src/dyncall/include/dyncall_callf.h deleted file mode 100644 index 0a8108834..000000000 --- a/src/dyncall/include/dyncall_callf.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_callf.h - Description: formatted call interface to dyncall - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -/* - - dyncall formatted calls C API - - REVISION - 2007/12/11 initial - -*/ - - -#ifndef DYNCALL_CALLF_H -#define DYNCALL_CALLF_H - -/* dyncall formatted calls */ - -#include "dyncall.h" -#include "dyncall_signature.h" -#include "dyncall_value.h" - -#include - -void dcArgF (DCCallVM* vm, const DCsigchar* signature, ...); -void dcVArgF(DCCallVM* vm, const DCsigchar* signature, va_list args); - -void dcCallF (DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, ...); -void dcVCallF(DCCallVM* vm, DCValue* result, DCpointer funcptr, const DCsigchar* signature, va_list args); - -#endif /* DYNCALL_CALLF_H */ - diff --git a/src/dyncall/include/dyncall_config.h b/src/dyncall/include/dyncall_config.h deleted file mode 100644 index 4f3588878..000000000 --- a/src/dyncall/include/dyncall_config.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_config.h - Description: Macro configuration file for non-standard C types - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -/* - - dyncall type configuration - - REVISION - 2007/12/11 initial - -*/ - -#ifndef DYNCALL_CONFIG_H -#define DYNCALL_CONFIG_H - -#include "dyncall_macros.h" - -#define DC_BOOL int -#define DC_LONG_LONG long long -#define DC_POINTER void* - -#endif /* DYNCALL_CONFIG_H */ - diff --git a/src/dyncall/include/dyncall_macros.h b/src/dyncall/include/dyncall_macros.h deleted file mode 100644 index 7731f50a8..000000000 --- a/src/dyncall/include/dyncall_macros.h +++ /dev/null @@ -1,289 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_macros.h - Description: Platform detection macros - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -/* - - dyncall macros - - Platform detection, specific defines and configuration. - The purpose of this file is to provide coherent platform and compiler - specific defines. So instead of defines like WIN32, _OpenBSD_ or - __GNUC__, one should use DC__OS_Win32, DC__OS_OpenBSD or DC__C_GNU, - respectively. - - REVISION - 2007/12/11 initial - -*/ - - -#ifndef DYNCALL_MACROS_H -#define DYNCALL_MACROS_H - - -/* Platform specific defines. */ - -/* MS Windows XP x64/Vista64 or later. */ -#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__) -#define DC__OS_Win64 - -/* MS Windows NT/95/98/ME/2000/XP/Vista32. */ -#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(__WINDOWS__) || defined(_WINDOWS) -#define DC__OS_Win32 - -/* All the OS' based on Darwin OS (MacOS X, OpenDarwin). Note that '__APPLE__' may be defined for classic MacOS, too. */ -/* __MACOSX__ is not defined in gcc assembler mode (switch: -S) */ -/* @@@ TODO: Check for Classic OS */ - -#elif defined(__APPLE__) || defined(__Darwin__) -# define DC__OS_Darwin -# if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) -# define DC__OS_IPhone -# else /* defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) */ -# define DC__OS_MacOSX -# endif - -/* The most popular open source Unix-like OS - Linux. */ -#elif defined(__linux__) || defined(__linux) || defined(__gnu_linux__) -#define DC__OS_Linux - -/* The most powerful open source Unix-like OS - FreeBSD. */ -#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -#define DC__OS_FreeBSD - -/* The most secure open source Unix-like OS - OpenBSD. */ -#elif defined(__OpenBSD__) -#define DC__OS_OpenBSD - -/* The most portable open source Unix-like OS - NetBSD. */ -#elif defined(__NetBSD__) -#define DC__OS_NetBSD - -/* The FreeBSD fork having heavy clusterization in mind - DragonFlyBSD. */ -#elif defined(__DragonFly__) -#define DC__OS_DragonFlyBSD - -/* Sun's Unix-like OS - SunOS / Solaris. */ -#elif defined(__sun__) || defined(__sun) || defined(sun) -#define DC__OS_SunOS - -/* The "Linux-like environment for Windows" - Cygwin. */ -#elif defined(__CYGWIN__) -#define DC__OS_Cygwin - -/* The "Minimalist GNU for Windows" - MinGW. */ -#elif defined(__MINGW__)/*@@@*/ -#define DC__OS_MinGW - -/* The Nintendo DS (homebrew) using devkitpro. */ -#elif defined(__nds__) -#define DC__OS_NDS - -/* The PlayStation Portable (homebrew) SDK. */ -#elif defined(__psp__) || defined(PSP) -#define DC__OS_PSP - -/* Haiku (BeOS alike). */ -#elif defined(__HAIKU__) -#define DC__OS_BeOS - -/* The Unix successor - Plan9 from Bell Labs */ -#elif defined(Plan9) || defined(__Plan9__) -#define DC__OS_Plan9 - -/* Digital's Unix-like OS - VMS */ -#elif defined(__vms) -#define DC__OS_VMS - -#elif defined(__minix) -#define DC__OS_Minix - -#else - #error Unsupported OS. -#endif - - - -/* Compiler specific defines. Do not change the order, because */ -/* some of the compilers define flags for compatible ones, too. */ - -/* Intel's C/C++ compiler. */ -#if defined(__INTEL_COMPILER) -#define DC__C_Intel - -/* MS C/C++ compiler. */ -#elif defined(_MSC_VER) -#define DC__C_MSVC - -/* LLVM clang. */ -#elif defined(__clang__) -#define DC__C_CLANG - -/* The GNU Compiler Collection - GCC. */ -#elif defined(__GNUC__) -#define DC__C_GNU - -/* Watcom compiler. */ -#elif defined(__WATCOMC__) -#define DC__C_WATCOM - -/* Portable C Compiler. */ -#elif defined(__PCC__) -#define DC__C_PCC - -/* Sun Pro C. */ -#elif defined(__SUNPRO_C) -#define DC__C_SUNPRO - -/* Undetected C Compiler. */ -#else -#define DC__C_UNKNOWN -#endif - - - -/* Architecture. */ - -/* Check architecture. */ -#if defined(_M_X64_) || defined(_M_AMD64) || defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) -# define DC__Arch_AMD64 -#elif defined(_M_IX86) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__) || defined(__386__) || defined(__i386) -# define DC__Arch_Intel_x86 -#elif defined(_M_IA64) || defined(__ia64__) -# define DC__Arch_Itanium -#elif defined(_M_PPC) || defined(__powerpc__) || defined(__powerpc) || defined(__POWERPC__) || defined(__ppc__) || defined(__power__) -# if defined(__ppc64__) || defined(_ARCH_PPC64) || defined(__power64__) || defined(__powerpc64__) -# define DC__Arch_PPC64 -# else -# define DC__Arch_PPC32 -# endif -#elif defined(__mips64__) || defined(__mips64) -# define DC__Arch_MIPS64 -#elif defined(_M_MRX000) || defined(__mips__) || defined(__mips) || defined(_mips) -# define DC__Arch_MIPS -#elif defined(__arm__) -# define DC__Arch_ARM -#elif defined(__aarch64__) -# define DC__Arch_ARM64 -#elif defined(__sh__) -# define DC__Arch_SuperH -#elif defined(__sparcv9) || defined(__sparc64__) || ( defined(__sparc) && defined(__arch64__) ) -/* this could be needed on Linux/GNU sparc64 in the future: || ( defined(__sparc) && defined(__arch64__) ) */ -# define DC__Arch_Sparcv9 -#elif defined(__sparc) -# define DC__Arch_Sparc -#endif - - - -/* Rough OS classification. */ - -#if defined(DC__OS_Win32) || defined(DC__OS_Win64) -# define DC_WINDOWS -#elif defined(DC__OS_Plan9) -# define DC_PLAN9 -#elif defined(DC__OS_NDS) || defined(DC__OS_PSP) -# define DC_OTHER -#else -# define DC_UNIX -#endif - - - -/* Misc machine-dependent modes, ABIs, etc.. */ - -#if defined(__arm__) && !defined(__thumb__) -# define DC__Arch_ARM_ARM -#elif defined(__arm__) && defined(__thumb__) -# define DC__Arch_ARM_THUMB -#endif - -#if defined(DC__Arch_ARM_ARM) || defined(DC__Arch_ARM_THUMB) -# if defined(__ARM_EABI__) || defined(DC__OS_NDS) -# if defined (__ARM_PCS_VFP) && (__ARM_PCS_VFP == 1) -# define DC__ABI_ARM_HF -# else -# define DC__ABI_ARM_EABI -# endif -# elif defined(__APCS_32__) -# define DC__ABI_ARM_OABI -# endif -#endif /* ARM */ - -#if defined(DC__Arch_MIPS) || defined(DC__Arch_MIPS64) -# if defined(_ABIO32) || defined(_MIPS_ARCH_MIPS1) || defined(_MIPS_ARCH_MIPS2) -# define DC__ABI_MIPS_O32 -# elif defined(_ABIN32) -# define DC__ABI_MIPS_N32 -# elif defined(_ABI64) -# define DC__ABI_MIPS_N64 -# else -# define DC__ABI_MIPS_EABI -# endif -#endif /* MIPS */ - -#if defined(DC__Arch_PPC64) -# if defined(_CALL_ELF) -# define DC__ABI_PPC64_ELF_V _CALL_ELF -# else -# define DC__ABI_PPC64_ELF_V 0 /* 0 means not explicitly set, otherwise this is 1 (big endian) and 2 (little endian) */ -# endif -#endif /* MIPS */ - - -/* Endian detection. */ -#if defined(DC__Arch_Intel_x86) || defined(DC__Arch_AMD64) /* always little */ -# define DC__Endian_LITTLE -#elif defined(DC__Arch_Sparc) /*always big until v9*/ -# define DC__Endian_BIG -#else /* all others are bi-endian */ -/* @@@check flags used on following bi-endianness archs: -DC__Arch_ARM -DC__Arch_ARM64 -DC__Arch_Itanium -DC__Arch_MIPS -DC__Arch_MIPS64 -DC__Arch_PPC32 -DC__Arch_PPC64 -DC__Arch_Sparcv9 -DC__Arch_SuperH -*/ -# if (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 1)) || defined(_BIG_ENDIAN) || defined(MIPSEB) -# define DC__Endian_BIG -# elif (defined(DC__Arch_PPC64) && (DC__ABI_PPC64_ELF_V == 2)) || defined(_LITTLE_ENDIAN) || defined(MIPSEL) -# define DC__Endian_LITTLE -# endif /* no else, leave unset if not sure */ -#endif - - -/* Internal macro/tag. */ -#if !defined(DC_API) -#define DC_API -#endif - -#endif /* DYNCALL_MACROS_H */ - diff --git a/src/dyncall/include/dyncall_signature.h b/src/dyncall/include/dyncall_signature.h deleted file mode 100644 index 385dec67a..000000000 --- a/src/dyncall/include/dyncall_signature.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_signature.h - Description: Type and calling-convention signature character defines - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -/* - - dyncall signature characters - - REVISION - 2007/12/11 initial - -*/ - - -#ifndef DYNCALL_SIGNATURE_H -#define DYNCALL_SIGNATURE_H - -typedef char DCsigchar; - -#define DC_SIGCHAR_VOID 'v' -#define DC_SIGCHAR_BOOL 'B' -#define DC_SIGCHAR_CHAR 'c' -#define DC_SIGCHAR_UCHAR 'C' -#define DC_SIGCHAR_SHORT 's' -#define DC_SIGCHAR_USHORT 'S' -#define DC_SIGCHAR_INT 'i' -#define DC_SIGCHAR_UINT 'I' -#define DC_SIGCHAR_LONG 'j' -#define DC_SIGCHAR_ULONG 'J' -#define DC_SIGCHAR_LONGLONG 'l' -#define DC_SIGCHAR_ULONGLONG 'L' -#define DC_SIGCHAR_FLOAT 'f' -#define DC_SIGCHAR_DOUBLE 'd' -#define DC_SIGCHAR_POINTER 'p' -#define DC_SIGCHAR_STRING 'Z' -#define DC_SIGCHAR_STRUCT 'T' -#define DC_SIGCHAR_ENDARG ')' /* also works for end struct */ - -/* callback signatures */ - -#define DC_SIGCHAR_CC_PREFIX '_' -#define DC_SIGCHAR_CC_ELLIPSIS 'e' -#define DC_SIGCHAR_CC_STDCALL 's' -#define DC_SIGCHAR_CC_FASTCALL_GNU 'f' -#define DC_SIGCHAR_CC_FASTCALL_MS 'F' -#define DC_SIGCHAR_CC_THISCALL_MS '+' - -#endif /* DYNCALL_SIGNATURE_H */ - diff --git a/src/dyncall/include/dyncall_thunk.h b/src/dyncall/include/dyncall_thunk.h deleted file mode 100644 index 87b05d1d2..000000000 --- a/src/dyncall/include/dyncall_thunk.h +++ /dev/null @@ -1,90 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk.h - Description: Thunk - Interface - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_H -#define DYNCALL_THUNK_H - -/** - ** dyncall thunks - ** - ** thunks are small-size hybrid code/data objects, created at run-time to - ** be used as function pointers with associated data and entry functions. - ** - ** The header contains code, that does load its address into a designated scratch - ** register and will jump to a thunk function. - ** - ** Thunk entry procedures are compiled functions, that are called as a result of - ** a thunk function. - ** There is one thunk entry currently for supporting callbacks. - ** - ** Thunk context register ( ::= an available scratch register in the calling convention): - ** - ** x86: eax - ** x64: rax - ** ppc: r2 - ** arm: r12 - ** arm64: x9 - ** - **/ - -#include "dyncall_macros.h" - -typedef struct DCThunk_ DCThunk; - -#ifdef __cplusplus -extern "C" { -#endif - -void dcbInitThunk(DCThunk* p, void (*entry)()); - -#if defined(DC__Arch_Intel_x86) -#include "dyncall_thunk_x86.h" -#elif defined (DC__Arch_AMD64) -#include "dyncall_thunk_x64.h" -#elif defined (DC__Arch_PPC32) -#include "dyncall_thunk_ppc32.h" -#elif defined (DC__Arch_PPC64) -#include "dyncall_thunk_ppc64.h" -#elif defined (DC__Arch_ARM_ARM) -#include "dyncall_thunk_arm32_arm.h" -#elif defined (DC__Arch_ARM_THUMB) -#include "dyncall_thunk_arm32_thumb.h" -#elif defined (DC__Arch_MIPS) -#include "dyncall_thunk_mips.h" -#elif defined (DC__Arch_Sparc) -#include "dyncall_thunk_sparc32.h" -#elif defined (DC__Arch_Sparcv9) -#include "dyncall_thunk_sparc64.h" -#elif defined (DC__Arch_ARM64) -#include "dyncall_thunk_arm64.h" -#endif - -#ifdef __cplusplus -} -#endif - - -#endif /* DYNCALL_THUNK_H */ diff --git a/src/dyncall/include/dyncall_thunk_arm32_arm.h b/src/dyncall/include/dyncall_thunk_arm32_arm.h deleted file mode 100644 index 12ffb3305..000000000 --- a/src/dyncall/include/dyncall_thunk_arm32_arm.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_arm32_arm.h - Description: Thunk - Header for ARM32 (ARM mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_ARM32_ARM_H -#define DYNCALL_THUNK_ARM32_ARM_H - - -struct DCThunk_ -{ - unsigned int code[2]; - void (*entry)(); -}; - -#define DCTHUNK_ARM32_ARM_SIZE 12 - - -#endif /* DYNCALL_THUNK_ARM32_ARM_H */ - diff --git a/src/dyncall/include/dyncall_thunk_arm32_thumb.h b/src/dyncall/include/dyncall_thunk_arm32_thumb.h deleted file mode 100644 index 832484c11..000000000 --- a/src/dyncall/include/dyncall_thunk_arm32_thumb.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_arm32_thumb.h - Description: Thunk - Header for ARM32 (THUMB mode) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_ARM32_THUMB_H -#define DYNCALL_THUNK_ARM32_THUMB_H - -#include "dyncall_thunk_arm32_arm.h" /* Uses same code as ARM mode. */ - -#define DCTHUNK_ARM32_THUMB_SIZE 12 - - -#endif /* DYNCALL_THUNK_ARM32_THUMB_H */ - diff --git a/src/dyncall/include/dyncall_thunk_arm64.h b/src/dyncall/include/dyncall_thunk_arm64.h deleted file mode 100644 index baa5127cf..000000000 --- a/src/dyncall/include/dyncall_thunk_arm64.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_arm64.h - Description: Thunk - Header for ARM64 / ARMv8 / AAPCS64 - License: - - Copyright (c) 2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_THUNK_ARM64_H -#define DYNCALL_THUNK_ARM64_H - -struct DCThunk_ -{ - // off size - //-----|---------- - unsigned int code[4]; // 0 16 - void (*entry)(); // 16 8 - void* reserved; // 24 8 - - // 32 total size - -}; - -#endif /* DYNCALL_THUNK_ARM64_H */ - diff --git a/src/dyncall/include/dyncall_thunk_mips.h b/src/dyncall/include/dyncall_thunk_mips.h deleted file mode 100644 index b6acffd53..000000000 --- a/src/dyncall/include/dyncall_thunk_mips.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_mips.h - Description: Thunk - Header for MIPS - License: - - Copyright (c) 2013-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_MIPS_H -#define DYNCALL_THUNK_MIPS_H - -struct DCThunk_ -{ - unsigned short data[6]; - unsigned int jump; - unsigned short bddt[2]; -}; - -#endif /* DYNCALL_THUNK_MIPS_H */ - diff --git a/src/dyncall/include/dyncall_thunk_ppc32.h b/src/dyncall/include/dyncall_thunk_ppc32.h deleted file mode 100644 index 42bce8091..000000000 --- a/src/dyncall/include/dyncall_thunk_ppc32.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_ppc32.h - Description: Thunk - Header for ppc32 (darwin/sysv) - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_THUNK_PPC32_H -#define DYNCALL_THUNK_PPC32_H - -struct DCThunk_ -{ - unsigned short code_load_hi, addr_self_hi; /* offset: 0 size: 4 */ - unsigned short code_load_lo, addr_self_lo; /* offset: 4 size: 4 */ - unsigned int code_jump[3]; /* offset: 8 size: 12 */ - void (*addr_entry)(); /* offset: 20 size: 4 */ -}; /* total size: 24 */ - -#define DCTHUNK_SIZE_PPC32 24 - -#endif /* DYNCALL_THUNK_PPC32_H */ - diff --git a/src/dyncall/include/dyncall_thunk_ppc64.h b/src/dyncall/include/dyncall_thunk_ppc64.h deleted file mode 100644 index 2a7e88ea4..000000000 --- a/src/dyncall/include/dyncall_thunk_ppc64.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_ppc64.h - Description: Thunk - Header for ppc64 - License: - - Copyright (c) 2014-2015 Masanori Mitsugi - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - -#ifndef DYNCALL_THUNK_PPC64_H -#define DYNCALL_THUNK_PPC64_H - -#if DC__ABI_PPC64_ELF_V != 2 -struct DCThunk_ /* v1 */ -{ - void (*thunk_entry)(); /* offset: 0 */ - long toc_thunk; /* offset: 8 */ - unsigned short code_load_hi, addr_self_hi; /* offset: 16 */ - unsigned short code_load_lo, addr_self_lo; /* offset: 20 */ - unsigned int code_jump[6]; /* offset: 24 */ - void (*addr_entry)(); /* offset: 48 */ - long toc_entry; /* offset: 56 */ -}; -#define DCTHUNK_SIZE_PPC64 64 -#else -struct DCThunk_ /* v2 */ -{ - unsigned short addr_self_hist, code_load_hist; /* offset: 0 */ - unsigned short addr_self_hier, code_load_hier; /* offset: 4 */ - unsigned int code_rot; /* offset: 8 */ - unsigned short addr_self_hi, code_load_hi; /* offset: 12 */ - unsigned short addr_self_lo, code_load_lo; /* offset: 16 */ - unsigned int code_jump[5]; /* offset: 20 */ - void (*addr_entry)(); /* offset: 40 */ -}; -#define DCTHUNK_SIZE_PPC64 48 -#endif - -#endif /* DYNCALL_THUNK_PPC64_H */ - diff --git a/src/dyncall/include/dyncall_thunk_sparc32.h b/src/dyncall/include/dyncall_thunk_sparc32.h deleted file mode 100644 index 456e13e3d..000000000 --- a/src/dyncall/include/dyncall_thunk_sparc32.h +++ /dev/null @@ -1,37 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_sparc32.h - Description: Thunk - Header for sparc32 - not yet implemented - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_SPARC32_H -#define DYNCALL_THUNK_SPARC32_H - -struct DCThunk_ -{ - int x[4]; /* dummy */ -}; - -#define DCTHUNK_SIZE_SPARC32 32 - -#endif /* DYNCALL_THUNK_SPARC32_H */ diff --git a/src/dyncall/include/dyncall_thunk_sparc64.h b/src/dyncall/include/dyncall_thunk_sparc64.h deleted file mode 100644 index c8eb90d13..000000000 --- a/src/dyncall/include/dyncall_thunk_sparc64.h +++ /dev/null @@ -1,37 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_sparc64.h - Description: Thunk - Header for sparc64 - not yet implemented - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_SPARC64_H -#define DYNCALL_THUNK_SPARC64_H - -struct DCThunk_ -{ - int x[4]; /* dummy */ -}; - -#define DCTHUNK_SIZE_SPARC64 32 - -#endif /* DYNCALL_THUNK_SPARC32_H */ diff --git a/src/dyncall/include/dyncall_thunk_x64.h b/src/dyncall/include/dyncall_thunk_x64.h deleted file mode 100644 index 5e60d4f87..000000000 --- a/src/dyncall/include/dyncall_thunk_x64.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_x64.h - Description: Thunk - Header for x64 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_X64_H -#define DYNCALL_THUNK_X64_H - -struct DCThunk_ -{ - unsigned long long code[2]; - void (*entry)(); -}; - -#define DCTHUNK_X64_SIZE 24 - - -#endif /* DYNCALL_THUNK_X64_H */ - diff --git a/src/dyncall/include/dyncall_thunk_x86.h b/src/dyncall/include/dyncall_thunk_x86.h deleted file mode 100644 index 29b7ca81d..000000000 --- a/src/dyncall/include/dyncall_thunk_x86.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - - Package: dyncall - Library: dyncallback - File: dyncallback/dyncall_thunk_x86.h - Description: Thunk - Header for x86 - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -#ifndef DYNCALL_THUNK_X86_H -#define DYNCALL_THUNK_X86_H - -struct DCThunk_ -{ - unsigned int code_load; - void* addr_self; - unsigned int code_jump; - void (*addr_entry)(); -}; - -#define DCTHUNK_X86_SIZE 16 - -#endif /* DYNCALL_THUNK_X86_H */ diff --git a/src/dyncall/include/dyncall_types.h b/src/dyncall/include/dyncall_types.h deleted file mode 100644 index 1831eb744..000000000 --- a/src/dyncall/include/dyncall_types.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_types.h - Description: Typedefs - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -/* - - dyncall argument- and return-types - - REVISION - 2007/12/11 initial - -*/ - -#ifndef DYNCALL_TYPES_H -#define DYNCALL_TYPES_H - -#include - -#include "dyncall_config.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void DCvoid; -typedef DC_BOOL DCbool; -typedef char DCchar; -typedef unsigned char DCuchar; -typedef short DCshort; -typedef unsigned short DCushort; -typedef int DCint; -typedef unsigned int DCuint; -typedef long DClong; -typedef unsigned long DCulong; -typedef DC_LONG_LONG DClonglong; -typedef unsigned DC_LONG_LONG DCulonglong; -typedef float DCfloat; -typedef double DCdouble; -typedef DC_POINTER DCpointer; -typedef const char* DCstring; - -typedef size_t DCsize; - -#define DC_TRUE 1 -#define DC_FALSE 0 - -#ifdef __cplusplus -} -#endif - -#endif /* DYNCALL_TYPES_H */ - diff --git a/src/dyncall/include/dyncall_value.h b/src/dyncall/include/dyncall_value.h deleted file mode 100644 index 69068f0a2..000000000 --- a/src/dyncall/include/dyncall_value.h +++ /dev/null @@ -1,91 +0,0 @@ -/* - - Package: dyncall - Library: dyncall - File: dyncall/dyncall_value.h - Description: Value variant type - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - -/* - - dyncall value variant - - a value variant union-type that carries all supported dyncall types. - - REVISION - 2007/12/11 initial - -*/ - -#ifndef DYNCALL_VALUE_H -#define DYNCALL_VALUE_H - -#include "dyncall_types.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef union DCValue_ DCValue; - -union DCValue_ -{ -#if defined (DC__Arch_PPC32) && defined(DC__Endian_BIG) - DCbool B; - struct { DCchar c_pad[3]; DCchar c; }; - struct { DCuchar C_pad[3]; DCuchar C; }; - struct { DCshort s_pad; DCshort s; }; - struct { DCshort S_pad; DCshort S; }; - DCint i; - DCuint I; -#elif defined (DC__Arch_PPC64) && defined(DC__Endian_BIG) - struct { DCbool B_pad; DCbool B; }; - struct { DCchar c_pad[7]; DCchar c; }; - struct { DCuchar C_pad[7]; DCuchar C; }; - struct { DCshort s_pad[3]; DCshort s; }; - struct { DCshort S_pad[3]; DCshort S; }; - struct { DCint i_pad; DCint i; }; - struct { DCint I_pad; DCuint I; }; -#else - DCbool B; - DCchar c; - DCuchar C; - DCshort s; - DCushort S; - DCint i; - DCuint I; -#endif - DClong j; - DCulong J; - DClonglong l; - DCulonglong L; - DCfloat f; - DCdouble d; - DCpointer p; - DCstring Z; -}; - -#ifdef __cplusplus -} -#endif - -#endif /* DYNCALL_VALUE_H */ - diff --git a/src/dyncall/include/dynload.h b/src/dyncall/include/dynload.h deleted file mode 100644 index df9fe4141..000000000 --- a/src/dyncall/include/dynload.h +++ /dev/null @@ -1,66 +0,0 @@ -/* - - Package: dyncall - Library: dynload - File: dynload/dynload.h - Description: public header for library dynload - License: - - Copyright (c) 2007-2015 Daniel Adler , - Tassilo Philipp - - Permission to use, copy, modify, and distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -*/ - - - -#ifndef DYNLOAD_H -#define DYNLOAD_H - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef DL_API -#define DL_API -#endif - -/* --- public api ---------------------------------------------------------- */ - -/* shared library loading and explicit symbol resolving */ - -typedef struct DLLib_ DLLib; - -DL_API DLLib* dlLoadLibrary(const char* libpath); -DL_API void dlFreeLibrary(DLLib* pLib); -DL_API void* dlFindSymbol(DLLib* pLib, const char* pSymbolName); - -/* symbol table enumeration - only for symbol lookup, not resolve */ - -typedef struct DLSyms_ DLSyms; - -DL_API DLSyms* dlSymsInit (const char* libPath); -DL_API void dlSymsCleanup(DLSyms* pSyms); - -DL_API int dlSymsCount (DLSyms* pSyms); -DL_API const char* dlSymsName (DLSyms* pSyms, int index); -DL_API const char* dlSymsNameFromValue(DLSyms* pSyms, void* value); /* symbol must be loaded */ - - -#ifdef __cplusplus -} -#endif - -#endif /* DYNLOAD_H */ - diff --git a/src/dyncall/lib/libdyncall_s.lib b/src/dyncall/lib/libdyncall_s.lib deleted file mode 100644 index e36ce7c239dc881f557b3e5a6c1bc16c0fc613a2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 25454 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 EKOj4tO8@`> diff --git a/src/dyncall/lib/libdynload_s.lib b/src/dyncall/lib/libdynload_s.lib deleted file mode 100644 index 80fc28d066f12642b9e7cdd476fed3543bc1df80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3342 zcmcInO>7%Q6rS}uX<`C#p`aidv`LLfk?PpZZ_^0HaT3PCP9l;DBLQcTeP)ibpD9v^!ei<^qI}dO~~+yO;Vrbn{|5 zlgrtKxMQVrr97!fZYfu+@QIu)*|Buis-Vb@6x{4|+9^p)@*{T6ggNJ32b4z&mX);U z3+ci#NJ%$sO6lM4uB&TncRtu&15|m~Bm5B`|7oQ91Jn1mj=esBK>Ieg{iD}4{mr0;qI#>EwegnO7lxU-oNOyO)VMKd7DjxyNcA@m zzSdI7Hp7lR-+E6l42h?vw&{*1hsI*5;mKA57yTQQccGjj+J3Ye@0%GKkDo{luS92J zL#f1A0+{4@JeHgUX3EOuXTW=zwBsC^FWHVcV`e0PExJ{ai zrAIFUlw`MQ`T07k-%6ApW1|MuuhTLOveAQrYht4z!5M6@DN&BMCD;aC{lYl4@zoBZ z=dTr;xlPKxqpV&SW7kECgZ@xPu~?fTQx*%-%uVKho9eMTrHk8wegpc48n5^#fNvUP z{@1;lv^*24qvc{KNXzF!P07s3w&9MOl>JWGH^b~|>inIRrzl%)qU>Z{k|m5-;}wlH zyovie{&le>vAG`GyqZ}3+?P7Oaqh>Cb;@u)hVwC)Z-cTy;G~$ye98P5sSYrxZR~^7 zY=q(`2cUj{b8kTXFz3opBaWXAAusY;RQRP!dQCFWqQ`ZvFSt68@8=i z_d^_Og1VV=2e&u_IFxjv)%r;7QC~z0_(D0(T2EL!LZMuse zlFdyV;f)Azafz;BOi;-i4KViV+GSM%ByS|Z3#)4w3-COiJmP*^RTn3OmJNv7-nf80 zx`yY4(V*+vp%1E~@Z^!W4)I2b8bEc;fEwx3Tkq!uhjmMZF2EHfIIUPSLK9HXPhvfYU`RzD3R|Zk@gXWm+Im$2(pDD&VrFRzzoa!N zRa@_X^s$0q{|yEC2&7*XWE~{@R;nw!15yx*SRw2*+6|Hzh1UN9Nu)!b^+P;lhrCEB z_X=cHFQg`QHJK_C$R|cfnM0!6UkdzD;(3O6-X8Lufhy`dM6tK6OR=i<$*hYBm*?)S zj4hv2kZh1-j_t)n%L#L=PMRUd-ql1*fFo3H6v}v?-a^JpyX4q4=>N&91N?3|wg>Ps z*jtB!gdWBm3rqU{bK)g1Hof;bk-v8SOFG2dw2y8+fd^7)l>D_FtH^j`G1~ZfY)8pY z4nch%=P(ptO!n_t++2g%RN5Ig(ZA@^3!nXRwyKK=QZ+6-C;(oISax^^(hrCMr8+9H zLkF`}MA2~+ofVMOdp{22ZVP<@AQ4Vx&qnV1Pr P(S-%n@cfe?RJ_RF>&w_% diff --git a/src/exact_value.cpp b/src/exact_value.cpp index c1666cafd..ed181b9d0 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -46,7 +46,31 @@ struct ExactValue { gb_global ExactValue const empty_exact_value = {}; HashKey hash_exact_value(ExactValue v) { + switch (v.kind) { + case ExactValue_Invalid: + return HashKey{}; + case ExactValue_Bool: + return hash_integer(u64(v.value_bool)); + case ExactValue_String: + return hash_string(v.value_string); + case ExactValue_Integer: + return hash_integer(u64(v.value_integer)); + case ExactValue_Float: + return hash_f64(v.value_float); + case ExactValue_Pointer: + return hash_integer(v.value_pointer); + case ExactValue_Complex: + return hashing_proc(&v.value_complex, gb_size_of(Complex128)); + + case ExactValue_Compound: + return hash_pointer(v.value_compound); + case ExactValue_Procedure: + return hash_pointer(v.value_procedure); + case ExactValue_Type: + return hash_pointer(v.value_type); + } return hashing_proc(&v, gb_size_of(ExactValue)); + } diff --git a/src/ir.cpp b/src/ir.cpp index a28d28739..2fb398273 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -6925,7 +6925,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { Type *enum_ptr = make_type_pointer(a, t); t = base_type(t); Type *core_elem = core_type(t); - i64 enum_count = t->Enum.field_count; + i64 enum_count = t->Enum.fields.count; irValue *max_count = ir_const_int(a, enum_count); irValue *ti = ir_type_info(proc, t); @@ -8039,12 +8039,11 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info // is_export ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 3), ir_const_bool(a, t->Enum.is_export)); - if (t->Enum.field_count > 0) { - Entity **fields = t->Enum.fields; - isize count = t->Enum.field_count; - irValue *name_array = ir_generate_array(m, t_string, count, + if (t->Enum.fields.count > 0) { + auto fields = t->Enum.fields; + irValue *name_array = ir_generate_array(m, t_string, fields.count, str_lit("__$enum_names"), cast(i64)entry_index); - irValue *value_array = ir_generate_array(m, t_type_info_enum_value, count, + irValue *value_array = ir_generate_array(m, t_type_info_enum_value, fields.count, str_lit("__$enum_values"), cast(i64)entry_index); bool is_value_int = is_type_integer(t->Enum.base_type); @@ -8052,7 +8051,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info GB_ASSERT(is_type_float(t->Enum.base_type)); } - for (isize i = 0; i < count; i++) { + for_array(i, fields) { irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i); irValue *value_ep = ir_emit_array_epi(proc, value_array, cast(i32)i); @@ -8063,7 +8062,7 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info ir_emit_store(proc, name_ep, ir_const_string(a, fields[i]->token.string)); } - irValue *v_count = ir_const_int(a, count); + irValue *v_count = ir_const_int(a, fields.count); irValue *names = ir_emit_struct_ep(proc, tag, 1); irValue *name_array_elem = ir_array_elem(proc, name_array); diff --git a/src/map.cpp b/src/map.cpp index 08a059d56..a08070656 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -30,8 +30,8 @@ struct HashKey { // u128 key; u64 key; union { - String string; // if String, s.len > 0 - void * ptr; + String string; // if String, s.len > 0 + void * ptr; PtrAndId ptr_and_id; }; }; @@ -65,6 +65,16 @@ gb_inline HashKey hash_ptr_and_id(void *ptr, u32 id) { h.ptr_and_id.id = id; return h; } +gb_inline HashKey hash_integer(u64 u) { + HashKey h = {HashKey_Default}; + h.key = u; + return h; +} +gb_inline HashKey hash_f64(f64 f) { + HashKey h = {HashKey_Default}; + h.key = *cast(u64 *)&f; + return h; +} bool hash_key_equal(HashKey a, HashKey b) { if (a.key == b.key) { diff --git a/src/parser.cpp b/src/parser.cpp index 8dd5d6d30..2643fb2b3 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -375,6 +375,17 @@ void error(AstNode *node, char *fmt, ...) { va_end(va); } +void error_no_newline(AstNode *node, char *fmt, ...) { + Token token = {}; + if (node != nullptr) { + token = ast_node_token(node); + } + va_list va; + va_start(va, fmt); + error_no_newline_va(token, fmt, va); + va_end(va); +} + void warning(AstNode *node, char *fmt, ...) { va_list va; va_start(va, fmt); @@ -3700,6 +3711,20 @@ AstNode *parse_stmt(AstFile *f) { syntax_error(token, "#bounds_check and #no_bounds_check cannot be applied together"); } return s; + } else if (tag == "complete") { + s = parse_stmt(f); + switch (s->kind) { + case AstNode_SwitchStmt: + s->SwitchStmt.complete = true; + break; + case AstNode_TypeSwitchStmt: + s->TypeSwitchStmt.complete = true; + break; + default: + syntax_error(token, "#complete can only be applied to a switch statement"); + break; + } + return s; } if (tag == "include") { diff --git a/src/parser.hpp b/src/parser.hpp index 8d15f3128..d641e8a97 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -286,17 +286,19 @@ AST_NODE_KIND(_ComplexStmtBegin, "", struct {}) \ Entity *implicit_entity; \ }) \ AST_NODE_KIND(SwitchStmt, "switch statement", struct { \ - Token token; \ - AstNode *label; \ - AstNode *init; \ - AstNode *tag; \ - AstNode *body; \ + Token token; \ + AstNode *label; \ + AstNode *init; \ + AstNode *tag; \ + AstNode *body; \ + bool complete; \ }) \ AST_NODE_KIND(TypeSwitchStmt, "type switch statement", struct { \ - Token token; \ - AstNode *label; \ - AstNode *tag; \ - AstNode *body; \ + Token token; \ + AstNode *label; \ + AstNode *tag; \ + AstNode *body; \ + bool complete; \ }) \ AST_NODE_KIND(DeferStmt, "defer statement", struct { Token token; AstNode *stmt; }) \ AST_NODE_KIND(BranchStmt, "branch statement", struct { Token token; AstNode *label; }) \ diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index 404b4cea6..6b7a50638 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -227,6 +227,22 @@ void error_va(Token token, char *fmt, va_list va) { gb_mutex_unlock(&global_error_collector.mutex); } +void error_no_newline_va(Token token, char *fmt, va_list va) { + gb_mutex_lock(&global_error_collector.mutex); + global_error_collector.count++; + // NOTE(bill): Duplicate error, skip it + if (token.pos.line == 0) { + gb_printf_err("Error: %s", gb_bprintf_va(fmt, va)); + } else if (global_error_collector.prev != token.pos) { + global_error_collector.prev = token.pos; + gb_printf_err("%.*s(%td:%td) %s", + LIT(token.pos.file), token.pos.line, token.pos.column, + gb_bprintf_va(fmt, va)); + } + gb_mutex_unlock(&global_error_collector.mutex); +} + + void syntax_error_va(Token token, char *fmt, va_list va) { gb_mutex_lock(&global_error_collector.mutex); global_error_collector.count++; diff --git a/src/types.cpp b/src/types.cpp index 2dcd05361..dadbe0a62 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -126,8 +126,7 @@ struct TypeStruct { }) \ TYPE_KIND(Struct, TypeStruct) \ TYPE_KIND(Enum, struct { \ - Entity **fields; \ - i32 field_count; \ + Array fields; \ AstNode *node; \ Scope * scope; \ Entity * names; \ @@ -1657,7 +1656,7 @@ Selection lookup_field_with_selection(gbAllocator a, Type *type_, String field_n } } - for (isize i = 0; i < type->Enum.field_count; i++) { + for_array(i, type->Enum.fields) { Entity *f = type->Enum.fields[i]; GB_ASSERT(f->kind == Entity_Constant); String str = f->token.string; @@ -2330,7 +2329,7 @@ gbString write_type_to_string(gbString str, Type *type) { str = write_type_to_string(str, type->Enum.base_type); } str = gb_string_appendc(str, " {"); - for (isize i = 0; i < type->Enum.field_count; i++) { + for_array(i, type->Enum.fields) { Entity *f = type->Enum.fields[i]; GB_ASSERT(f->kind == Entity_Constant); if (i > 0) {