ed/metadesk
1
0
Fork 0
mirror of https://github.com/Ed94/metadesk.git synced 2026-07-31 20:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename C helper types; cleanup pass over everything related to C helpers

Browse Source
This commit is contained in:
Allen Webster
2021-04-16 19:24:17 -07:00
parent 366eebca00
commit f52362ef2c
5 changed files with 401 additions and 400 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/metadesk_reference.md
+114 -109
View File
@@ -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),
};
samples/namespaced_types/namespaced_types.c
+9 -8
View File
@@ -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");
}
source/md_c_helpers.c
+172 -179
View File
@@ -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
source/md_c_helpers.h
+69 -68
View File
@@ -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
tests/sanity_tests.c
+37 -36
View File
@@ -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));
}
}