ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-08-14 09:18:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

eval2: opkind -> exprkind, prepare for exprs being looser

Browse Source
This commit is contained in:
Ryan Fleury
2026-06-25 13:58:03 -07:00
parent 6b52d68c62
commit c2b74260ef
5 changed files with 183 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/eval2/eval2.c
+92 -92
View File
@@ -1589,9 +1589,9 @@ e2_token_from_string_off(String8 string, U64 start_off)
token.range.max = off; token.range.max = off;
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
U64 biggest_match_size = 0; U64 biggest_match_size = 0;
for EachNonZeroEnumVal(E2_OpKind, k) for EachNonZeroEnumVal(E2_ExprKind, k)
{ {
String8 op_symbol = (e2_op_kind_info_table[k].pre.size != 0) ? e2_op_kind_info_table[k].pre : e2_op_kind_info_table[k].sep; String8 op_symbol = (e2_expr_kind_info_table[k].pre.size != 0) ? e2_expr_kind_info_table[k].pre : e2_expr_kind_info_table[k].sep;
if(biggest_match_size < op_symbol.size && str8_match(op_symbol, str8_prefix(token_string, op_symbol.size), 0)) if(biggest_match_size < op_symbol.size && str8_match(op_symbol, str8_prefix(token_string, op_symbol.size), 0))
{ {
biggest_match_size = op_symbol.size; biggest_match_size = op_symbol.size;
@@ -1735,25 +1735,25 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
else if(need_new_expr && e2_try_token(string, E2_TokenKind_Symbol, s(""), &off, &token)) else if(need_new_expr && e2_try_token(string, E2_TokenKind_Symbol, s(""), &off, &token))
{ {
// rjf: string -> operator kind // rjf: string -> operator kind
E2_OpKind op_kind = E2_OpKind_Null; E2_ExprKind expr_kind = E2_ExprKind_Null;
String8 closer = {0}; String8 closer = {0};
{ {
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachNonZeroEnumVal(E2_OpKind, k) for EachNonZeroEnumVal(E2_ExprKind, k)
{ {
if(e2_op_kind_info_table[k].parse_kind == E2_OpParseKind_UnaryPrefix && if(e2_expr_kind_info_table[k].parse_kind == E2_ExprParseKind_UnaryPrefix &&
e2_op_kind_info_table[k].precedence <= max_precedence && e2_expr_kind_info_table[k].precedence <= max_precedence &&
str8_match(token_string, e2_op_kind_info_table[k].pre, 0)) str8_match(token_string, e2_expr_kind_info_table[k].pre, 0))
{ {
op_kind = k; expr_kind = k;
closer = e2_op_kind_info_table[k].post; closer = e2_expr_kind_info_table[k].post;
break; break;
} }
} }
} }
// rjf: push task for operand // rjf: push task for operand
if(op_kind != E2_OpKind_Null) if(expr_kind != E2_ExprKind_Null)
{ {
E2_ParseTask *task = state->free_task; E2_ParseTask *task = state->free_task;
if(task != 0) if(task != 0)
@@ -1767,14 +1767,14 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = 1;
task->op_kind = op_kind; task->expr_kind = expr_kind;
task->max_precedence = e2_op_kind_info_table[op_kind].precedence; task->max_precedence = e2_expr_kind_info_table[expr_kind].precedence;
task->expected_closer = closer; task->expected_closer = closer;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
} }
// rjf: report unexpected symbols // rjf: report unexpected symbols
if(op_kind == E2_OpKind_Null) if(expr_kind == E2_ExprKind_Null)
{ {
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
e2_msgf(arena, &parse.msgs, token.range, "Unexpected `%S`.", token_string); e2_msgf(arena, &parse.msgs, token.range, "Unexpected `%S`.", token_string);
@@ -1782,7 +1782,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
} }
//- rjf: identifiers with an active dot op kind -> member access //- rjf: identifiers with an active dot op kind -> member access
else if(need_new_expr && state->top_task != 0 && state->top_task->op_kind == E2_OpKind_Dot && e2_try_token(string, E2_TokenKind_Identifier, s(""), &off, &token)) else if(need_new_expr && state->top_task != 0 && state->top_task->expr_kind == E2_ExprKind_Dot && e2_try_token(string, E2_TokenKind_Identifier, s(""), &off, &token))
{ {
// rjf: if we have a caller-provided access result, use that as our new expression // rjf: if we have a caller-provided access result, use that as our new expression
if(next_access_result != &e2_expr_nil) if(next_access_result != &e2_expr_nil)
@@ -1809,11 +1809,11 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
{ {
String8 identifier = str8_substr(string, token.range); String8 identifier = str8_substr(string, token.range);
B32 identifier_mapped = 0; B32 identifier_mapped = 0;
B32 definitions_are_allowed = (state->top_task == 0 || state->top_task->op_kind != E2_OpKind_Macro); B32 definitions_are_allowed = (state->top_task == 0 || state->top_task->expr_kind != E2_ExprKind_Macro);
// rjf: if we're currently parsing a macro definition, then we first want to try // rjf: if we're currently parsing a macro definition, then we first want to try
// resolving identifiers as macro arguments // resolving identifiers as macro arguments
if(!identifier_mapped && state->top_task != 0 && state->top_task->op_kind == E2_OpKind_Macro) if(!identifier_mapped && state->top_task != 0 && state->top_task->expr_kind == E2_ExprKind_Macro)
{ {
U64 arg_num = 1; U64 arg_num = 1;
for(String8Node *n = state->top_task->macro_arg_names.first; n != 0; n = n->next, arg_num += 1) for(String8Node *n = state->top_task->macro_arg_names.first; n != 0; n = n->next, arg_num += 1)
@@ -1846,8 +1846,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = 1;
task->op_kind = E2_OpKind_Define; task->expr_kind = E2_ExprKind_Define;
task->max_precedence = e2_op_kind_info_table[E2_OpKind_Define].precedence; task->max_precedence = e2_expr_kind_info_table[E2_ExprKind_Define].precedence;
task->identifier = identifier; task->identifier = identifier;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
} }
@@ -1891,7 +1891,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = 1;
task->op_kind = E2_OpKind_Macro; task->expr_kind = E2_ExprKind_Macro;
task->max_precedence = max_S64; task->max_precedence = max_S64;
task->identifier = identifier; task->identifier = identifier;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
@@ -1924,23 +1924,23 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
if(!identifier_mapped) if(!identifier_mapped)
{ {
// rjf: string -> op kind // rjf: string -> op kind
E2_OpKind op_kind = E2_OpKind_Null; E2_ExprKind expr_kind = E2_ExprKind_Null;
{ {
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachNonZeroEnumVal(E2_OpKind, k) for EachNonZeroEnumVal(E2_ExprKind, k)
{ {
if(e2_op_kind_info_table[k].parse_kind == E2_OpParseKind_UnaryPrefix && if(e2_expr_kind_info_table[k].parse_kind == E2_ExprParseKind_UnaryPrefix &&
e2_op_kind_info_table[k].precedence <= max_precedence && e2_expr_kind_info_table[k].precedence <= max_precedence &&
str8_match(token_string, str8_skip_chop_whitespace(e2_op_kind_info_table[k].pre), 0)) str8_match(token_string, str8_skip_chop_whitespace(e2_expr_kind_info_table[k].pre), 0))
{ {
op_kind = k; expr_kind = k;
break; break;
} }
} }
} }
// rjf: push task for operand // rjf: push task for operand
if(op_kind != E2_OpKind_Null) if(expr_kind != E2_ExprKind_Null)
{ {
identifier_mapped = 1; identifier_mapped = 1;
E2_ParseTask *task = state->free_task; E2_ParseTask *task = state->free_task;
@@ -1955,8 +1955,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
MemoryZeroStruct(task); MemoryZeroStruct(task);
task->src_range = token.range; task->src_range = token.range;
task->child_count_target = 1; task->child_count_target = 1;
task->op_kind = op_kind; task->expr_kind = expr_kind;
task->max_precedence = e2_op_kind_info_table[op_kind].precedence; task->max_precedence = e2_expr_kind_info_table[expr_kind].precedence;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
} }
} }
@@ -2060,35 +2060,35 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
if(e2_try_token(string, E2_TokenKind_Symbol, s(""), &trailing_symbol_off, &token)) if(e2_try_token(string, E2_TokenKind_Symbol, s(""), &trailing_symbol_off, &token))
{ {
// rjf: token string -> operator kind // rjf: token string -> operator kind
E2_OpKind op_kind = E2_OpKind_Null; E2_ExprKind expr_kind = E2_ExprKind_Null;
U64 child_count_target = 2; U64 child_count_target = 2;
String8 splitter = {0}; String8 splitter = {0};
String8 closer = {0}; String8 closer = {0};
B32 splitter_is_required = 0; B32 splitter_is_required = 0;
{ {
String8 token_string = str8_substr(string, token.range); String8 token_string = str8_substr(string, token.range);
for EachNonZeroEnumVal(E2_OpKind, k) for EachNonZeroEnumVal(E2_ExprKind, k)
{ {
E2_OpInfo *op_info = &e2_op_kind_info_table[k]; E2_ExprKindInfo *expr_kind_info = &e2_expr_kind_info_table[k];
if(op_info->precedence <= max_precedence && str8_match(token_string, op_info->sep, 0)) if(expr_kind_info->precedence <= max_precedence && str8_match(token_string, expr_kind_info->sep, 0))
{ {
switch(op_info->parse_kind) switch(expr_kind_info->parse_kind)
{ {
default:{}break; default:{}break;
case E2_OpParseKind_Binary: {child_count_target = 2;}break; case E2_ExprParseKind_Binary: {child_count_target = 2;}break;
case E2_OpParseKind_Ternary: {child_count_target = 3; splitter_is_required = 1;}break; case E2_ExprParseKind_Ternary: {child_count_target = 3; splitter_is_required = 1;}break;
case E2_OpParseKind_Call: {child_count_target = max_U64;}break; case E2_ExprParseKind_Call: {child_count_target = max_U64;}break;
} }
splitter = op_info->chain; splitter = expr_kind_info->chain;
closer = op_info->post; closer = expr_kind_info->post;
op_kind = k; expr_kind = k;
break; break;
} }
} }
} }
// rjf: non-null operator kind -> build binary expression node, push task to fill other child // rjf: non-null operator kind -> build binary expression node, push task to fill other child
if(op_kind != E2_OpKind_Null) if(expr_kind != E2_ExprKind_Null)
{ {
E2_ParseTask *task = state->free_task; E2_ParseTask *task = state->free_task;
if(task != 0) if(task != 0)
@@ -2103,8 +2103,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
task->src_range = token.range; task->src_range = token.range;
task->child_count = 0; task->child_count = 0;
task->child_count_target = child_count_target; task->child_count_target = child_count_target;
task->op_kind = op_kind; task->expr_kind = expr_kind;
task->max_precedence = e2_op_kind_info_table[op_kind].precedence; task->max_precedence = e2_expr_kind_info_table[expr_kind].precedence;
task->expected_splitter = splitter; task->expected_splitter = splitter;
task->expected_closer = closer; task->expected_closer = closer;
task->splitter_is_required = splitter_is_required; task->splitter_is_required = splitter_is_required;
@@ -2177,8 +2177,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
task->src_range = type_expr->src_range; task->src_range = type_expr->src_range;
task->child_count = 1; task->child_count = 1;
task->child_count_target = 2; task->child_count_target = 2;
task->op_kind = E2_OpKind_CCast; task->expr_kind = E2_ExprKind_CCast;
task->max_precedence = e2_op_kind_info_table[E2_OpKind_CCast].precedence; task->max_precedence = e2_expr_kind_info_table[E2_ExprKind_CCast].precedence;
SLLStackPush(state->top_task, task); SLLStackPush(state->top_task, task);
expr = &e2_expr_nil; expr = &e2_expr_nil;
E2_ExprNode *child_n = push_array(arena, E2_ExprNode, 1); E2_ExprNode *child_n = push_array(arena, E2_ExprNode, 1);
@@ -2204,7 +2204,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
{ {
RDI_EvalOp op = RDI_EvalOp_Stop; RDI_EvalOp op = RDI_EvalOp_Stop;
E2_TypeKey dst_type_key = {E2_TypeKeyKind_Null}; E2_TypeKey dst_type_key = {E2_TypeKeyKind_Null};
switch(completed_task->op_kind) switch(completed_task->expr_kind)
{ {
//- rjf: no op -> just a sub-expression //- rjf: no op -> just a sub-expression
default: default:
@@ -2226,13 +2226,13 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
// expression submitted to us by the user (the parser reports it first) // expression submitted to us by the user (the parser reports it first)
// stored as the second child in the list. we just want to use the // stored as the second child in the list. we just want to use the
// second expression - the initial child was just the accessed evaluation. // second expression - the initial child was just the accessed evaluation.
case E2_OpKind_Dot: case E2_ExprKind_Dot:
{ {
finished_root = rhs; finished_root = rhs;
}break; }break;
//- rjf: indexes //- rjf: indexes
case E2_OpKind_Index: case E2_ExprKind_Index:
{ {
E2_TypeKey lhs_type_key = e2_type_key_undecorate(lhs->type_key); E2_TypeKey lhs_type_key = e2_type_key_undecorate(lhs->type_key);
E2_TypeKind lhs_type_kind = e2_type_kind_from_key(lhs_type_key); E2_TypeKind lhs_type_kind = e2_type_kind_from_key(lhs_type_key);
@@ -2277,7 +2277,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: calls //- rjf: calls
case E2_OpKind_Call: case E2_ExprKind_Call:
{ {
// rjf: calls of types redirect to casts // rjf: calls of types redirect to casts
if(lhs->mode == E2_Mode_Type) if(lhs->mode == E2_Mode_Type)
@@ -2310,7 +2310,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: sizeof //- rjf: sizeof
case E2_OpKind_SizeOf: case E2_ExprKind_SizeOf:
{ {
E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums); E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums);
U64 rhs_size = e2_byte_size_from_type_key(rhs_type_key); U64 rhs_size = e2_byte_size_from_type_key(rhs_type_key);
@@ -2319,7 +2319,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: typeof //- rjf: typeof
case E2_OpKind_TypeOf: case E2_ExprKind_TypeOf:
{ {
E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums); E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums);
finished_root = e2_expr(arena); finished_root = e2_expr(arena);
@@ -2328,7 +2328,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: casts //- rjf: casts
case E2_OpKind_CCast: case E2_ExprKind_CCast:
cast:; cast:;
{ {
E2_Expr *cast_type_expr = lhs; E2_Expr *cast_type_expr = lhs;
@@ -2345,8 +2345,8 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: dereferences //- rjf: dereferences
case E2_OpKind_Deref: case E2_ExprKind_Deref:
case E2_OpKind_DerefAsm: case E2_ExprKind_DerefAsm:
{ {
// rjf: unpack operand // rjf: unpack operand
E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums); E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_AllDecorative & ~E2_TypeUnwrapFlag_Enums);
@@ -2367,7 +2367,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot dereference arrays of zero-sized types."); e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot dereference arrays of zero-sized types.");
} }
else if(!e2_type_kind_is_ptr_or_ref(rhs_type_kind) && rhs_type_kind != E2_TypeKind_Array && else if(!e2_type_kind_is_ptr_or_ref(rhs_type_kind) && rhs_type_kind != E2_TypeKind_Array &&
completed_task->op_kind != E2_OpKind_DerefAsm) completed_task->expr_kind != E2_ExprKind_DerefAsm)
{ {
malformed = 1; malformed = 1;
e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot dereference this type."); e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot dereference this type.");
@@ -2381,7 +2381,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
// integer type. // integer type.
// //
if(!e2_type_kind_is_ptr_or_ref(rhs_type_kind) && rhs_type_kind != E2_TypeKind_Array && if(!e2_type_kind_is_ptr_or_ref(rhs_type_kind) && rhs_type_kind != E2_TypeKind_Array &&
completed_task->op_kind == E2_OpKind_DerefAsm) completed_task->expr_kind == E2_ExprKind_DerefAsm)
{ {
dereferenced_type = e2_type_key_basic(E2_TypeKind_U64); dereferenced_type = e2_type_key_basic(E2_TypeKind_U64);
} }
@@ -2405,7 +2405,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: address-of //- rjf: address-of
case E2_OpKind_Address: case E2_ExprKind_Address:
{ {
// rjf: determine if malformed // rjf: determine if malformed
B32 malformed = 0; B32 malformed = 0;
@@ -2426,15 +2426,15 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: positive (no-op, just take the right-hand-side) //- rjf: positive (no-op, just take the right-hand-side)
case E2_OpKind_Pos: case E2_ExprKind_Pos:
{ {
finished_root = rhs; finished_root = rhs;
}break; }break;
//- rjf: unary ops //- rjf: unary ops
case E2_OpKind_Neg: {op = RDI_EvalOp_Neg;}goto unary_op; case E2_ExprKind_Neg: {op = RDI_EvalOp_Neg;}goto unary_op;
case E2_OpKind_LogNot: {op = RDI_EvalOp_LogNot;}goto unary_op; case E2_ExprKind_LogNot: {op = RDI_EvalOp_LogNot;}goto unary_op;
case E2_OpKind_BitNot: {op = RDI_EvalOp_BitNot;}goto unary_op; case E2_ExprKind_BitNot: {op = RDI_EvalOp_BitNot;}goto unary_op;
unary_op:; unary_op:;
{ {
// rjf: unpack operand // rjf: unpack operand
@@ -2473,24 +2473,24 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: binary ops //- rjf: binary ops
case E2_OpKind_Mul: {op = RDI_EvalOp_Mul;}goto binary_op; case E2_ExprKind_Mul: {op = RDI_EvalOp_Mul;}goto binary_op;
case E2_OpKind_Div: {op = RDI_EvalOp_Div;}goto binary_op; case E2_ExprKind_Div: {op = RDI_EvalOp_Div;}goto binary_op;
case E2_OpKind_Mod: {op = RDI_EvalOp_Mod;}goto binary_op; case E2_ExprKind_Mod: {op = RDI_EvalOp_Mod;}goto binary_op;
case E2_OpKind_Add: {op = RDI_EvalOp_Add;}goto binary_op; case E2_ExprKind_Add: {op = RDI_EvalOp_Add;}goto binary_op;
case E2_OpKind_Sub: {op = RDI_EvalOp_Sub;}goto binary_op; case E2_ExprKind_Sub: {op = RDI_EvalOp_Sub;}goto binary_op;
case E2_OpKind_LShift:{op = RDI_EvalOp_LShift;}goto binary_op; case E2_ExprKind_LShift:{op = RDI_EvalOp_LShift;}goto binary_op;
case E2_OpKind_RShift:{op = RDI_EvalOp_RShift;}goto binary_op; case E2_ExprKind_RShift:{op = RDI_EvalOp_RShift;}goto binary_op;
case E2_OpKind_Less: {op = RDI_EvalOp_Less;}goto binary_op; case E2_ExprKind_Less: {op = RDI_EvalOp_Less;}goto binary_op;
case E2_OpKind_LtEq: {op = RDI_EvalOp_LsEq;}goto binary_op; case E2_ExprKind_LtEq: {op = RDI_EvalOp_LsEq;}goto binary_op;
case E2_OpKind_Grtr: {op = RDI_EvalOp_Grtr;}goto binary_op; case E2_ExprKind_Grtr: {op = RDI_EvalOp_Grtr;}goto binary_op;
case E2_OpKind_GrEq: {op = RDI_EvalOp_GrEq;}goto binary_op; case E2_ExprKind_GrEq: {op = RDI_EvalOp_GrEq;}goto binary_op;
case E2_OpKind_EqEq: {op = RDI_EvalOp_EqEq;}goto binary_op; case E2_ExprKind_EqEq: {op = RDI_EvalOp_EqEq;}goto binary_op;
case E2_OpKind_NtEq: {op = RDI_EvalOp_NtEq;}goto binary_op; case E2_ExprKind_NtEq: {op = RDI_EvalOp_NtEq;}goto binary_op;
case E2_OpKind_BitAnd:{op = RDI_EvalOp_BitAnd;}goto binary_op; case E2_ExprKind_BitAnd:{op = RDI_EvalOp_BitAnd;}goto binary_op;
case E2_OpKind_BitXor:{op = RDI_EvalOp_BitXor;}goto binary_op; case E2_ExprKind_BitXor:{op = RDI_EvalOp_BitXor;}goto binary_op;
case E2_OpKind_BitOr: {op = RDI_EvalOp_BitOr;}goto binary_op; case E2_ExprKind_BitOr: {op = RDI_EvalOp_BitOr;}goto binary_op;
case E2_OpKind_LogAnd:{op = RDI_EvalOp_LogAnd;}goto binary_op; case E2_ExprKind_LogAnd:{op = RDI_EvalOp_LogAnd;}goto binary_op;
case E2_OpKind_LogOr: {op = RDI_EvalOp_LogOr;}goto binary_op; case E2_ExprKind_LogOr: {op = RDI_EvalOp_LogOr;}goto binary_op;
binary_op:; binary_op:;
{ {
// rjf: resolve lhs / rhs to values // rjf: resolve lhs / rhs to values
@@ -2641,14 +2641,14 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
//- rjf: type comparisons //- rjf: type comparisons
case ArithKind_TypeCompare: case ArithKind_TypeCompare:
{ {
if(completed_task->op_kind == E2_OpKind_EqEq || if(completed_task->expr_kind == E2_ExprKind_EqEq ||
completed_task->op_kind == E2_OpKind_NtEq) completed_task->expr_kind == E2_ExprKind_NtEq)
{ {
E2_TypeKey lhs_type_key = e2_type_key_unwrap(lhs->type_key, E2_TypeUnwrapFlag_Meta); E2_TypeKey lhs_type_key = e2_type_key_unwrap(lhs->type_key, E2_TypeUnwrapFlag_Meta);
E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_Meta); E2_TypeKey rhs_type_key = e2_type_key_unwrap(rhs->type_key, E2_TypeUnwrapFlag_Meta);
B32 types_match = e2_type_deep_match(lhs_type_key, rhs_type_key); B32 types_match = e2_type_deep_match(lhs_type_key, rhs_type_key);
B32 result = types_match; B32 result = types_match;
if(completed_task->op_kind == E2_OpKind_NtEq) if(completed_task->expr_kind == E2_ExprKind_NtEq)
{ {
result = !result; result = !result;
} }
@@ -2657,14 +2657,14 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
} }
else else
{ {
e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot use `%S` on types.", str8_skip_chop_whitespace(e2_op_kind_info_table[completed_task->op_kind].sep)); e2_msgf(arena, &parse.msgs, completed_task->src_range, "Cannot use `%S` on types.", str8_skip_chop_whitespace(e2_expr_kind_info_table[completed_task->expr_kind].sep));
} }
}break; }break;
} }
}break; }break;
//- rjf: definitions //- rjf: definitions
case E2_OpKind_Define: case E2_ExprKind_Define:
{ {
if(completed_with_caller_info) if(completed_with_caller_info)
{ {
@@ -2681,7 +2681,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: macros //- rjf: macros
case E2_OpKind_Macro: case E2_ExprKind_Macro:
{ {
if(completed_with_caller_info) if(completed_with_caller_info)
{ {
@@ -2698,7 +2698,7 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
}break; }break;
//- rjf: conditionals //- rjf: conditionals
case E2_OpKind_Cond: case E2_ExprKind_Cond:
{ {
// rjf: unpack operands // rjf: unpack operands
E2_Expr *condition_expr = lhs; E2_Expr *condition_expr = lhs;
@@ -2869,25 +2869,25 @@ e2_parse_from_string(Arena *arena, E2_ParseState *state, E2_ExprMap *expr_map, E
{ {
for(E2_ParseTask *t = state->top_task; t != 0; t = t->next) for(E2_ParseTask *t = state->top_task; t != 0; t = t->next)
{ {
if(t->child_count == 1 && t->child_count_target == 2 && t->op_kind == E2_OpKind_Dot) if(t->child_count == 1 && t->child_count_target == 2 && t->expr_kind == E2_ExprKind_Dot)
{ {
e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't access member `%S`.", state->last_requested_member_name); e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't access member `%S`.", state->last_requested_member_name);
} }
else if(t->child_count == 2 && t->child_count_target == 2 && t->op_kind == E2_OpKind_Index) else if(t->child_count == 2 && t->child_count_target == 2 && t->expr_kind == E2_ExprKind_Index)
{ {
e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't index into this type."); e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't index into this type.");
} }
else if(t->child_count >= 1 && t->op_kind == E2_OpKind_Call) else if(t->child_count >= 1 && t->expr_kind == E2_ExprKind_Call)
{ {
e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't call into this type."); e2_msgf(arena, &parse.msgs, t->src_range, "Couldn't call into this type.");
} }
else if(t->child_count == 1 && t->child_count_target == 2 && t->op_kind != E2_OpKind_Null) else if(t->child_count == 1 && t->child_count_target == 2 && t->expr_kind != E2_ExprKind_Null)
{ {
e2_msgf(arena, &parse.msgs, t->src_range, "Expected expression after binary operator `%S`.", e2_op_kind_info_table[t->op_kind].sep); e2_msgf(arena, &parse.msgs, t->src_range, "Expected expression after binary operator `%S`.", e2_expr_kind_info_table[t->expr_kind].sep);
} }
else if(t->child_count == 0 && t->child_count_target == 1 && t->op_kind != E2_OpKind_Null) else if(t->child_count == 0 && t->child_count_target == 1 && t->expr_kind != E2_ExprKind_Null)
{ {
e2_msgf(arena, &parse.msgs, t->src_range, "Expected expression after unary operator `%S`.", e2_op_kind_info_table[t->op_kind].pre); e2_msgf(arena, &parse.msgs, t->src_range, "Expected expression after unary operator `%S`.", e2_expr_kind_info_table[t->expr_kind].pre);
} }
else else
{ {
src/eval2/eval2.h
+12 -11
View File
@@ -7,20 +7,20 @@
//////////////////////////////// ////////////////////////////////
//~ rjf: Operator Info Tables //~ rjf: Operator Info Tables
typedef enum E2_OpParseKind typedef enum E2_ExprParseKind
{ {
E2_OpParseKind_Null, E2_ExprParseKind_Null,
E2_OpParseKind_UnaryPrefix, E2_ExprParseKind_UnaryPrefix,
E2_OpParseKind_Binary, E2_ExprParseKind_Binary,
E2_OpParseKind_Ternary, E2_ExprParseKind_Ternary,
E2_OpParseKind_Call, E2_ExprParseKind_Call,
} }
E2_OpParseKind; E2_ExprParseKind;
typedef struct E2_OpInfo E2_OpInfo; typedef struct E2_ExprKindInfo E2_ExprKindInfo;
struct E2_OpInfo struct E2_ExprKindInfo
{ {
E2_OpParseKind parse_kind; E2_ExprParseKind parse_kind;
S64 precedence; S64 precedence;
String8 pre; String8 pre;
String8 sep; String8 sep;
@@ -330,6 +330,7 @@ struct E2_Expr
E2_ExprNode *first_child; E2_ExprNode *first_child;
E2_ExprNode *last_child; E2_ExprNode *last_child;
U64 child_count; U64 child_count;
E2_ExprKind kind;
Rng1U64 src_range; Rng1U64 src_range;
String8 string; String8 string;
RDI_EvalOp op; RDI_EvalOp op;
@@ -363,7 +364,7 @@ struct E2_ParseTask
U64 child_count; U64 child_count;
U64 child_count_target; U64 child_count_target;
S64 max_precedence; S64 max_precedence;
E2_OpKind op_kind; E2_ExprKind expr_kind;
String8 identifier; String8 identifier;
String8 expected_closer; String8 expected_closer;
String8 expected_splitter; String8 expected_splitter;
src/eval2/eval2.mdesk
+5 -5
View File
@@ -2,7 +2,7 @@
// Licensed under the MIT license (https://opensource.org/license/mit/) // Licensed under the MIT license (https://opensource.org/license/mit/)
@table(name parse_kind precedence pre sep pos chain) @table(name parse_kind precedence pre sep pos chain)
E2_OpTable: E2_ExprKindTable:
{ {
{Dot Binary 1 "" "." "" "" } {Dot Binary 1 "" "." "" "" }
{Index Binary 1 "" "[" "]" "" } {Index Binary 1 "" "[" "]" "" }
@@ -40,17 +40,17 @@ E2_OpTable:
{Cond Ternary 14 "" "?" "" ":"} {Cond Ternary 14 "" "?" "" ":"}
} }
@enum E2_OpKind: @enum E2_ExprKind:
{ {
Null, Null,
@expand(E2_OpTable a) `$(a.name)`, @expand(E2_ExprKindTable a) `$(a.name)`,
COUNT, COUNT,
} }
@data(E2_OpInfo) e2_op_kind_info_table: @data(E2_ExprKindInfo) e2_expr_kind_info_table:
{ {
`{0}`, `{0}`,
@expand(E2_OpTable a) `{E2_OpParseKind_$(a.parse_kind), $(a.precedence), str8_lit_comp("$(a.pre)"), str8_lit_comp("$(a.sep)"), str8_lit_comp("$(a.pos)"), str8_lit_comp("$(a.chain)")}` @expand(E2_ExprKindTable a) `{E2_ExprParseKind_$(a.parse_kind), $(a.precedence), str8_lit_comp("$(a.pre)"), str8_lit_comp("$(a.sep)"), str8_lit_comp("$(a.pos)"), str8_lit_comp("$(a.chain)")}`
} }
@table(name basic_string basic_byte_size) @table(name basic_string basic_byte_size)
src/eval2/generated/eval2.meta.c
+35 -35
View File
@@ -4,43 +4,43 @@
//- GENERATED CODE //- GENERATED CODE
C_LINKAGE_BEGIN C_LINKAGE_BEGIN
E2_OpInfo e2_op_kind_info_table[35] = E2_ExprKindInfo e2_expr_kind_info_table[35] =
{ {
{0}, {0},
{E2_OpParseKind_Binary, 1, str8_lit_comp(""), str8_lit_comp("."), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 1, str8_lit_comp(""), str8_lit_comp("."), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 1, str8_lit_comp(""), str8_lit_comp("["), str8_lit_comp("]"), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 1, str8_lit_comp(""), str8_lit_comp("["), str8_lit_comp("]"), str8_lit_comp("")},
{E2_OpParseKind_Call, 1, str8_lit_comp(""), str8_lit_comp("("), str8_lit_comp(")"), str8_lit_comp(",")}, {E2_ExprParseKind_Call, 1, str8_lit_comp(""), str8_lit_comp("("), str8_lit_comp(")"), str8_lit_comp(",")},
{E2_OpParseKind_UnaryPrefix, 1, str8_lit_comp("["), str8_lit_comp(""), str8_lit_comp("]"), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("["), str8_lit_comp(""), str8_lit_comp("]"), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 1, str8_lit_comp("sizeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("sizeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 1, str8_lit_comp("typeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp("typeof "), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 1, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 1, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("!"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("!"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_UnaryPrefix, 2, str8_lit_comp("~"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_UnaryPrefix, 2, str8_lit_comp("~"), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("*"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("/"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("/"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("%"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 3, str8_lit_comp(""), str8_lit_comp("%"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("+"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 4, str8_lit_comp(""), str8_lit_comp("-"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp("<<"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp("<<"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp(">>"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 5, str8_lit_comp(""), str8_lit_comp(">>"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp("<="), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 6, str8_lit_comp(""), str8_lit_comp(">="), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("=="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("=="), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("!="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 7, str8_lit_comp(""), str8_lit_comp("!="), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 8, str8_lit_comp(""), str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 8, str8_lit_comp(""), str8_lit_comp("&"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 9, str8_lit_comp(""), str8_lit_comp("^"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 9, str8_lit_comp(""), str8_lit_comp("^"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 10, str8_lit_comp(""), str8_lit_comp("|"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 10, str8_lit_comp(""), str8_lit_comp("|"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 11, str8_lit_comp(""), str8_lit_comp("&&"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 11, str8_lit_comp(""), str8_lit_comp("&&"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Binary, 12, str8_lit_comp(""), str8_lit_comp("||"), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Binary, 12, str8_lit_comp(""), str8_lit_comp("||"), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Null, 13, str8_lit_comp(""), str8_lit_comp("="), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Null, 13, str8_lit_comp(""), str8_lit_comp("="), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Null, 14, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")}, {E2_ExprParseKind_Null, 14, str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp(""), str8_lit_comp("")},
{E2_OpParseKind_Ternary, 14, str8_lit_comp(""), str8_lit_comp("?"), str8_lit_comp(""), str8_lit_comp(":")}, {E2_ExprParseKind_Ternary, 14, str8_lit_comp(""), str8_lit_comp("?"), str8_lit_comp(""), str8_lit_comp(":")},
}; };
U8 e2_type_kind_basic_byte_size_table[61] = U8 e2_type_kind_basic_byte_size_table[61] =
src/eval2/generated/eval2.meta.h
+39 -39
View File
@@ -6,45 +6,45 @@
#ifndef EVAL2_META_H #ifndef EVAL2_META_H
#define EVAL2_META_H #define EVAL2_META_H
typedef enum E2_OpKind typedef enum E2_ExprKind
{ {
E2_OpKind_Null, E2_ExprKind_Null,
E2_OpKind_Dot, E2_ExprKind_Dot,
E2_OpKind_Index, E2_ExprKind_Index,
E2_OpKind_Call, E2_ExprKind_Call,
E2_OpKind_DerefAsm, E2_ExprKind_DerefAsm,
E2_OpKind_SizeOf, E2_ExprKind_SizeOf,
E2_OpKind_TypeOf, E2_ExprKind_TypeOf,
E2_OpKind_CCast, E2_ExprKind_CCast,
E2_OpKind_Deref, E2_ExprKind_Deref,
E2_OpKind_Address, E2_ExprKind_Address,
E2_OpKind_Pos, E2_ExprKind_Pos,
E2_OpKind_Neg, E2_ExprKind_Neg,
E2_OpKind_LogNot, E2_ExprKind_LogNot,
E2_OpKind_BitNot, E2_ExprKind_BitNot,
E2_OpKind_Mul, E2_ExprKind_Mul,
E2_OpKind_Div, E2_ExprKind_Div,
E2_OpKind_Mod, E2_ExprKind_Mod,
E2_OpKind_Add, E2_ExprKind_Add,
E2_OpKind_Sub, E2_ExprKind_Sub,
E2_OpKind_LShift, E2_ExprKind_LShift,
E2_OpKind_RShift, E2_ExprKind_RShift,
E2_OpKind_Less, E2_ExprKind_Less,
E2_OpKind_LtEq, E2_ExprKind_LtEq,
E2_OpKind_Grtr, E2_ExprKind_Grtr,
E2_OpKind_GrEq, E2_ExprKind_GrEq,
E2_OpKind_EqEq, E2_ExprKind_EqEq,
E2_OpKind_NtEq, E2_ExprKind_NtEq,
E2_OpKind_BitAnd, E2_ExprKind_BitAnd,
E2_OpKind_BitXor, E2_ExprKind_BitXor,
E2_OpKind_BitOr, E2_ExprKind_BitOr,
E2_OpKind_LogAnd, E2_ExprKind_LogAnd,
E2_OpKind_LogOr, E2_ExprKind_LogOr,
E2_OpKind_Define, E2_ExprKind_Define,
E2_OpKind_Macro, E2_ExprKind_Macro,
E2_OpKind_Cond, E2_ExprKind_Cond,
E2_OpKind_COUNT, E2_ExprKind_COUNT,
} E2_OpKind; } E2_ExprKind;
typedef enum E2_TypeKind typedef enum E2_TypeKind
{ {
@@ -125,7 +125,7 @@ E2_TypeKind_LastMeta = E2_TypeKind_MetaDescription,
} E2_TypeKind; } E2_TypeKind;
C_LINKAGE_BEGIN C_LINKAGE_BEGIN
extern E2_OpInfo e2_op_kind_info_table[35]; extern E2_ExprKindInfo e2_expr_kind_info_table[35];
extern U8 e2_type_kind_basic_byte_size_table[61]; extern U8 e2_type_kind_basic_byte_size_table[61];
extern String8 e2_type_kind_basic_string_table[61]; extern String8 e2_type_kind_basic_string_table[61];