diff --git a/docs/metadesk_reference.md b/docs/metadesk_reference.md index d7c91e3..24bb51b 100644 --- a/docs/metadesk_reference.md +++ b/docs/metadesk_reference.md @@ -451,78 +451,6 @@ main: bytes_parse: MD_u64; }; -//////////////////////////////// -//~ Expression and Type-Expression parser helper types. - -// VERY_IMPORTANT_NOTE(rjf): If this enum is ever changed, ensure that -// it is kept in-sync with the MD_ExprPrecFromExprKind function. - -@send(ExpressionParsingHelper) -@enum MD_ExprKind: { - Nil, - - // NOTE(rjf): Atom - Atom, - - // NOTE(rjf): Access - Dot, - Arrow, - Call, - Subscript, - Dereference, - Reference, - - // NOTE(rjf): Arithmetic - Add, - Subtract, - Multiply, - Divide, - Mod, - - // NOTE(rjf): Comparison - IsEqual, - IsNotEqual, - LessThan, - GreaterThan, - LessThanEqualTo, - GreaterThanEqualTo, - - // NOTE(rjf): Bools - BoolAnd, - BoolOr, - BoolNot, - - // NOTE(rjf): Bitwise - BitAnd, - BitOr, - BitNot, - BitXor, - LeftShift, - RightShift, - - // NOTE(rjf): Unary numeric - Negative, - - // NOTE(rjf): Type - Pointer, - Array, - Volatile, - Const, - - MAX, -}; - -@send(ExpressionParsingHelper) -@typedef(MD_i32) MD_ExprPrec; - -@send(ExpressionParsingHelper) -@struct MD_Expr: { - node: *MD_Node, - kind: MD_ExprKind, - parent: *MD_Expr, - sub: ([2]*MD_Expr), -}; - //////////////////////////////// //~ Command line parsing helper types. @@ -1330,81 +1258,81 @@ main: //~ Expression and Type-Expression Helper @send(ExpressionParsingHelper) -@func MD_NilExpr: { - return: *MD_Expr, +@func MD_C_NilExpr: { + return: *MD_C_Expr, }; @send(ExpressionParsingHelper) -@func MD_ExprIsNil: { - expr: *MD_Expr, +@func MD_C_ExprIsNil: { + expr: *MD_C_Expr, return: MD_b32, }; @send(ExpressionParsingHelper) -@func MD_PreUnaryExprKindFromNode: { +@func MD_C_PreUnaryExprKindFromNode: { node: *MD_Node, return: MD_ExprKind, }; @send(ExpressionParsingHelper) -@func MD_BinaryExprKindFromNode: { +@func MD_C_BinaryExprKindFromNode: { node: *MD_Node, return: MD_ExprKind, }; @send(ExpressionParsingHelper) -@func MD_ExprPrecFromExprKind: { +@func MD_C_ExprPrecFromExprKind: { kind: MD_ExprKind, return: MD_ExprPrec, }; @send(ExpressionParsingHelper) -@func MD_MakeExpr: { +@func MD_C_MakeExpr: { node: *MD_Node, kind: MD_ExprKind, - left: *MD_Expr, - right: *MD_Expr, - return: *MD_Expr, + left: *MD_C_Expr, + right: *MD_C_Expr, + return: *MD_C_Expr, }; @send(ExpressionParsingHelper) -@func MD_ParseAsExpr: { +@func MD_C_ParseAsExpr: { first: *MD_Node, last: *MD_Node, - return: *MD_Expr, + return: *MD_C_Expr, }; @send(ExpressionParsingHelper) -@func MD_ParseAsType: { +@func MD_C_ParseAsType: { first: *MD_Node, last: *MD_Node, - return: *MD_Expr, + return: *MD_C_Expr, }; @send(ExpressionParsingHelper) -@func MD_EvaluateExpr_I64: { - expr: *MD_Expr, +@func MD_C_EvaluateExpr_I64: { + expr: *MD_C_Expr, return: MD_i64, }; @send(ExpressionParsingHelper) -@func MD_EvaluateExpr_F64: { - expr: *MD_Expr, +@func MD_C_EvaluateExpr_F64: { + expr: *MD_C_Expr, return: MD_f64, }; @send(ExpressionParsingHelper) -@func MD_ExprMatch: { - a: *MD_Expr, - b: *MD_Expr, +@func MD_C_ExprMatch: { + a: *MD_C_Expr, + b: *MD_C_Expr, str_flags: MD_StringMatchFlags, return: MD_b32, }; @send(ExpressionParsingHelper) -@func MD_ExprDeepMatch: { - a: *MD_Expr, - b: *MD_Expr, +@func MD_C_ExprDeepMatch: { + a: *MD_C_Expr, + b: *MD_C_Expr, str_flags: MD_StringMatchFlags, return: MD_b32, }; @@ -1443,31 +1371,25 @@ main: @func MD_C_Generate_DeclByNameAndType: { file: *FILE, name: MD_String8, - type: *MD_Expr, + type: *MD_C_Expr, }; @send(Output) @func MD_C_Generate_Expr: { file: *FILE, - expr: *MD_Expr, + expr: *MD_C_Expr, }; @send(Output) -@func MD_OutputType: { +@func MD_C_Generate_TypeLHS: { file: *FILE, - type: *MD_Expr, + type: *MD_C_Expr, }; @send(Output) -@func MD_OutputType_C_LHS: { +@func MD_C_Generate_TypeRHS: { file: *FILE, - type: *MD_Expr, -}; - -@send(Output) -@func MD_OutputType_C_RHS: { - file: *FILE, - type: *MD_Expr, + type: *MD_C_Expr, }; //////////////////////////////// @@ -1544,3 +1466,86 @@ main: out_info: *MD_FileInfo, return: MD_b32, }; + +//////////////////////////////// +//~ Expression and Type-Expression parser helper types. + +// VERY_IMPORTANT_NOTE(rjf): If this enum is ever changed, ensure that +// it is kept in-sync with the MD_ExprPrecFromExprKind function. + +@send(ExpressionParsingHelper) +@enum MD_C_ExprKind: { + Nil, + + // NOTE(rjf): Atom + Atom, + + // NOTE(rjf): Access + Dot, + Arrow, + Call, + Subscript, + Dereference, + Reference, + + // NOTE(rjf): Arithmetic + Add, + Subtract, + Multiply, + Divide, + Mod, + + // NOTE(rjf): Comparison + IsEqual, + IsNotEqual, + LessThan, + GreaterThan, + LessThanEqualTo, + GreaterThanEqualTo, + + // NOTE(rjf): Bools + BoolAnd, + BoolOr, + BoolNot, + + // NOTE(rjf): Bitwise + BitAnd, + BitOr, + BitNot, + BitXor, + LeftShift, + RightShift, + + // NOTE(rjf): Unary numeric + Negative, + + // NOTE(rjf): Type + Pointer, + Array, + Volatile, + Const, + + MAX, +}; + + +@send(ExpressionParsingHelper) +@enum MD_C_ExprKindGroup: { + Nil, + Atom, + Binary, + PreUnary, + PostUnary, + Type, +}; + +@send(ExpressionParsingHelper) +@typedef(MD_i32) MD_C_ExprPrec; + +@send(ExpressionParsingHelper) +@struct MD_C_Expr: { + node: *MD_Node, + kind: MD_ExprKind, + parent: *MD_C_Expr, + sub: ([2]*MD_C_Expr), +}; diff --git a/samples/namespaced_types/namespaced_types.c b/samples/namespaced_types/namespaced_types.c index 15b128d..89a35f9 100644 --- a/samples/namespaced_types/namespaced_types.c +++ b/samples/namespaced_types/namespaced_types.c @@ -14,11 +14,12 @@ static MD_Map MapFromChildren(MD_Node *node) return result; } -static void OutputType_C_LHS_Namespace(FILE *file, MD_Map *user_defined_types, MD_String8 prefix, MD_Expr *type) +static void +OutputType_C_LHS_Namespace(FILE *file, MD_Map *user_defined_types, MD_String8 prefix, MD_C_Expr *type) { switch (type->kind) { - case MD_ExprKind_Atom: + case MD_C_ExprKind_Atom: { MD_Node *node = type->node; @@ -29,7 +30,7 @@ static void OutputType_C_LHS_Namespace(FILE *file, MD_Map *user_defined_types, M fprintf(file, "%.*s", MD_StringExpand(node->whole_string)); }break; - case MD_ExprKind_Pointer: + case MD_C_ExprKind_Pointer: { OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]); if (_MD_OutputType_C_NeedsParens(type)) @@ -39,7 +40,7 @@ static void OutputType_C_LHS_Namespace(FILE *file, MD_Map *user_defined_types, M fprintf(file, "*"); }break; - case MD_ExprKind_Array: + case MD_C_ExprKind_Array: { OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]); if (_MD_OutputType_C_NeedsParens(type)) @@ -48,8 +49,8 @@ static void OutputType_C_LHS_Namespace(FILE *file, MD_Map *user_defined_types, M } }break; - case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; - case MD_ExprKind_Const: { fprintf(file, "const "); }break; + case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break; + case MD_C_ExprKind_Const: { fprintf(file, "const "); }break; default: { @@ -132,12 +133,12 @@ static void OutputPrefixedType(FILE *f, MD_Map *user_defined_types, MD_String8 p } else { - MD_Expr *type = MD_ParseAsType(node->first_child, node->last_child); + MD_C_Expr *type = MD_C_ParseAsType(node->first_child, node->last_child); I(); OutputType_C_LHS_Namespace(f, user_defined_types, prefix, type); fprintf(f, " %.*s", MD_StringExpand(node->string)); - MD_C_Generate_RHS(f, type); + MD_C_Generate_TypeRHS(f, type); fprintf(f, ";\n"); } diff --git a/source/md_c_helpers.c b/source/md_c_helpers.c index a01b81b..4adbe3b 100644 --- a/source/md_c_helpers.c +++ b/source/md_c_helpers.c @@ -1,37 +1,37 @@ //~ Expression and Type-Expression Helper -MD_GLOBAL MD_Expr _md_nil_expr = +MD_GLOBAL MD_C_Expr _md_nil_expr = { &_md_nil_node, - MD_ExprKind_Nil, + MD_C_ExprKind_Nil, &_md_nil_expr, {&_md_nil_expr, &_md_nil_expr }, }; -MD_FUNCTION_IMPL MD_Expr * -MD_NilExpr(void) +MD_FUNCTION_IMPL MD_C_Expr * +MD_C_NilExpr(void) { return &_md_nil_expr; } MD_FUNCTION_IMPL MD_b32 -MD_ExprIsNil(MD_Expr *expr) +MD_C_ExprIsNil(MD_C_Expr *expr) { - return expr == 0 || expr == &_md_nil_expr || expr->kind == MD_ExprKind_Nil; + return expr == 0 || expr == &_md_nil_expr || expr->kind == MD_C_ExprKind_Nil; } -typedef struct _MD_ExprKindMetadata _MD_ExprKindMetadata; -struct _MD_ExprKindMetadata +typedef struct _MD_C_ExprKindMetadata _MD_C_ExprKindMetadata; +struct _MD_C_ExprKindMetadata { - MD_ExprKindGroup group; - MD_ExprPrec prec; + MD_C_ExprKindGroup group; + MD_C_ExprPrec prec; char *symbol; char *pre_symbol; char *post_symbol; }; -MD_FUNCTION_IMPL _MD_ExprKindMetadata * -_MD_MetadataFromExprKind(MD_ExprKind kind) +MD_FUNCTION_IMPL _MD_C_ExprKindMetadata * +_MD_MetadataFromExprKind(MD_C_ExprKind kind) { // 0: Invalid // 12: (unary) - ~ ! @@ -46,88 +46,88 @@ _MD_MetadataFromExprKind(MD_ExprKind kind) // 3: | // 2: && // 1: || - static _MD_ExprKindMetadata metadata[] = + static _MD_C_ExprKindMetadata metadata[] = { - {MD_ExprKindGroup_Nil, +0, "NIL", "", "" }, // MD_ExprKind_Nil - {MD_ExprKindGroup_Atom, +0, "NIL", "", "" }, // MD_ExprKind_Atom - {MD_ExprKindGroup_Binary, +11, ".", "", "" }, // MD_ExprKind_Dot - {MD_ExprKindGroup_Binary, +11, "->", "", "" }, // MD_ExprKind_Arrow - {MD_ExprKindGroup_PostUnary, +11, "", "(", ")"}, // MD_ExprKind_Call - {MD_ExprKindGroup_PostUnary, +11, "", "[", "]"}, // MD_ExprKind_Subscript - {MD_ExprKindGroup_PreUnary, +12, "", "*", "" }, // MD_ExprKind_Dereference - {MD_ExprKindGroup_PreUnary, +12, "", "&", "" }, // MD_ExprKind_Reference - {MD_ExprKindGroup_Binary, +9, "+", "", "" }, // MD_ExprKind_Add - {MD_ExprKindGroup_Binary, +9, "-", "", "" }, // MD_ExprKind_Subtract - {MD_ExprKindGroup_Binary, +10, "*", "", "" }, // MD_ExprKind_Multiply - {MD_ExprKindGroup_Binary, +10, "/", "", "" }, // MD_ExprKind_Divide - {MD_ExprKindGroup_Binary, +10, "%", "", "" }, // MD_ExprKind_Mod - {MD_ExprKindGroup_Binary, +6, "==", "", "" }, // MD_ExprKind_IsEqual - {MD_ExprKindGroup_Binary, +6, "!=", "", "" }, // MD_ExprKind_IsNotEqual - {MD_ExprKindGroup_Binary, +7, "<", "", "" }, // MD_ExprKind_LessThan - {MD_ExprKindGroup_Binary, +7, ">", "", "" }, // MD_ExprKind_GreaterThan - {MD_ExprKindGroup_Binary, +7, "<=", "", "" }, // MD_ExprKind_LessThanEqualTo - {MD_ExprKindGroup_Binary, +7, ">=", "", "" }, // MD_ExprKind_GreaterThanEqualTo - {MD_ExprKindGroup_Binary, +2, "&&", "", "" }, // MD_ExprKind_BoolAnd - {MD_ExprKindGroup_Binary, +1, "||", "", "" }, // MD_ExprKind_BoolOr - {MD_ExprKindGroup_PreUnary, +12, "", "!", "" }, // MD_ExprKind_BoolNot - {MD_ExprKindGroup_Binary, +5, "&", "", "" }, // MD_ExprKind_BitAnd - {MD_ExprKindGroup_Binary, +3, "|", "", "" }, // MD_ExprKind_BitOr - {MD_ExprKindGroup_PreUnary, +12, "", "~", "" }, // MD_ExprKind_BitNot - {MD_ExprKindGroup_Binary, +4, "^", "", "" }, // MD_ExprKind_BitXor - {MD_ExprKindGroup_Binary, +8, "<<", "", "" }, // MD_ExprKind_LeftShift - {MD_ExprKindGroup_Binary, +8, ">>", "", "" }, // MD_ExprKind_RightShift - {MD_ExprKindGroup_PreUnary, +12, "", "-", "" }, // MD_ExprKind_Negative - {MD_ExprKindGroup_Type, +0, "*", "", "" }, // MD_ExprKind_Pointer - {MD_ExprKindGroup_Type, +0, "", "[", "]"}, // MD_ExprKind_Array + {MD_C_ExprKindGroup_Nil, +0, "NIL", "", "" }, // MD_C_ExprKind_Nil + {MD_C_ExprKindGroup_Atom, +0, "NIL", "", "" }, // MD_C_ExprKind_Atom + {MD_C_ExprKindGroup_Binary, +11, ".", "", "" }, // MD_C_ExprKind_Dot + {MD_C_ExprKindGroup_Binary, +11, "->", "", "" }, // MD_C_ExprKind_Arrow + {MD_C_ExprKindGroup_PostUnary, +11, "", "(", ")"}, // MD_C_ExprKind_Call + {MD_C_ExprKindGroup_PostUnary, +11, "", "[", "]"}, // MD_C_ExprKind_Subscript + {MD_C_ExprKindGroup_PreUnary, +12, "", "*", "" }, // MD_C_ExprKind_Dereference + {MD_C_ExprKindGroup_PreUnary, +12, "", "&", "" }, // MD_C_ExprKind_Reference + {MD_C_ExprKindGroup_Binary, +9, "+", "", "" }, // MD_C_ExprKind_Add + {MD_C_ExprKindGroup_Binary, +9, "-", "", "" }, // MD_C_ExprKind_Subtract + {MD_C_ExprKindGroup_Binary, +10, "*", "", "" }, // MD_C_ExprKind_Multiply + {MD_C_ExprKindGroup_Binary, +10, "/", "", "" }, // MD_C_ExprKind_Divide + {MD_C_ExprKindGroup_Binary, +10, "%", "", "" }, // MD_C_ExprKind_Mod + {MD_C_ExprKindGroup_Binary, +6, "==", "", "" }, // MD_C_ExprKind_IsEqual + {MD_C_ExprKindGroup_Binary, +6, "!=", "", "" }, // MD_C_ExprKind_IsNotEqual + {MD_C_ExprKindGroup_Binary, +7, "<", "", "" }, // MD_C_ExprKind_LessThan + {MD_C_ExprKindGroup_Binary, +7, ">", "", "" }, // MD_C_ExprKind_GreaterThan + {MD_C_ExprKindGroup_Binary, +7, "<=", "", "" }, // MD_C_ExprKind_LessThanEqualTo + {MD_C_ExprKindGroup_Binary, +7, ">=", "", "" }, // MD_C_ExprKind_GreaterThanEqualTo + {MD_C_ExprKindGroup_Binary, +2, "&&", "", "" }, // MD_C_ExprKind_BoolAnd + {MD_C_ExprKindGroup_Binary, +1, "||", "", "" }, // MD_C_ExprKind_BoolOr + {MD_C_ExprKindGroup_PreUnary, +12, "", "!", "" }, // MD_C_ExprKind_BoolNot + {MD_C_ExprKindGroup_Binary, +5, "&", "", "" }, // MD_C_ExprKind_BitAnd + {MD_C_ExprKindGroup_Binary, +3, "|", "", "" }, // MD_C_ExprKind_BitOr + {MD_C_ExprKindGroup_PreUnary, +12, "", "~", "" }, // MD_C_ExprKind_BitNot + {MD_C_ExprKindGroup_Binary, +4, "^", "", "" }, // MD_C_ExprKind_BitXor + {MD_C_ExprKindGroup_Binary, +8, "<<", "", "" }, // MD_C_ExprKind_LeftShift + {MD_C_ExprKindGroup_Binary, +8, ">>", "", "" }, // MD_C_ExprKind_RightShift + {MD_C_ExprKindGroup_PreUnary, +12, "", "-", "" }, // MD_C_ExprKind_Negative + {MD_C_ExprKindGroup_Type, +0, "*", "", "" }, // MD_C_ExprKind_Pointer + {MD_C_ExprKindGroup_Type, +0, "", "[", "]"}, // MD_C_ExprKind_Array }; return &metadata[kind]; } -MD_FUNCTION_IMPL MD_ExprKind -MD_PostUnaryExprKindFromNode(MD_Node *node) +MD_FUNCTION_IMPL MD_C_ExprKind +MD_C_PostUnaryExprKindFromNode(MD_Node *node) { - MD_ExprKind kind = MD_ExprKind_Nil; + MD_C_ExprKind kind = MD_C_ExprKind_Nil; if(!MD_NodeIsNil(node->first_child)) { if(node->flags & MD_NodeFlag_ParenLeft && node->flags & MD_NodeFlag_ParenRight) { - kind = MD_ExprKind_Call; + kind = MD_C_ExprKind_Call; } else if(node->flags & MD_NodeFlag_BracketLeft && node->flags & MD_NodeFlag_BracketRight) { - kind = MD_ExprKind_Subscript; + kind = MD_C_ExprKind_Subscript; } } return kind; } -MD_FUNCTION_IMPL MD_ExprKind -MD_PreUnaryExprKindFromNode(MD_Node *node) +MD_FUNCTION_IMPL MD_C_ExprKind +MD_C_PreUnaryExprKindFromNode(MD_Node *node) { - MD_ExprKind kind = MD_ExprKind_Nil; + MD_C_ExprKind kind = MD_C_ExprKind_Nil; // NOTE(rjf): Special-cases for calls/subscripts. if(!MD_NodeIsNil(node->first_child)) { if(node->flags & MD_NodeFlag_ParenLeft && node->flags & MD_NodeFlag_ParenRight) { - kind = MD_ExprKind_Call; + kind = MD_C_ExprKind_Call; } else if(node->flags & MD_NodeFlag_BracketLeft && node->flags & MD_NodeFlag_BracketRight) { - kind = MD_ExprKind_Subscript; + kind = MD_C_ExprKind_Subscript; } } else { - for(MD_ExprKind kind_it = (MD_ExprKind)0; kind_it < MD_ExprKind_MAX; - kind_it = (MD_ExprKind)((int)kind_it + 1)) + for(MD_C_ExprKind kind_it = (MD_C_ExprKind)0; kind_it < MD_C_ExprKind_MAX; + kind_it = (MD_C_ExprKind)((int)kind_it + 1)) { - _MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); - if(metadata->group == MD_ExprKindGroup_PreUnary) + _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); + if(metadata->group == MD_C_ExprKindGroup_PreUnary) { if(MD_StringMatch(node->string, MD_S8CString(metadata->pre_symbol), 0)) { @@ -140,17 +140,17 @@ MD_PreUnaryExprKindFromNode(MD_Node *node) return kind; } -MD_FUNCTION_IMPL MD_ExprKind -MD_BinaryExprKindFromNode(MD_Node *node) +MD_FUNCTION_IMPL MD_C_ExprKind +MD_C_BinaryExprKindFromNode(MD_Node *node) { - MD_ExprKind kind = MD_ExprKind_Nil; + MD_C_ExprKind kind = MD_C_ExprKind_Nil; if(node->kind == MD_NodeKind_Label && MD_NodeIsNil(node->first_child)) { - for(MD_ExprKind kind_it = (MD_ExprKind)0; kind_it < MD_ExprKind_MAX; - kind_it = (MD_ExprKind)((int)kind_it + 1)) + for(MD_C_ExprKind kind_it = (MD_C_ExprKind)0; kind_it < MD_C_ExprKind_MAX; + kind_it = (MD_C_ExprKind)((int)kind_it + 1)) { - _MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); - if(metadata->group == MD_ExprKindGroup_Binary) + _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); + if(metadata->group == MD_C_ExprKindGroup_Binary) { if(MD_StringMatch(node->string, MD_S8CString(metadata->symbol), 0)) { @@ -163,30 +163,23 @@ MD_BinaryExprKindFromNode(MD_Node *node) return kind; } -MD_FUNCTION_IMPL MD_ExprPrec -MD_ExprPrecFromExprKind(MD_ExprKind kind) +MD_FUNCTION_IMPL MD_C_ExprPrec +MD_C_ExprPrecFromExprKind(MD_C_ExprKind kind) { - _MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind); + _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind); return metadata->prec; } -MD_FUNCTION_IMPL MD_Expr * -MD_MakeExpr(MD_Node *node, MD_ExprKind kind, MD_Expr *left, MD_Expr *right) +MD_FUNCTION_IMPL MD_C_Expr * +MD_C_MakeExpr(MD_Node *node, MD_C_ExprKind kind, MD_C_Expr *left, MD_C_Expr *right) { - MD_Expr *expr = _MD_PushArray(MD_Expr, 1); - if(expr) - { - if(left == 0) left = MD_NilExpr(); - if(right == 0) right = MD_NilExpr(); - expr->node = node; - expr->kind = kind; - expr->sub[0] = left; - expr->sub[1] = right; - } - else - { - expr = MD_NilExpr(); - } + MD_C_Expr *expr = _MD_PushArray(MD_C_Expr, 1); + if(left == 0) left = MD_C_NilExpr(); + if(right == 0) right = MD_C_NilExpr(); + expr->node = node; + expr->kind = kind; + expr->sub[0] = left; + expr->sub[1] = right; return expr; } @@ -271,101 +264,101 @@ _MD_NodeParse_Next(_MD_NodeParseCtx *ctx) ctx->at = ctx->at->next; } -MD_PRIVATE_FUNCTION_IMPL MD_Expr * +MD_PRIVATE_FUNCTION_IMPL MD_C_Expr * _MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in); -MD_PRIVATE_FUNCTION_IMPL MD_Expr * +MD_PRIVATE_FUNCTION_IMPL MD_C_Expr * _MD_ParseExpr(_MD_NodeParseCtx *ctx); -MD_PRIVATE_FUNCTION_IMPL MD_Expr * +MD_PRIVATE_FUNCTION_IMPL MD_C_Expr * _MD_ParseUnaryExpr(_MD_NodeParseCtx *ctx) { - MD_Expr *result = MD_NilExpr(); + MD_C_Expr *result = MD_C_NilExpr(); MD_Node *set = 0; MD_Node *node = 0; // NOTE(rjf): Sub-expression if(_MD_NodeParse_ConsumeSet(ctx, &set)) { - result = MD_ParseAsExpr(set->first_child, set->last_child); + result = MD_C_ParseAsExpr(set->first_child, set->last_child); } // NOTE(rjf): Literal else if(_MD_NodeParse_ConsumeLiteral(ctx, &node)) { - result = MD_MakeExpr(node, MD_ExprKind_Atom, 0, 0); + result = MD_C_MakeExpr(node, MD_C_ExprKind_Atom, 0, 0); } // NOTE(rjf): Literal else if(_MD_NodeParse_ConsumeAtom(ctx, &node)) { - result = MD_MakeExpr(node, MD_ExprKind_Atom, 0, 0); + result = MD_C_MakeExpr(node, MD_C_ExprKind_Atom, 0, 0); } // NOTE(rjf): Negative else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("-"), &node)) { - result = MD_MakeExpr(node, MD_ExprKind_Negative, 0, _MD_ParseExpr(ctx)); + result = MD_C_MakeExpr(node, MD_C_ExprKind_Negative, 0, _MD_ParseExpr(ctx)); } // NOTE(rjf): Bitwise Negate else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("~"), &node)) { - result = MD_MakeExpr(node, MD_ExprKind_BitNot, 0, _MD_ParseExpr(ctx)); + result = MD_C_MakeExpr(node, MD_C_ExprKind_BitNot, 0, _MD_ParseExpr(ctx)); } // NOTE(rjf): Boolean Negate else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("!"), &node)) { - result = MD_MakeExpr(node, MD_ExprKind_BoolNot, 0, _MD_ParseExpr(ctx)); + result = MD_C_MakeExpr(node, MD_C_ExprKind_BoolNot, 0, _MD_ParseExpr(ctx)); } return result; } -MD_PRIVATE_FUNCTION_IMPL MD_Expr * +MD_PRIVATE_FUNCTION_IMPL MD_C_Expr * _MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in) { - MD_Expr *expr = _MD_ParseUnaryExpr(ctx); - MD_ExprKind expr_kind; - if(MD_ExprIsNil(expr)) + MD_C_Expr *expr = _MD_ParseUnaryExpr(ctx); + MD_C_ExprKind expr_kind; + if(MD_C_ExprIsNil(expr)) { goto end_parse; } - expr_kind = MD_BinaryExprKindFromNode(ctx->at); - if(expr_kind != MD_ExprKind_Nil) + expr_kind = MD_C_BinaryExprKindFromNode(ctx->at); + if(expr_kind != MD_C_ExprKind_Nil) { - for(int precedence = MD_ExprPrecFromExprKind(expr_kind); + for(int precedence = MD_C_ExprPrecFromExprKind(expr_kind); precedence >= precedence_in; precedence -= 1) { for(;;) { MD_Node *op_node = ctx->at; - expr_kind = MD_BinaryExprKindFromNode(ctx->at); - int operator_precedence = MD_ExprPrecFromExprKind(expr_kind); + expr_kind = MD_C_BinaryExprKindFromNode(ctx->at); + int operator_precedence = MD_C_ExprPrecFromExprKind(expr_kind); if(operator_precedence != precedence) { break; } - if(expr_kind == MD_ExprKind_Nil) + if(expr_kind == MD_C_ExprKind_Nil) { break; } _MD_NodeParse_Next(ctx); - MD_Expr *right = _MD_ParseExpr_(ctx, precedence+1); - if(MD_ExprIsNil(right)) + MD_C_Expr *right = _MD_ParseExpr_(ctx, precedence+1); + if(MD_C_ExprIsNil(right)) { // TODO(rjf): Error: "Expected right-hand-side of binary expression." goto end_parse; } - MD_Expr *left = expr; - expr = MD_MakeExpr(op_node, expr_kind, left, right); + MD_C_Expr *left = expr; + expr = MD_C_MakeExpr(op_node, expr_kind, left, right); expr->sub[0] = left; expr->sub[1] = right; } @@ -376,28 +369,28 @@ _MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in) return expr; } -MD_PRIVATE_FUNCTION_IMPL MD_Expr * +MD_PRIVATE_FUNCTION_IMPL MD_C_Expr * _MD_ParseExpr(_MD_NodeParseCtx *ctx) { return _MD_ParseExpr_(ctx, 1); } -MD_FUNCTION_IMPL MD_Expr * -MD_ParseAsExpr(MD_Node *first, MD_Node *last) +MD_FUNCTION_IMPL MD_C_Expr * +MD_C_ParseAsExpr(MD_Node *first, MD_Node *last) { _MD_NodeParseCtx ctx_ = { first, last, last->next }; _MD_NodeParseCtx *ctx = &ctx_; return _MD_ParseExpr(ctx); } -MD_FUNCTION_IMPL MD_Expr * -MD_ParseAsType(MD_Node *first, MD_Node *last) +MD_FUNCTION_IMPL MD_C_Expr * +MD_C_ParseAsType(MD_Node *first, MD_Node *last) { - MD_Expr *expr = MD_NilExpr(); - MD_Expr *last_expr = expr; + MD_C_Expr *expr = MD_C_NilExpr(); + MD_C_Expr *last_expr = expr; _MD_NodeParseCtx ctx_ = { first, last, last->next }; _MD_NodeParseCtx *ctx = &ctx_; -#define _MD_PushType(x) if(MD_ExprIsNil(last_expr)) { expr = last_expr = x; } else { last_expr = last_expr->sub[0] = x; } +#define _MD_PushType(x) if(MD_C_ExprIsNil(last_expr)) { expr = last_expr = x; } else { last_expr = last_expr->sub[0] = x; } MD_Node *set = 0; MD_Node *ptr = 0; MD_Node *base_type = 0; @@ -406,28 +399,28 @@ MD_ParseAsType(MD_Node *first, MD_Node *last) { if(_MD_NodeParse_Consume(ctx, MD_S8Lit("*"), &ptr)) { - MD_Expr *t = MD_MakeExpr(ptr, MD_ExprKind_Pointer, MD_NilExpr(), MD_NilExpr()); + MD_C_Expr *t = MD_C_MakeExpr(ptr, MD_C_ExprKind_Pointer, MD_C_NilExpr(), MD_C_NilExpr()); _MD_PushType(t); } else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("volatile"), &node)) { - MD_Expr *t = MD_MakeExpr(node, MD_ExprKind_Volatile, MD_NilExpr(), MD_NilExpr()); + MD_C_Expr *t = MD_C_MakeExpr(node, MD_C_ExprKind_Volatile, MD_C_NilExpr(), MD_C_NilExpr()); _MD_PushType(t); } else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("const"), &node)) { - MD_Expr *t = MD_MakeExpr(node, MD_ExprKind_Const, MD_NilExpr(), MD_NilExpr()); + MD_C_Expr *t = MD_C_MakeExpr(node, MD_C_ExprKind_Const, MD_C_NilExpr(), MD_C_NilExpr()); _MD_PushType(t); } else if(_MD_NodeParse_ConsumeSet(ctx, &set)) { - MD_Expr *t = MD_MakeExpr(set, MD_ExprKind_Array, MD_NilExpr(), MD_NilExpr()); - t->sub[1] = MD_ParseAsExpr(set->first_child, set->last_child); + MD_C_Expr *t = MD_C_MakeExpr(set, MD_C_ExprKind_Array, MD_C_NilExpr(), MD_C_NilExpr()); + t->sub[1] = MD_C_ParseAsExpr(set->first_child, set->last_child); _MD_PushType(t); } else if(_MD_NodeParse_ConsumeAtom(ctx, &base_type)) { - MD_Expr *t = MD_MakeExpr(base_type, MD_ExprKind_Atom, MD_NilExpr(), MD_NilExpr()); + MD_C_Expr *t = MD_C_MakeExpr(base_type, MD_C_ExprKind_Atom, MD_C_NilExpr(), MD_C_NilExpr()); _MD_PushType(t); } else @@ -440,49 +433,49 @@ MD_ParseAsType(MD_Node *first, MD_Node *last) } MD_FUNCTION_IMPL MD_i64 -MD_EvaluateExpr_I64(MD_Expr *expr) +MD_C_EvaluateExpr_I64(MD_C_Expr *expr) { MD_i64 result = 0; switch(expr->kind) { -#define _MD_BinaryOp(name, op) case MD_ExprKind_##name: { result = MD_EvaluateExpr_I64(expr->sub[0]) op MD_EvaluateExpr_I64(expr->sub[1]); }break +#define _MD_BinaryOp(name, op) case MD_C_ExprKind_##name: { result = MD_C_EvaluateExpr_I64(expr->sub[0]) op MD_C_EvaluateExpr_I64(expr->sub[1]); }break _MD_BinaryOp(Add, +); _MD_BinaryOp(Subtract, -); _MD_BinaryOp(Multiply, *); _MD_BinaryOp(Divide, /); #undef _MD_BinaryOp - case MD_ExprKind_Atom: { result = MD_I64FromString(expr->node->string, 10); }break; + case MD_C_ExprKind_Atom: { result = MD_I64FromString(expr->node->string, 10); }break; default: break; } return result; } MD_FUNCTION_IMPL MD_f64 -MD_EvaluateExpr_F64(MD_Expr *expr) +MD_C_EvaluateExpr_F64(MD_C_Expr *expr) { MD_f64 result = 0; switch(expr->kind) { -#define _MD_BinaryOp(name, op) case MD_ExprKind_##name: { result = MD_EvaluateExpr_I64(expr->sub[0]) op MD_EvaluateExpr_F64(expr->sub[1]); }break +#define _MD_BinaryOp(name, op) case MD_C_ExprKind_##name: { result = MD_C_EvaluateExpr_I64(expr->sub[0]) op MD_C_EvaluateExpr_F64(expr->sub[1]); }break _MD_BinaryOp(Add, +); _MD_BinaryOp(Subtract, -); _MD_BinaryOp(Multiply, *); _MD_BinaryOp(Divide, /); #undef _MD_BinaryOp - case MD_ExprKind_Atom: { result = MD_F64FromString(expr->node->string); }break; + case MD_C_ExprKind_Atom: { result = MD_F64FromString(expr->node->string); }break; default: break; } return result; } MD_FUNCTION_IMPL MD_b32 -MD_ExprMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags) +MD_C_ExprMatch(MD_C_Expr *a, MD_C_Expr *b, MD_MatchFlags flags) { MD_b32 result = 0; if(a->kind == b->kind) { result = 1; - if(a->kind == MD_ExprKind_Atom) + if(a->kind == MD_C_ExprKind_Atom) { result = MD_StringMatch(a->node->string, b->node->string, flags); } @@ -491,13 +484,13 @@ MD_ExprMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags) } MD_FUNCTION_IMPL MD_b32 -MD_ExprDeepMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags) +MD_C_ExprDeepMatch(MD_C_Expr *a, MD_C_Expr *b, MD_MatchFlags flags) { - MD_b32 result = MD_ExprMatch(a, b, flags); - if(result && !MD_ExprIsNil(a) && !MD_ExprIsNil(b)) + MD_b32 result = MD_C_ExprMatch(a, b, flags); + if(result && !MD_C_ExprIsNil(a) && !MD_C_ExprIsNil(b)) { - result = (MD_ExprDeepMatch(a->sub[0], b->sub[0], flags) && - MD_ExprDeepMatch(a->sub[1], b->sub[1], flags)); + result = (MD_C_ExprDeepMatch(a->sub[0], b->sub[0], flags) && + MD_C_ExprDeepMatch(a->sub[1], b->sub[1], flags)); } return result; } @@ -546,37 +539,19 @@ MD_C_Generate_Struct(FILE *file, MD_Node *node) } MD_FUNCTION_IMPL void -MD_C_Generate_Decl(FILE *file, MD_Node *node) -{ - if(node) - { - MD_Expr *type = MD_ParseAsType(node->first_child, node->last_child); - MD_C_Generate_DeclByNameAndType(file, node->string, type); - } -} - -MD_FUNCTION_IMPL void -MD_C_Generate_DeclByNameAndType(FILE *file, MD_String8 name, MD_Expr *type) -{ - MD_C_Generate_LHS(file, type); - fprintf(file, " %.*s", MD_StringExpand(name)); - MD_C_Generate_RHS(file, type); -} - -MD_FUNCTION_IMPL void -MD_C_Generate_Expr(FILE *file, MD_Expr *expr) +MD_C_Generate_Expr(FILE *file, MD_C_Expr *expr) { if(!MD_NodeIsNil(expr->node)) { - _MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(expr->kind); + _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(expr->kind); switch(metadata->group) { - case MD_ExprKindGroup_Atom: + case MD_C_ExprKindGroup_Atom: { fprintf(file, "%.*s", MD_StringExpand(expr->node->string)); }break; - case MD_ExprKindGroup_Binary: + case MD_C_ExprKindGroup_Binary: { fprintf(file, "("); MD_C_Generate_Expr(file, expr->sub[0]); @@ -585,7 +560,7 @@ MD_C_Generate_Expr(FILE *file, MD_Expr *expr) fprintf(file, ")"); }break; - case MD_ExprKindGroup_PreUnary: + case MD_C_ExprKindGroup_PreUnary: { fprintf(file, "%s", metadata->pre_symbol); fprintf(file, "("); @@ -593,7 +568,7 @@ MD_C_Generate_Expr(FILE *file, MD_Expr *expr) fprintf(file, ")"); }break; - case MD_ExprKindGroup_PostUnary: + case MD_C_ExprKindGroup_PostUnary: { fprintf(file, "("); MD_C_Generate_Expr(file, expr->sub[0]); @@ -607,11 +582,11 @@ MD_C_Generate_Expr(FILE *file, MD_Expr *expr) } MD_PRIVATE_FUNCTION_IMPL MD_b32 -_MD_OutputType_C_NeedsParens(MD_Expr *type) +_MD_OutputType_C_NeedsParens(MD_C_Expr *type) { MD_b32 result = 0; - if (type->kind == MD_ExprKind_Pointer && - type->sub[0]->kind == MD_ExprKind_Array) + if (type->kind == MD_C_ExprKind_Pointer && + type->sub[0]->kind == MD_C_ExprKind_Array) { result = 1; } @@ -619,19 +594,19 @@ _MD_OutputType_C_NeedsParens(MD_Expr *type) } MD_FUNCTION_IMPL void -MD_C_Generate_LHS(FILE *file, MD_Expr *type) +MD_C_Generate_TypeLHS(FILE *file, MD_C_Expr *type) { switch (type->kind) { - case MD_ExprKind_Atom: + case MD_C_ExprKind_Atom: { MD_Node *node = type->node; fprintf(file, "%.*s", MD_StringExpand(node->whole_string)); }break; - case MD_ExprKind_Pointer: + case MD_C_ExprKind_Pointer: { - MD_C_Generate_LHS(file, type->sub[0]); + MD_C_Generate_TypeLHS(file, type->sub[0]); if (_MD_OutputType_C_NeedsParens(type)) { fprintf(file, "("); @@ -639,21 +614,21 @@ MD_C_Generate_LHS(FILE *file, MD_Expr *type) fprintf(file, "*"); }break; - case MD_ExprKind_Array: + case MD_C_ExprKind_Array: { - MD_C_Generate_LHS(file, type->sub[0]); + MD_C_Generate_TypeLHS(file, type->sub[0]); if (_MD_OutputType_C_NeedsParens(type)) { fprintf(file, "("); } }break; - case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; - case MD_ExprKind_Const: { fprintf(file, "const "); }break; + case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break; + case MD_C_ExprKind_Const: { fprintf(file, "const "); }break; default: { - fprintf(file, "{ unexpected MD_ExprKind (%i) in type info for node \"%.*s\" }", + fprintf(file, "{ unexpected MD_C_ExprKind (%i) in type info for node \"%.*s\" }", type->kind, MD_StringExpand(type->node->whole_string)); }break; @@ -661,23 +636,23 @@ MD_C_Generate_LHS(FILE *file, MD_Expr *type) } MD_FUNCTION_IMPL void -MD_C_Generate_RHS(FILE *file, MD_Expr *type) +MD_C_Generate_TypeRHS(FILE *file, MD_C_Expr *type) { switch (type->kind) { - case MD_ExprKind_Atom: + case MD_C_ExprKind_Atom: {}break; - case MD_ExprKind_Pointer: + case MD_C_ExprKind_Pointer: { if (_MD_OutputType_C_NeedsParens(type)) { fprintf(file, ")"); } - MD_C_Generate_RHS(file, type->sub[0]); + MD_C_Generate_TypeRHS(file, type->sub[0]); }break; - case MD_ExprKind_Array: + case MD_C_ExprKind_Array: { if (_MD_OutputType_C_NeedsParens(type)) { @@ -686,17 +661,35 @@ MD_C_Generate_RHS(FILE *file, MD_Expr *type) fprintf(file, "["); MD_C_Generate_Expr(file, type->sub[1]); fprintf(file, "]"); - MD_C_Generate_RHS(file, type->sub[0]); + MD_C_Generate_TypeRHS(file, type->sub[0]); }break; - case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; - case MD_ExprKind_Const: { fprintf(file, "const "); }break; + case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break; + case MD_C_ExprKind_Const: { fprintf(file, "const "); }break; default: {}break; } } +MD_FUNCTION_IMPL void +MD_C_Generate_DeclByNameAndType(FILE *file, MD_String8 name, MD_C_Expr *type) +{ + MD_C_Generate_TypeLHS(file, type); + fprintf(file, " %.*s", MD_StringExpand(name)); + MD_C_Generate_TypeRHS(file, type); +} + +MD_FUNCTION_IMPL void +MD_C_Generate_Decl(FILE *file, MD_Node *node) +{ + if(node) + { + MD_C_Expr *type = MD_C_ParseAsType(node->first_child, node->last_child); + MD_C_Generate_DeclByNameAndType(file, node->string, type); + } +} + /* Copyright 2021 Dion Systems LLC diff --git a/source/md_c_helpers.h b/source/md_c_helpers.h index 05e11da..2503b98 100644 --- a/source/md_c_helpers.h +++ b/source/md_c_helpers.h @@ -5,109 +5,110 @@ //~ Expression and Type-Expression parser helper types. -typedef enum MD_ExprKind +typedef enum MD_C_ExprKind { // VERY_IMPORTANT_NOTE(rjf): If this enum is ever changed, ensure that // it is kept in-sync with the _MD_MetadataFromExprKind function. - MD_ExprKind_Nil, + MD_C_ExprKind_Nil, // NOTE(rjf): Atom - MD_ExprKind_Atom, + MD_C_ExprKind_Atom, // NOTE(rjf): Access - MD_ExprKind_Dot, - MD_ExprKind_Arrow, - MD_ExprKind_Call, - MD_ExprKind_Subscript, - MD_ExprKind_Dereference, - MD_ExprKind_Reference, + MD_C_ExprKind_Dot, + MD_C_ExprKind_Arrow, + MD_C_ExprKind_Call, + MD_C_ExprKind_Subscript, + MD_C_ExprKind_Dereference, + MD_C_ExprKind_Reference, // NOTE(rjf): Arithmetic - MD_ExprKind_Add, - MD_ExprKind_Subtract, - MD_ExprKind_Multiply, - MD_ExprKind_Divide, - MD_ExprKind_Mod, + MD_C_ExprKind_Add, + MD_C_ExprKind_Subtract, + MD_C_ExprKind_Multiply, + MD_C_ExprKind_Divide, + MD_C_ExprKind_Mod, // NOTE(rjf): Comparison - MD_ExprKind_IsEqual, - MD_ExprKind_IsNotEqual, - MD_ExprKind_LessThan, - MD_ExprKind_GreaterThan, - MD_ExprKind_LessThanEqualTo, - MD_ExprKind_GreaterThanEqualTo, + MD_C_ExprKind_IsEqual, + MD_C_ExprKind_IsNotEqual, + MD_C_ExprKind_LessThan, + MD_C_ExprKind_GreaterThan, + MD_C_ExprKind_LessThanEqualTo, + MD_C_ExprKind_GreaterThanEqualTo, // NOTE(rjf): Bools - MD_ExprKind_BoolAnd, - MD_ExprKind_BoolOr, - MD_ExprKind_BoolNot, - + MD_C_ExprKind_BoolAnd, + MD_C_ExprKind_BoolOr, + MD_C_ExprKind_BoolNot, // NOTE(rjf): Bitwise - MD_ExprKind_BitAnd, - MD_ExprKind_BitOr, - MD_ExprKind_BitNot, - MD_ExprKind_BitXor, - MD_ExprKind_LeftShift, - MD_ExprKind_RightShift, + MD_C_ExprKind_BitAnd, + MD_C_ExprKind_BitOr, + MD_C_ExprKind_BitNot, + MD_C_ExprKind_BitXor, + MD_C_ExprKind_LeftShift, + MD_C_ExprKind_RightShift, // NOTE(rjf): Unary numeric - MD_ExprKind_Negative, + MD_C_ExprKind_Negative, // NOTE(rjf): Type - MD_ExprKind_Pointer, - MD_ExprKind_Array, - MD_ExprKind_Volatile, - MD_ExprKind_Const, + MD_C_ExprKind_Pointer, + MD_C_ExprKind_Array, + MD_C_ExprKind_Volatile, + MD_C_ExprKind_Const, - MD_ExprKind_MAX, + MD_C_ExprKind_MAX, } -MD_ExprKind; +MD_C_ExprKind; -typedef enum MD_ExprKindGroup +typedef enum MD_C_ExprKindGroup { - MD_ExprKindGroup_Nil, - MD_ExprKindGroup_Atom, - MD_ExprKindGroup_Binary, - MD_ExprKindGroup_PreUnary, - MD_ExprKindGroup_PostUnary, - MD_ExprKindGroup_Type, + MD_C_ExprKindGroup_Nil, + MD_C_ExprKindGroup_Atom, + MD_C_ExprKindGroup_Binary, + MD_C_ExprKindGroup_PreUnary, + MD_C_ExprKindGroup_PostUnary, + MD_C_ExprKindGroup_Type, } -MD_ExprKindGroup; +MD_C_ExprKindGroup; -typedef MD_i32 MD_ExprPrec; +typedef MD_i32 MD_C_ExprPrec; -typedef struct MD_Expr MD_Expr; -struct MD_Expr +typedef struct MD_C_Expr MD_C_Expr; +struct MD_C_Expr { MD_Node *node; - MD_ExprKind kind; - MD_Expr *parent; - MD_Expr *sub[2]; + MD_C_ExprKind kind; + MD_C_Expr *parent; + MD_C_Expr *sub[2]; }; -//~ Expression and Type-Expression Helper -MD_FUNCTION MD_Expr * MD_NilExpr(void); -MD_FUNCTION MD_b32 MD_ExprIsNil(MD_Expr *expr); -MD_FUNCTION MD_ExprKind MD_PreUnaryExprKindFromNode(MD_Node *node); -MD_FUNCTION MD_ExprKind MD_BinaryExprKindFromNode(MD_Node *node); -MD_FUNCTION MD_ExprPrec MD_ExprPrecFromExprKind(MD_ExprKind kind); -MD_FUNCTION MD_Expr * MD_MakeExpr(MD_Node *node, MD_ExprKind kind, MD_Expr *left, MD_Expr *right); -MD_FUNCTION MD_Expr * MD_ParseAsExpr(MD_Node *first, MD_Node *last); -MD_FUNCTION MD_Expr * MD_ParseAsType(MD_Node *first, MD_Node *last); -MD_FUNCTION MD_i64 MD_EvaluateExpr_I64(MD_Expr *expr); -MD_FUNCTION MD_f64 MD_EvaluateExpr_F64(MD_Expr *expr); -MD_FUNCTION MD_b32 MD_ExprMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags); -MD_FUNCTION MD_b32 MD_ExprDeepMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags); +//~ C_Expression and Type-C_Expression Helper +MD_FUNCTION MD_C_Expr * MD_C_NilExpr(void); +MD_FUNCTION MD_b32 MD_C_ExprIsNil(MD_C_Expr *expr); +MD_FUNCTION MD_C_ExprKind MD_C_PreUnaryExprKindFromNode(MD_Node *node); +MD_FUNCTION MD_C_ExprKind MD_C_BinaryExprKindFromNode(MD_Node *node); +MD_FUNCTION MD_C_ExprPrec MD_C_ExprPrecFromExprKind(MD_C_ExprKind kind); +MD_FUNCTION MD_C_Expr * MD_C_MakeExpr(MD_Node *node, MD_C_ExprKind kind, MD_C_Expr *left, MD_C_Expr *right); +MD_FUNCTION MD_C_Expr * MD_C_ParseAsExpr(MD_Node *first, MD_Node *last); +MD_FUNCTION MD_C_Expr * MD_C_ParseAsType(MD_Node *first, MD_Node *last); +MD_FUNCTION MD_i64 MD_C_EvaluateExpr_I64(MD_C_Expr *expr); +MD_FUNCTION MD_f64 MD_C_EvaluateExpr_F64(MD_C_Expr *expr); +MD_FUNCTION MD_b32 MD_C_ExprMatch(MD_C_Expr *a, MD_C_Expr *b, MD_MatchFlags flags); +MD_FUNCTION MD_b32 MD_C_ExprDeepMatch(MD_C_Expr *a, MD_C_Expr *b, MD_MatchFlags flags); //~ C Language Generation MD_FUNCTION void MD_C_Generate_String(FILE *file, MD_Node *node); MD_FUNCTION void MD_C_Generate_Struct(FILE *file, MD_Node *node); + +MD_FUNCTION void MD_C_Generate_Expr(FILE *file, MD_C_Expr *expr); +MD_FUNCTION void MD_C_Generate_TypeLHS(FILE *file, MD_C_Expr *type); +MD_FUNCTION void MD_C_Generate_TypeRHS(FILE *file, MD_C_Expr *type); + +MD_FUNCTION void MD_C_Generate_DeclByNameAndType(FILE *file, MD_String8 name, MD_C_Expr *type); MD_FUNCTION void MD_C_Generate_Decl(FILE *file, MD_Node *node); -MD_FUNCTION void MD_C_Generate_DeclByNameAndType(FILE *file, MD_String8 name, MD_Expr *type); -MD_FUNCTION void MD_C_Generate_Expr(FILE *file, MD_Expr *expr); -MD_FUNCTION void MD_C_Generate_LHS(FILE *file, MD_Expr *type); -MD_FUNCTION void MD_C_Generate_RHS(FILE *file, MD_Expr *type); #endif //MD_C_HELPERS_H diff --git a/tests/sanity_tests.c b/tests/sanity_tests.c index 8ff5bdc..fe4c648 100644 --- a/tests/sanity_tests.c +++ b/tests/sanity_tests.c @@ -61,22 +61,23 @@ MakeTestNode(MD_NodeKind kind, MD_String8 string) return MD_MakeNodeFromString(kind, MD_S8Lit("`TEST_NODE`"), 0, 0, string); } -static MD_Expr * +static MD_C_Expr * AtomExpr(char *str) { - return MD_MakeExpr(MakeTestNode(MD_NodeKind_Label, MD_S8CString(str)), MD_ExprKind_Atom, MD_NilExpr(), MD_NilExpr()); + return MD_C_MakeExpr(MakeTestNode(MD_NodeKind_Label, MD_S8CString(str)), + MD_C_ExprKind_Atom, MD_C_NilExpr(), MD_C_NilExpr()); } -static MD_Expr * -BinOpExpr(MD_ExprKind kind, MD_Expr *left, MD_Expr *right) +static MD_C_Expr * +BinOpExpr(MD_C_ExprKind kind, MD_C_Expr *left, MD_C_Expr *right) { - return MD_MakeExpr(MD_NilNode(), kind, left, right); + return MD_C_MakeExpr(MD_NilNode(), kind, left, right); } -static MD_Expr * -TypeExpr(MD_ExprKind kind, MD_Expr *sub) +static MD_C_Expr * +TypeExpr(MD_C_ExprKind kind, MD_C_Expr *sub) { - return MD_MakeExpr(MD_NilNode(), kind, sub, MD_NilExpr()); + return MD_C_MakeExpr(MD_NilNode(), kind, sub, MD_C_NilExpr()); } static MD_b32 @@ -87,19 +88,19 @@ MatchParsedWithNode(MD_String8 string, MD_Node *tree) } static MD_b32 -MatchParsedWithExpr(MD_String8 string, MD_Expr *expr) +MatchParsedWithExpr(MD_String8 string, MD_C_Expr *expr) { MD_ParseResult parse = MD_ParseOneNode(MD_S8Lit(""), string); - MD_Expr *parse_expr = MD_ParseAsExpr(parse.node->first_child, parse.node->last_child); - return MD_ExprDeepMatch(expr, parse_expr, 0); + MD_C_Expr *parse_expr = MD_C_ParseAsExpr(parse.node->first_child, parse.node->last_child); + return MD_C_ExprDeepMatch(expr, parse_expr, 0); } static MD_b32 -MatchParsedWithType(MD_String8 string, MD_Expr *expr) +MatchParsedWithType(MD_String8 string, MD_C_Expr *expr) { MD_ParseResult parse = MD_ParseOneNode(MD_S8Lit(""), string); - MD_Expr *parse_expr = MD_ParseAsType(parse.node->first_child, parse.node->last_child); - return MD_ExprDeepMatch(expr, parse_expr, 0); + MD_C_Expr *parse_expr = MD_C_ParseAsType(parse.node->first_child, parse.node->last_child); + return MD_C_ExprDeepMatch(expr, parse_expr, 0); } static MD_b32 @@ -286,34 +287,34 @@ int main(void) { // NOTE(rjf): 5 + 3 { - MD_Expr *expr = BinOpExpr(MD_ExprKind_Add, AtomExpr("5"), AtomExpr("3")); - TestResult(MD_EvaluateExpr_I64(expr) == 8); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("5"), AtomExpr("3")); + TestResult(MD_C_EvaluateExpr_I64(expr) == 8); } // NOTE(rjf): 5 - 3 { - MD_Expr *expr = BinOpExpr(MD_ExprKind_Subtract, AtomExpr("5"), AtomExpr("3")); - TestResult(MD_EvaluateExpr_I64(expr) == 2); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Subtract, AtomExpr("5"), AtomExpr("3")); + TestResult(MD_C_EvaluateExpr_I64(expr) == 2); } // NOTE(rjf): 5 * 3 { - MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, AtomExpr("5"), AtomExpr("3")); - TestResult(MD_EvaluateExpr_I64(expr) == 15); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, AtomExpr("5"), AtomExpr("3")); + TestResult(MD_C_EvaluateExpr_I64(expr) == 15); } // NOTE(rjf): 10 / 2 { - MD_Expr *expr = BinOpExpr(MD_ExprKind_Divide, AtomExpr("10"), AtomExpr("2")); - TestResult(MD_EvaluateExpr_I64(expr) == 5); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Divide, AtomExpr("10"), AtomExpr("2")); + TestResult(MD_C_EvaluateExpr_I64(expr) == 5); } // NOTE(rjf): (3 + 4) * (2 + 6) { - MD_Expr *left = BinOpExpr(MD_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); - MD_Expr *right = BinOpExpr(MD_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); - MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, left, right); - TestResult(MD_EvaluateExpr_I64(expr) == 56); + MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); + MD_C_Expr *right = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, left, right); + TestResult(MD_C_EvaluateExpr_I64(expr) == 56); } } @@ -321,20 +322,20 @@ int main(void) { { MD_String8 string = MD_S8Lit("(1 + 2)"); - MD_Expr *expr = BinOpExpr(MD_ExprKind_Add, AtomExpr("1"), AtomExpr("2")); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("1"), AtomExpr("2")); TestResult(MatchParsedWithExpr(string, expr)); } { MD_String8 string = MD_S8Lit("((3 + 4) * (2 + 6))"); - MD_Expr *left = BinOpExpr(MD_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); - MD_Expr *right = BinOpExpr(MD_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); - MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, left, right); + MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); + MD_C_Expr *right = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, left, right); TestResult(MatchParsedWithExpr(string, expr)); } { MD_String8 string = MD_S8Lit("(1*2+3)"); - MD_Expr *left = BinOpExpr(MD_ExprKind_Multiply, AtomExpr("1"), AtomExpr("2")); - MD_Expr *expr = BinOpExpr(MD_ExprKind_Add, left, AtomExpr("3")); + MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Multiply, AtomExpr("1"), AtomExpr("2")); + MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Add, left, AtomExpr("3")); TestResult(MatchParsedWithExpr(string, expr)); } } @@ -343,22 +344,22 @@ int main(void) { { MD_String8 string = MD_S8Lit("(i32)"); - MD_Expr *expr = AtomExpr("i32"); + MD_C_Expr *expr = AtomExpr("i32"); TestResult(MatchParsedWithType(string, expr)); } { MD_String8 string = MD_S8Lit("(*i32)"); - MD_Expr *expr = TypeExpr(MD_ExprKind_Pointer, AtomExpr("i32")); + MD_C_Expr *expr = TypeExpr(MD_C_ExprKind_Pointer, AtomExpr("i32")); TestResult(MatchParsedWithType(string, expr)); } { MD_String8 string = MD_S8Lit("(**i32)"); - MD_Expr *expr = TypeExpr(MD_ExprKind_Pointer, TypeExpr(MD_ExprKind_Pointer, AtomExpr("i32"))); + MD_C_Expr *expr = TypeExpr(MD_C_ExprKind_Pointer, TypeExpr(MD_C_ExprKind_Pointer, AtomExpr("i32"))); TestResult(MatchParsedWithType(string, expr)); } { MD_String8 string = MD_S8Lit("(*void)"); - MD_Expr *expr = TypeExpr(MD_ExprKind_Pointer, AtomExpr("void")); + MD_C_Expr *expr = TypeExpr(MD_C_ExprKind_Pointer, AtomExpr("void")); TestResult(MatchParsedWithType(string, expr)); } }