ed/metadesk
1
0
Fork 0
mirror of https://github.com/Ed94/metadesk.git synced 2026-08-07 16:18:49 +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; 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. //~ Command line parsing helper types.
@@ -1330,81 +1258,81 @@ main:
//~ Expression and Type-Expression Helper //~ Expression and Type-Expression Helper
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_NilExpr: { @func MD_C_NilExpr: {
return: *MD_Expr, return: *MD_C_Expr,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ExprIsNil: { @func MD_C_ExprIsNil: {
expr: *MD_Expr, expr: *MD_C_Expr,
return: MD_b32, return: MD_b32,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_PreUnaryExprKindFromNode: { @func MD_C_PreUnaryExprKindFromNode: {
node: *MD_Node, node: *MD_Node,
return: MD_ExprKind, return: MD_ExprKind,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_BinaryExprKindFromNode: { @func MD_C_BinaryExprKindFromNode: {
node: *MD_Node, node: *MD_Node,
return: MD_ExprKind, return: MD_ExprKind,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ExprPrecFromExprKind: { @func MD_C_ExprPrecFromExprKind: {
kind: MD_ExprKind, kind: MD_ExprKind,
return: MD_ExprPrec, return: MD_ExprPrec,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_MakeExpr: { @func MD_C_MakeExpr: {
node: *MD_Node, node: *MD_Node,
kind: MD_ExprKind, kind: MD_ExprKind,
left: *MD_Expr, left: *MD_C_Expr,
right: *MD_Expr, right: *MD_C_Expr,
return: *MD_Expr, return: *MD_C_Expr,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ParseAsExpr: { @func MD_C_ParseAsExpr: {
first: *MD_Node, first: *MD_Node,
last: *MD_Node, last: *MD_Node,
return: *MD_Expr, return: *MD_C_Expr,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ParseAsType: { @func MD_C_ParseAsType: {
first: *MD_Node, first: *MD_Node,
last: *MD_Node, last: *MD_Node,
return: *MD_Expr, return: *MD_C_Expr,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_EvaluateExpr_I64: { @func MD_C_EvaluateExpr_I64: {
expr: *MD_Expr, expr: *MD_C_Expr,
return: MD_i64, return: MD_i64,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_EvaluateExpr_F64: { @func MD_C_EvaluateExpr_F64: {
expr: *MD_Expr, expr: *MD_C_Expr,
return: MD_f64, return: MD_f64,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ExprMatch: { @func MD_C_ExprMatch: {
a: *MD_Expr, a: *MD_C_Expr,
b: *MD_Expr, b: *MD_C_Expr,
str_flags: MD_StringMatchFlags, str_flags: MD_StringMatchFlags,
return: MD_b32, return: MD_b32,
}; };
@send(ExpressionParsingHelper) @send(ExpressionParsingHelper)
@func MD_ExprDeepMatch: { @func MD_C_ExprDeepMatch: {
a: *MD_Expr, a: *MD_C_Expr,
b: *MD_Expr, b: *MD_C_Expr,
str_flags: MD_StringMatchFlags, str_flags: MD_StringMatchFlags,
return: MD_b32, return: MD_b32,
}; };
@@ -1443,31 +1371,25 @@ main:
@func MD_C_Generate_DeclByNameAndType: { @func MD_C_Generate_DeclByNameAndType: {
file: *FILE, file: *FILE,
name: MD_String8, name: MD_String8,
type: *MD_Expr, type: *MD_C_Expr,
}; };
@send(Output) @send(Output)
@func MD_C_Generate_Expr: { @func MD_C_Generate_Expr: {
file: *FILE, file: *FILE,
expr: *MD_Expr, expr: *MD_C_Expr,
}; };
@send(Output) @send(Output)
@func MD_OutputType: { @func MD_C_Generate_TypeLHS: {
file: *FILE, file: *FILE,
type: *MD_Expr, type: *MD_C_Expr,
}; };
@send(Output) @send(Output)
@func MD_OutputType_C_LHS: { @func MD_C_Generate_TypeRHS: {
file: *FILE, file: *FILE,
type: *MD_Expr, type: *MD_C_Expr,
};
@send(Output)
@func MD_OutputType_C_RHS: {
file: *FILE,
type: *MD_Expr,
}; };
//////////////////////////////// ////////////////////////////////
@@ -1544,3 +1466,86 @@ main:
out_info: *MD_FileInfo, out_info: *MD_FileInfo,
return: MD_b32, 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; 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) switch (type->kind)
{ {
case MD_ExprKind_Atom: case MD_C_ExprKind_Atom:
{ {
MD_Node *node = type->node; 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)); fprintf(file, "%.*s", MD_StringExpand(node->whole_string));
}break; }break;
case MD_ExprKind_Pointer: case MD_C_ExprKind_Pointer:
{ {
OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]); OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]);
if (_MD_OutputType_C_NeedsParens(type)) 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, "*"); fprintf(file, "*");
}break; }break;
case MD_ExprKind_Array: case MD_C_ExprKind_Array:
{ {
OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]); OutputType_C_LHS_Namespace(file, user_defined_types, prefix, type->sub[0]);
if (_MD_OutputType_C_NeedsParens(type)) 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; }break;
case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break;
case MD_ExprKind_Const: { fprintf(file, "const "); }break; case MD_C_ExprKind_Const: { fprintf(file, "const "); }break;
default: default:
{ {
@@ -132,12 +133,12 @@ static void OutputPrefixedType(FILE *f, MD_Map *user_defined_types, MD_String8 p
} }
else 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(); I();
OutputType_C_LHS_Namespace(f, user_defined_types, prefix, type); OutputType_C_LHS_Namespace(f, user_defined_types, prefix, type);
fprintf(f, " %.*s", MD_StringExpand(node->string)); fprintf(f, " %.*s", MD_StringExpand(node->string));
MD_C_Generate_RHS(f, type); MD_C_Generate_TypeRHS(f, type);
fprintf(f, ";\n"); fprintf(f, ";\n");
} }
source/md_c_helpers.c
+172 -179
View File
@@ -1,37 +1,37 @@
//~ Expression and Type-Expression Helper //~ Expression and Type-Expression Helper
MD_GLOBAL MD_Expr _md_nil_expr = MD_GLOBAL MD_C_Expr _md_nil_expr =
{ {
&_md_nil_node, &_md_nil_node,
MD_ExprKind_Nil, MD_C_ExprKind_Nil,
&_md_nil_expr, &_md_nil_expr,
{&_md_nil_expr, &_md_nil_expr }, {&_md_nil_expr, &_md_nil_expr },
}; };
MD_FUNCTION_IMPL MD_Expr * MD_FUNCTION_IMPL MD_C_Expr *
MD_NilExpr(void) MD_C_NilExpr(void)
{ {
return &_md_nil_expr; return &_md_nil_expr;
} }
MD_FUNCTION_IMPL MD_b32 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; typedef struct _MD_C_ExprKindMetadata _MD_C_ExprKindMetadata;
struct _MD_ExprKindMetadata struct _MD_C_ExprKindMetadata
{ {
MD_ExprKindGroup group; MD_C_ExprKindGroup group;
MD_ExprPrec prec; MD_C_ExprPrec prec;
char *symbol; char *symbol;
char *pre_symbol; char *pre_symbol;
char *post_symbol; char *post_symbol;
}; };
MD_FUNCTION_IMPL _MD_ExprKindMetadata * MD_FUNCTION_IMPL _MD_C_ExprKindMetadata *
_MD_MetadataFromExprKind(MD_ExprKind kind) _MD_MetadataFromExprKind(MD_C_ExprKind kind)
{ {
// 0: Invalid // 0: Invalid
// 12: (unary) - ~ ! // 12: (unary) - ~ !
@@ -46,88 +46,88 @@ _MD_MetadataFromExprKind(MD_ExprKind kind)
// 3: | // 3: |
// 2: && // 2: &&
// 1: || // 1: ||
static _MD_ExprKindMetadata metadata[] = static _MD_C_ExprKindMetadata metadata[] =
{ {
{MD_ExprKindGroup_Nil, +0, "NIL", "", "" }, // MD_ExprKind_Nil {MD_C_ExprKindGroup_Nil, +0, "NIL", "", "" }, // MD_C_ExprKind_Nil
{MD_ExprKindGroup_Atom, +0, "NIL", "", "" }, // MD_ExprKind_Atom {MD_C_ExprKindGroup_Atom, +0, "NIL", "", "" }, // MD_C_ExprKind_Atom
{MD_ExprKindGroup_Binary, +11, ".", "", "" }, // MD_ExprKind_Dot {MD_C_ExprKindGroup_Binary, +11, ".", "", "" }, // MD_C_ExprKind_Dot
{MD_ExprKindGroup_Binary, +11, "->", "", "" }, // MD_ExprKind_Arrow {MD_C_ExprKindGroup_Binary, +11, "->", "", "" }, // MD_C_ExprKind_Arrow
{MD_ExprKindGroup_PostUnary, +11, "", "(", ")"}, // MD_ExprKind_Call {MD_C_ExprKindGroup_PostUnary, +11, "", "(", ")"}, // MD_C_ExprKind_Call
{MD_ExprKindGroup_PostUnary, +11, "", "[", "]"}, // MD_ExprKind_Subscript {MD_C_ExprKindGroup_PostUnary, +11, "", "[", "]"}, // MD_C_ExprKind_Subscript
{MD_ExprKindGroup_PreUnary, +12, "", "*", "" }, // MD_ExprKind_Dereference {MD_C_ExprKindGroup_PreUnary, +12, "", "*", "" }, // MD_C_ExprKind_Dereference
{MD_ExprKindGroup_PreUnary, +12, "", "&", "" }, // MD_ExprKind_Reference {MD_C_ExprKindGroup_PreUnary, +12, "", "&", "" }, // MD_C_ExprKind_Reference
{MD_ExprKindGroup_Binary, +9, "+", "", "" }, // MD_ExprKind_Add {MD_C_ExprKindGroup_Binary, +9, "+", "", "" }, // MD_C_ExprKind_Add
{MD_ExprKindGroup_Binary, +9, "-", "", "" }, // MD_ExprKind_Subtract {MD_C_ExprKindGroup_Binary, +9, "-", "", "" }, // MD_C_ExprKind_Subtract
{MD_ExprKindGroup_Binary, +10, "*", "", "" }, // MD_ExprKind_Multiply {MD_C_ExprKindGroup_Binary, +10, "*", "", "" }, // MD_C_ExprKind_Multiply
{MD_ExprKindGroup_Binary, +10, "/", "", "" }, // MD_ExprKind_Divide {MD_C_ExprKindGroup_Binary, +10, "/", "", "" }, // MD_C_ExprKind_Divide
{MD_ExprKindGroup_Binary, +10, "%", "", "" }, // MD_ExprKind_Mod {MD_C_ExprKindGroup_Binary, +10, "%", "", "" }, // MD_C_ExprKind_Mod
{MD_ExprKindGroup_Binary, +6, "==", "", "" }, // MD_ExprKind_IsEqual {MD_C_ExprKindGroup_Binary, +6, "==", "", "" }, // MD_C_ExprKind_IsEqual
{MD_ExprKindGroup_Binary, +6, "!=", "", "" }, // MD_ExprKind_IsNotEqual {MD_C_ExprKindGroup_Binary, +6, "!=", "", "" }, // MD_C_ExprKind_IsNotEqual
{MD_ExprKindGroup_Binary, +7, "<", "", "" }, // MD_ExprKind_LessThan {MD_C_ExprKindGroup_Binary, +7, "<", "", "" }, // MD_C_ExprKind_LessThan
{MD_ExprKindGroup_Binary, +7, ">", "", "" }, // MD_ExprKind_GreaterThan {MD_C_ExprKindGroup_Binary, +7, ">", "", "" }, // MD_C_ExprKind_GreaterThan
{MD_ExprKindGroup_Binary, +7, "<=", "", "" }, // MD_ExprKind_LessThanEqualTo {MD_C_ExprKindGroup_Binary, +7, "<=", "", "" }, // MD_C_ExprKind_LessThanEqualTo
{MD_ExprKindGroup_Binary, +7, ">=", "", "" }, // MD_ExprKind_GreaterThanEqualTo {MD_C_ExprKindGroup_Binary, +7, ">=", "", "" }, // MD_C_ExprKind_GreaterThanEqualTo
{MD_ExprKindGroup_Binary, +2, "&&", "", "" }, // MD_ExprKind_BoolAnd {MD_C_ExprKindGroup_Binary, +2, "&&", "", "" }, // MD_C_ExprKind_BoolAnd
{MD_ExprKindGroup_Binary, +1, "||", "", "" }, // MD_ExprKind_BoolOr {MD_C_ExprKindGroup_Binary, +1, "||", "", "" }, // MD_C_ExprKind_BoolOr
{MD_ExprKindGroup_PreUnary, +12, "", "!", "" }, // MD_ExprKind_BoolNot {MD_C_ExprKindGroup_PreUnary, +12, "", "!", "" }, // MD_C_ExprKind_BoolNot
{MD_ExprKindGroup_Binary, +5, "&", "", "" }, // MD_ExprKind_BitAnd {MD_C_ExprKindGroup_Binary, +5, "&", "", "" }, // MD_C_ExprKind_BitAnd
{MD_ExprKindGroup_Binary, +3, "|", "", "" }, // MD_ExprKind_BitOr {MD_C_ExprKindGroup_Binary, +3, "|", "", "" }, // MD_C_ExprKind_BitOr
{MD_ExprKindGroup_PreUnary, +12, "", "~", "" }, // MD_ExprKind_BitNot {MD_C_ExprKindGroup_PreUnary, +12, "", "~", "" }, // MD_C_ExprKind_BitNot
{MD_ExprKindGroup_Binary, +4, "^", "", "" }, // MD_ExprKind_BitXor {MD_C_ExprKindGroup_Binary, +4, "^", "", "" }, // MD_C_ExprKind_BitXor
{MD_ExprKindGroup_Binary, +8, "<<", "", "" }, // MD_ExprKind_LeftShift {MD_C_ExprKindGroup_Binary, +8, "<<", "", "" }, // MD_C_ExprKind_LeftShift
{MD_ExprKindGroup_Binary, +8, ">>", "", "" }, // MD_ExprKind_RightShift {MD_C_ExprKindGroup_Binary, +8, ">>", "", "" }, // MD_C_ExprKind_RightShift
{MD_ExprKindGroup_PreUnary, +12, "", "-", "" }, // MD_ExprKind_Negative {MD_C_ExprKindGroup_PreUnary, +12, "", "-", "" }, // MD_C_ExprKind_Negative
{MD_ExprKindGroup_Type, +0, "*", "", "" }, // MD_ExprKind_Pointer {MD_C_ExprKindGroup_Type, +0, "*", "", "" }, // MD_C_ExprKind_Pointer
{MD_ExprKindGroup_Type, +0, "", "[", "]"}, // MD_ExprKind_Array {MD_C_ExprKindGroup_Type, +0, "", "[", "]"}, // MD_C_ExprKind_Array
}; };
return &metadata[kind]; return &metadata[kind];
} }
MD_FUNCTION_IMPL MD_ExprKind MD_FUNCTION_IMPL MD_C_ExprKind
MD_PostUnaryExprKindFromNode(MD_Node *node) 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(!MD_NodeIsNil(node->first_child))
{ {
if(node->flags & MD_NodeFlag_ParenLeft && if(node->flags & MD_NodeFlag_ParenLeft &&
node->flags & MD_NodeFlag_ParenRight) node->flags & MD_NodeFlag_ParenRight)
{ {
kind = MD_ExprKind_Call; kind = MD_C_ExprKind_Call;
} }
else if(node->flags & MD_NodeFlag_BracketLeft && else if(node->flags & MD_NodeFlag_BracketLeft &&
node->flags & MD_NodeFlag_BracketRight) node->flags & MD_NodeFlag_BracketRight)
{ {
kind = MD_ExprKind_Subscript; kind = MD_C_ExprKind_Subscript;
} }
} }
return kind; return kind;
} }
MD_FUNCTION_IMPL MD_ExprKind MD_FUNCTION_IMPL MD_C_ExprKind
MD_PreUnaryExprKindFromNode(MD_Node *node) 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. // NOTE(rjf): Special-cases for calls/subscripts.
if(!MD_NodeIsNil(node->first_child)) if(!MD_NodeIsNil(node->first_child))
{ {
if(node->flags & MD_NodeFlag_ParenLeft && if(node->flags & MD_NodeFlag_ParenLeft &&
node->flags & MD_NodeFlag_ParenRight) node->flags & MD_NodeFlag_ParenRight)
{ {
kind = MD_ExprKind_Call; kind = MD_C_ExprKind_Call;
} }
else if(node->flags & MD_NodeFlag_BracketLeft && else if(node->flags & MD_NodeFlag_BracketLeft &&
node->flags & MD_NodeFlag_BracketRight) node->flags & MD_NodeFlag_BracketRight)
{ {
kind = MD_ExprKind_Subscript; kind = MD_C_ExprKind_Subscript;
} }
} }
else else
{ {
for(MD_ExprKind kind_it = (MD_ExprKind)0; kind_it < MD_ExprKind_MAX; for(MD_C_ExprKind kind_it = (MD_C_ExprKind)0; kind_it < MD_C_ExprKind_MAX;
kind_it = (MD_ExprKind)((int)kind_it + 1)) kind_it = (MD_C_ExprKind)((int)kind_it + 1))
{ {
_MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it);
if(metadata->group == MD_ExprKindGroup_PreUnary) if(metadata->group == MD_C_ExprKindGroup_PreUnary)
{ {
if(MD_StringMatch(node->string, MD_S8CString(metadata->pre_symbol), 0)) if(MD_StringMatch(node->string, MD_S8CString(metadata->pre_symbol), 0))
{ {
@@ -140,17 +140,17 @@ MD_PreUnaryExprKindFromNode(MD_Node *node)
return kind; return kind;
} }
MD_FUNCTION_IMPL MD_ExprKind MD_FUNCTION_IMPL MD_C_ExprKind
MD_BinaryExprKindFromNode(MD_Node *node) 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)) if(node->kind == MD_NodeKind_Label && MD_NodeIsNil(node->first_child))
{ {
for(MD_ExprKind kind_it = (MD_ExprKind)0; kind_it < MD_ExprKind_MAX; for(MD_C_ExprKind kind_it = (MD_C_ExprKind)0; kind_it < MD_C_ExprKind_MAX;
kind_it = (MD_ExprKind)((int)kind_it + 1)) kind_it = (MD_C_ExprKind)((int)kind_it + 1))
{ {
_MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it); _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind_it);
if(metadata->group == MD_ExprKindGroup_Binary) if(metadata->group == MD_C_ExprKindGroup_Binary)
{ {
if(MD_StringMatch(node->string, MD_S8CString(metadata->symbol), 0)) if(MD_StringMatch(node->string, MD_S8CString(metadata->symbol), 0))
{ {
@@ -163,30 +163,23 @@ MD_BinaryExprKindFromNode(MD_Node *node)
return kind; return kind;
} }
MD_FUNCTION_IMPL MD_ExprPrec MD_FUNCTION_IMPL MD_C_ExprPrec
MD_ExprPrecFromExprKind(MD_ExprKind kind) MD_C_ExprPrecFromExprKind(MD_C_ExprKind kind)
{ {
_MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind); _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(kind);
return metadata->prec; return metadata->prec;
} }
MD_FUNCTION_IMPL MD_Expr * MD_FUNCTION_IMPL MD_C_Expr *
MD_MakeExpr(MD_Node *node, MD_ExprKind kind, MD_Expr *left, MD_Expr *right) 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); MD_C_Expr *expr = _MD_PushArray(MD_C_Expr, 1);
if(expr) if(left == 0) left = MD_C_NilExpr();
{ if(right == 0) right = MD_C_NilExpr();
if(left == 0) left = MD_NilExpr(); expr->node = node;
if(right == 0) right = MD_NilExpr(); expr->kind = kind;
expr->node = node; expr->sub[0] = left;
expr->kind = kind; expr->sub[1] = right;
expr->sub[0] = left;
expr->sub[1] = right;
}
else
{
expr = MD_NilExpr();
}
return expr; return expr;
} }
@@ -271,101 +264,101 @@ _MD_NodeParse_Next(_MD_NodeParseCtx *ctx)
ctx->at = ctx->at->next; 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_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_ParseExpr(_MD_NodeParseCtx *ctx);
MD_PRIVATE_FUNCTION_IMPL MD_Expr * MD_PRIVATE_FUNCTION_IMPL MD_C_Expr *
_MD_ParseUnaryExpr(_MD_NodeParseCtx *ctx) _MD_ParseUnaryExpr(_MD_NodeParseCtx *ctx)
{ {
MD_Expr *result = MD_NilExpr(); MD_C_Expr *result = MD_C_NilExpr();
MD_Node *set = 0; MD_Node *set = 0;
MD_Node *node = 0; MD_Node *node = 0;
// NOTE(rjf): Sub-expression // NOTE(rjf): Sub-expression
if(_MD_NodeParse_ConsumeSet(ctx, &set)) 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 // NOTE(rjf): Literal
else if(_MD_NodeParse_ConsumeLiteral(ctx, &node)) 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 // NOTE(rjf): Literal
else if(_MD_NodeParse_ConsumeAtom(ctx, &node)) 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 // NOTE(rjf): Negative
else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("-"), &node)) 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 // NOTE(rjf): Bitwise Negate
else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("~"), &node)) 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 // NOTE(rjf): Boolean Negate
else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("!"), &node)) 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; return result;
} }
MD_PRIVATE_FUNCTION_IMPL MD_Expr * MD_PRIVATE_FUNCTION_IMPL MD_C_Expr *
_MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in) _MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in)
{ {
MD_Expr *expr = _MD_ParseUnaryExpr(ctx); MD_C_Expr *expr = _MD_ParseUnaryExpr(ctx);
MD_ExprKind expr_kind; MD_C_ExprKind expr_kind;
if(MD_ExprIsNil(expr)) if(MD_C_ExprIsNil(expr))
{ {
goto end_parse; goto end_parse;
} }
expr_kind = MD_BinaryExprKindFromNode(ctx->at); expr_kind = MD_C_BinaryExprKindFromNode(ctx->at);
if(expr_kind != MD_ExprKind_Nil) 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 >= precedence_in;
precedence -= 1) precedence -= 1)
{ {
for(;;) for(;;)
{ {
MD_Node *op_node = ctx->at; MD_Node *op_node = ctx->at;
expr_kind = MD_BinaryExprKindFromNode(ctx->at); expr_kind = MD_C_BinaryExprKindFromNode(ctx->at);
int operator_precedence = MD_ExprPrecFromExprKind(expr_kind); int operator_precedence = MD_C_ExprPrecFromExprKind(expr_kind);
if(operator_precedence != precedence) if(operator_precedence != precedence)
{ {
break; break;
} }
if(expr_kind == MD_ExprKind_Nil) if(expr_kind == MD_C_ExprKind_Nil)
{ {
break; break;
} }
_MD_NodeParse_Next(ctx); _MD_NodeParse_Next(ctx);
MD_Expr *right = _MD_ParseExpr_(ctx, precedence+1); MD_C_Expr *right = _MD_ParseExpr_(ctx, precedence+1);
if(MD_ExprIsNil(right)) if(MD_C_ExprIsNil(right))
{ {
// TODO(rjf): Error: "Expected right-hand-side of binary expression." // TODO(rjf): Error: "Expected right-hand-side of binary expression."
goto end_parse; goto end_parse;
} }
MD_Expr *left = expr; MD_C_Expr *left = expr;
expr = MD_MakeExpr(op_node, expr_kind, left, right); expr = MD_C_MakeExpr(op_node, expr_kind, left, right);
expr->sub[0] = left; expr->sub[0] = left;
expr->sub[1] = right; expr->sub[1] = right;
} }
@@ -376,28 +369,28 @@ _MD_ParseExpr_(_MD_NodeParseCtx *ctx, int precedence_in)
return expr; return expr;
} }
MD_PRIVATE_FUNCTION_IMPL MD_Expr * MD_PRIVATE_FUNCTION_IMPL MD_C_Expr *
_MD_ParseExpr(_MD_NodeParseCtx *ctx) _MD_ParseExpr(_MD_NodeParseCtx *ctx)
{ {
return _MD_ParseExpr_(ctx, 1); return _MD_ParseExpr_(ctx, 1);
} }
MD_FUNCTION_IMPL MD_Expr * MD_FUNCTION_IMPL MD_C_Expr *
MD_ParseAsExpr(MD_Node *first, MD_Node *last) MD_C_ParseAsExpr(MD_Node *first, MD_Node *last)
{ {
_MD_NodeParseCtx ctx_ = { first, last, last->next }; _MD_NodeParseCtx ctx_ = { first, last, last->next };
_MD_NodeParseCtx *ctx = &ctx_; _MD_NodeParseCtx *ctx = &ctx_;
return _MD_ParseExpr(ctx); return _MD_ParseExpr(ctx);
} }
MD_FUNCTION_IMPL MD_Expr * MD_FUNCTION_IMPL MD_C_Expr *
MD_ParseAsType(MD_Node *first, MD_Node *last) MD_C_ParseAsType(MD_Node *first, MD_Node *last)
{ {
MD_Expr *expr = MD_NilExpr(); MD_C_Expr *expr = MD_C_NilExpr();
MD_Expr *last_expr = expr; MD_C_Expr *last_expr = expr;
_MD_NodeParseCtx ctx_ = { first, last, last->next }; _MD_NodeParseCtx ctx_ = { first, last, last->next };
_MD_NodeParseCtx *ctx = &ctx_; _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 *set = 0;
MD_Node *ptr = 0; MD_Node *ptr = 0;
MD_Node *base_type = 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)) 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); _MD_PushType(t);
} }
else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("volatile"), &node)) 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); _MD_PushType(t);
} }
else if(_MD_NodeParse_Consume(ctx, MD_S8Lit("const"), &node)) 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); _MD_PushType(t);
} }
else if(_MD_NodeParse_ConsumeSet(ctx, &set)) else if(_MD_NodeParse_ConsumeSet(ctx, &set))
{ {
MD_Expr *t = MD_MakeExpr(set, MD_ExprKind_Array, MD_NilExpr(), MD_NilExpr()); MD_C_Expr *t = MD_C_MakeExpr(set, MD_C_ExprKind_Array, MD_C_NilExpr(), MD_C_NilExpr());
t->sub[1] = MD_ParseAsExpr(set->first_child, set->last_child); t->sub[1] = MD_C_ParseAsExpr(set->first_child, set->last_child);
_MD_PushType(t); _MD_PushType(t);
} }
else if(_MD_NodeParse_ConsumeAtom(ctx, &base_type)) 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); _MD_PushType(t);
} }
else else
@@ -440,49 +433,49 @@ MD_ParseAsType(MD_Node *first, MD_Node *last)
} }
MD_FUNCTION_IMPL MD_i64 MD_FUNCTION_IMPL MD_i64
MD_EvaluateExpr_I64(MD_Expr *expr) MD_C_EvaluateExpr_I64(MD_C_Expr *expr)
{ {
MD_i64 result = 0; MD_i64 result = 0;
switch(expr->kind) 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(Add, +);
_MD_BinaryOp(Subtract, -); _MD_BinaryOp(Subtract, -);
_MD_BinaryOp(Multiply, *); _MD_BinaryOp(Multiply, *);
_MD_BinaryOp(Divide, /); _MD_BinaryOp(Divide, /);
#undef _MD_BinaryOp #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; default: break;
} }
return result; return result;
} }
MD_FUNCTION_IMPL MD_f64 MD_FUNCTION_IMPL MD_f64
MD_EvaluateExpr_F64(MD_Expr *expr) MD_C_EvaluateExpr_F64(MD_C_Expr *expr)
{ {
MD_f64 result = 0; MD_f64 result = 0;
switch(expr->kind) 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(Add, +);
_MD_BinaryOp(Subtract, -); _MD_BinaryOp(Subtract, -);
_MD_BinaryOp(Multiply, *); _MD_BinaryOp(Multiply, *);
_MD_BinaryOp(Divide, /); _MD_BinaryOp(Divide, /);
#undef _MD_BinaryOp #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; default: break;
} }
return result; return result;
} }
MD_FUNCTION_IMPL MD_b32 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; MD_b32 result = 0;
if(a->kind == b->kind) if(a->kind == b->kind)
{ {
result = 1; 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); 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_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); MD_b32 result = MD_C_ExprMatch(a, b, flags);
if(result && !MD_ExprIsNil(a) && !MD_ExprIsNil(b)) if(result && !MD_C_ExprIsNil(a) && !MD_C_ExprIsNil(b))
{ {
result = (MD_ExprDeepMatch(a->sub[0], b->sub[0], flags) && result = (MD_C_ExprDeepMatch(a->sub[0], b->sub[0], flags) &&
MD_ExprDeepMatch(a->sub[1], b->sub[1], flags)); MD_C_ExprDeepMatch(a->sub[1], b->sub[1], flags));
} }
return result; return result;
} }
@@ -546,37 +539,19 @@ MD_C_Generate_Struct(FILE *file, MD_Node *node)
} }
MD_FUNCTION_IMPL void MD_FUNCTION_IMPL void
MD_C_Generate_Decl(FILE *file, MD_Node *node) MD_C_Generate_Expr(FILE *file, MD_C_Expr *expr)
{
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)
{ {
if(!MD_NodeIsNil(expr->node)) if(!MD_NodeIsNil(expr->node))
{ {
_MD_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(expr->kind); _MD_C_ExprKindMetadata *metadata = _MD_MetadataFromExprKind(expr->kind);
switch(metadata->group) switch(metadata->group)
{ {
case MD_ExprKindGroup_Atom: case MD_C_ExprKindGroup_Atom:
{ {
fprintf(file, "%.*s", MD_StringExpand(expr->node->string)); fprintf(file, "%.*s", MD_StringExpand(expr->node->string));
}break; }break;
case MD_ExprKindGroup_Binary: case MD_C_ExprKindGroup_Binary:
{ {
fprintf(file, "("); fprintf(file, "(");
MD_C_Generate_Expr(file, expr->sub[0]); MD_C_Generate_Expr(file, expr->sub[0]);
@@ -585,7 +560,7 @@ MD_C_Generate_Expr(FILE *file, MD_Expr *expr)
fprintf(file, ")"); fprintf(file, ")");
}break; }break;
case MD_ExprKindGroup_PreUnary: case MD_C_ExprKindGroup_PreUnary:
{ {
fprintf(file, "%s", metadata->pre_symbol); fprintf(file, "%s", metadata->pre_symbol);
fprintf(file, "("); fprintf(file, "(");
@@ -593,7 +568,7 @@ MD_C_Generate_Expr(FILE *file, MD_Expr *expr)
fprintf(file, ")"); fprintf(file, ")");
}break; }break;
case MD_ExprKindGroup_PostUnary: case MD_C_ExprKindGroup_PostUnary:
{ {
fprintf(file, "("); fprintf(file, "(");
MD_C_Generate_Expr(file, expr->sub[0]); 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_PRIVATE_FUNCTION_IMPL MD_b32
_MD_OutputType_C_NeedsParens(MD_Expr *type) _MD_OutputType_C_NeedsParens(MD_C_Expr *type)
{ {
MD_b32 result = 0; MD_b32 result = 0;
if (type->kind == MD_ExprKind_Pointer && if (type->kind == MD_C_ExprKind_Pointer &&
type->sub[0]->kind == MD_ExprKind_Array) type->sub[0]->kind == MD_C_ExprKind_Array)
{ {
result = 1; result = 1;
} }
@@ -619,19 +594,19 @@ _MD_OutputType_C_NeedsParens(MD_Expr *type)
} }
MD_FUNCTION_IMPL void 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) switch (type->kind)
{ {
case MD_ExprKind_Atom: case MD_C_ExprKind_Atom:
{ {
MD_Node *node = type->node; MD_Node *node = type->node;
fprintf(file, "%.*s", MD_StringExpand(node->whole_string)); fprintf(file, "%.*s", MD_StringExpand(node->whole_string));
}break; }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)) if (_MD_OutputType_C_NeedsParens(type))
{ {
fprintf(file, "("); fprintf(file, "(");
@@ -639,21 +614,21 @@ MD_C_Generate_LHS(FILE *file, MD_Expr *type)
fprintf(file, "*"); fprintf(file, "*");
}break; }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)) if (_MD_OutputType_C_NeedsParens(type))
{ {
fprintf(file, "("); fprintf(file, "(");
} }
}break; }break;
case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break;
case MD_ExprKind_Const: { fprintf(file, "const "); }break; case MD_C_ExprKind_Const: { fprintf(file, "const "); }break;
default: 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, type->kind,
MD_StringExpand(type->node->whole_string)); MD_StringExpand(type->node->whole_string));
}break; }break;
@@ -661,23 +636,23 @@ MD_C_Generate_LHS(FILE *file, MD_Expr *type)
} }
MD_FUNCTION_IMPL void 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) switch (type->kind)
{ {
case MD_ExprKind_Atom: case MD_C_ExprKind_Atom:
{}break; {}break;
case MD_ExprKind_Pointer: case MD_C_ExprKind_Pointer:
{ {
if (_MD_OutputType_C_NeedsParens(type)) if (_MD_OutputType_C_NeedsParens(type))
{ {
fprintf(file, ")"); fprintf(file, ")");
} }
MD_C_Generate_RHS(file, type->sub[0]); MD_C_Generate_TypeRHS(file, type->sub[0]);
}break; }break;
case MD_ExprKind_Array: case MD_C_ExprKind_Array:
{ {
if (_MD_OutputType_C_NeedsParens(type)) if (_MD_OutputType_C_NeedsParens(type))
{ {
@@ -686,17 +661,35 @@ MD_C_Generate_RHS(FILE *file, MD_Expr *type)
fprintf(file, "["); fprintf(file, "[");
MD_C_Generate_Expr(file, type->sub[1]); MD_C_Generate_Expr(file, type->sub[1]);
fprintf(file, "]"); fprintf(file, "]");
MD_C_Generate_RHS(file, type->sub[0]); MD_C_Generate_TypeRHS(file, type->sub[0]);
}break; }break;
case MD_ExprKind_Volatile: { fprintf(file, "volatile "); }break; case MD_C_ExprKind_Volatile: { fprintf(file, "volatile "); }break;
case MD_ExprKind_Const: { fprintf(file, "const "); }break; case MD_C_ExprKind_Const: { fprintf(file, "const "); }break;
default: default:
{}break; {}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 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. //~ 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 // VERY_IMPORTANT_NOTE(rjf): If this enum is ever changed, ensure that
// it is kept in-sync with the _MD_MetadataFromExprKind function. // it is kept in-sync with the _MD_MetadataFromExprKind function.
MD_ExprKind_Nil, MD_C_ExprKind_Nil,
// NOTE(rjf): Atom // NOTE(rjf): Atom
MD_ExprKind_Atom, MD_C_ExprKind_Atom,
// NOTE(rjf): Access // NOTE(rjf): Access
MD_ExprKind_Dot, MD_C_ExprKind_Dot,
MD_ExprKind_Arrow, MD_C_ExprKind_Arrow,
MD_ExprKind_Call, MD_C_ExprKind_Call,
MD_ExprKind_Subscript, MD_C_ExprKind_Subscript,
MD_ExprKind_Dereference, MD_C_ExprKind_Dereference,
MD_ExprKind_Reference, MD_C_ExprKind_Reference,
// NOTE(rjf): Arithmetic // NOTE(rjf): Arithmetic
MD_ExprKind_Add, MD_C_ExprKind_Add,
MD_ExprKind_Subtract, MD_C_ExprKind_Subtract,
MD_ExprKind_Multiply, MD_C_ExprKind_Multiply,
MD_ExprKind_Divide, MD_C_ExprKind_Divide,
MD_ExprKind_Mod, MD_C_ExprKind_Mod,
// NOTE(rjf): Comparison // NOTE(rjf): Comparison
MD_ExprKind_IsEqual, MD_C_ExprKind_IsEqual,
MD_ExprKind_IsNotEqual, MD_C_ExprKind_IsNotEqual,
MD_ExprKind_LessThan, MD_C_ExprKind_LessThan,
MD_ExprKind_GreaterThan, MD_C_ExprKind_GreaterThan,
MD_ExprKind_LessThanEqualTo, MD_C_ExprKind_LessThanEqualTo,
MD_ExprKind_GreaterThanEqualTo, MD_C_ExprKind_GreaterThanEqualTo,
// NOTE(rjf): Bools // NOTE(rjf): Bools
MD_ExprKind_BoolAnd, MD_C_ExprKind_BoolAnd,
MD_ExprKind_BoolOr, MD_C_ExprKind_BoolOr,
MD_ExprKind_BoolNot, MD_C_ExprKind_BoolNot,
// NOTE(rjf): Bitwise // NOTE(rjf): Bitwise
MD_ExprKind_BitAnd, MD_C_ExprKind_BitAnd,
MD_ExprKind_BitOr, MD_C_ExprKind_BitOr,
MD_ExprKind_BitNot, MD_C_ExprKind_BitNot,
MD_ExprKind_BitXor, MD_C_ExprKind_BitXor,
MD_ExprKind_LeftShift, MD_C_ExprKind_LeftShift,
MD_ExprKind_RightShift, MD_C_ExprKind_RightShift,
// NOTE(rjf): Unary numeric // NOTE(rjf): Unary numeric
MD_ExprKind_Negative, MD_C_ExprKind_Negative,
// NOTE(rjf): Type // NOTE(rjf): Type
MD_ExprKind_Pointer, MD_C_ExprKind_Pointer,
MD_ExprKind_Array, MD_C_ExprKind_Array,
MD_ExprKind_Volatile, MD_C_ExprKind_Volatile,
MD_ExprKind_Const, 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_C_ExprKindGroup_Nil,
MD_ExprKindGroup_Atom, MD_C_ExprKindGroup_Atom,
MD_ExprKindGroup_Binary, MD_C_ExprKindGroup_Binary,
MD_ExprKindGroup_PreUnary, MD_C_ExprKindGroup_PreUnary,
MD_ExprKindGroup_PostUnary, MD_C_ExprKindGroup_PostUnary,
MD_ExprKindGroup_Type, 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; typedef struct MD_C_Expr MD_C_Expr;
struct MD_Expr struct MD_C_Expr
{ {
MD_Node *node; MD_Node *node;
MD_ExprKind kind; MD_C_ExprKind kind;
MD_Expr *parent; MD_C_Expr *parent;
MD_Expr *sub[2]; MD_C_Expr *sub[2];
}; };
//~ Expression and Type-Expression Helper //~ C_Expression and Type-C_Expression Helper
MD_FUNCTION MD_Expr * MD_NilExpr(void); MD_FUNCTION MD_C_Expr * MD_C_NilExpr(void);
MD_FUNCTION MD_b32 MD_ExprIsNil(MD_Expr *expr); MD_FUNCTION MD_b32 MD_C_ExprIsNil(MD_C_Expr *expr);
MD_FUNCTION MD_ExprKind MD_PreUnaryExprKindFromNode(MD_Node *node); MD_FUNCTION MD_C_ExprKind MD_C_PreUnaryExprKindFromNode(MD_Node *node);
MD_FUNCTION MD_ExprKind MD_BinaryExprKindFromNode(MD_Node *node); MD_FUNCTION MD_C_ExprKind MD_C_BinaryExprKindFromNode(MD_Node *node);
MD_FUNCTION MD_ExprPrec MD_ExprPrecFromExprKind(MD_ExprKind kind); MD_FUNCTION MD_C_ExprPrec MD_C_ExprPrecFromExprKind(MD_C_ExprKind kind);
MD_FUNCTION MD_Expr * MD_MakeExpr(MD_Node *node, MD_ExprKind kind, MD_Expr *left, MD_Expr *right); 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_Expr * MD_ParseAsExpr(MD_Node *first, MD_Node *last); MD_FUNCTION MD_C_Expr * MD_C_ParseAsExpr(MD_Node *first, MD_Node *last);
MD_FUNCTION MD_Expr * MD_ParseAsType(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_EvaluateExpr_I64(MD_Expr *expr); MD_FUNCTION MD_i64 MD_C_EvaluateExpr_I64(MD_C_Expr *expr);
MD_FUNCTION MD_f64 MD_EvaluateExpr_F64(MD_Expr *expr); MD_FUNCTION MD_f64 MD_C_EvaluateExpr_F64(MD_C_Expr *expr);
MD_FUNCTION MD_b32 MD_ExprMatch(MD_Expr *a, MD_Expr *b, MD_MatchFlags flags); MD_FUNCTION MD_b32 MD_C_ExprMatch(MD_C_Expr *a, MD_C_Expr *b, MD_MatchFlags flags);
MD_FUNCTION MD_b32 MD_ExprDeepMatch(MD_Expr *a, MD_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 //~ C Language Generation
MD_FUNCTION void MD_C_Generate_String(FILE *file, MD_Node *node); 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_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_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 #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); return MD_MakeNodeFromString(kind, MD_S8Lit("`TEST_NODE`"), 0, 0, string);
} }
static MD_Expr * static MD_C_Expr *
AtomExpr(char *str) 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 * static MD_C_Expr *
BinOpExpr(MD_ExprKind kind, MD_Expr *left, MD_Expr *right) 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 * static MD_C_Expr *
TypeExpr(MD_ExprKind kind, MD_Expr *sub) 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 static MD_b32
@@ -87,19 +88,19 @@ MatchParsedWithNode(MD_String8 string, MD_Node *tree)
} }
static MD_b32 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_ParseResult parse = MD_ParseOneNode(MD_S8Lit(""), string);
MD_Expr *parse_expr = MD_ParseAsExpr(parse.node->first_child, parse.node->last_child); MD_C_Expr *parse_expr = MD_C_ParseAsExpr(parse.node->first_child, parse.node->last_child);
return MD_ExprDeepMatch(expr, parse_expr, 0); return MD_C_ExprDeepMatch(expr, parse_expr, 0);
} }
static MD_b32 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_ParseResult parse = MD_ParseOneNode(MD_S8Lit(""), string);
MD_Expr *parse_expr = MD_ParseAsType(parse.node->first_child, parse.node->last_child); MD_C_Expr *parse_expr = MD_C_ParseAsType(parse.node->first_child, parse.node->last_child);
return MD_ExprDeepMatch(expr, parse_expr, 0); return MD_C_ExprDeepMatch(expr, parse_expr, 0);
} }
static MD_b32 static MD_b32
@@ -286,34 +287,34 @@ int main(void)
{ {
// NOTE(rjf): 5 + 3 // NOTE(rjf): 5 + 3
{ {
MD_Expr *expr = BinOpExpr(MD_ExprKind_Add, AtomExpr("5"), AtomExpr("3")); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("5"), AtomExpr("3"));
TestResult(MD_EvaluateExpr_I64(expr) == 8); TestResult(MD_C_EvaluateExpr_I64(expr) == 8);
} }
// NOTE(rjf): 5 - 3 // NOTE(rjf): 5 - 3
{ {
MD_Expr *expr = BinOpExpr(MD_ExprKind_Subtract, AtomExpr("5"), AtomExpr("3")); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Subtract, AtomExpr("5"), AtomExpr("3"));
TestResult(MD_EvaluateExpr_I64(expr) == 2); TestResult(MD_C_EvaluateExpr_I64(expr) == 2);
} }
// NOTE(rjf): 5 * 3 // NOTE(rjf): 5 * 3
{ {
MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, AtomExpr("5"), AtomExpr("3")); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, AtomExpr("5"), AtomExpr("3"));
TestResult(MD_EvaluateExpr_I64(expr) == 15); TestResult(MD_C_EvaluateExpr_I64(expr) == 15);
} }
// NOTE(rjf): 10 / 2 // NOTE(rjf): 10 / 2
{ {
MD_Expr *expr = BinOpExpr(MD_ExprKind_Divide, AtomExpr("10"), AtomExpr("2")); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Divide, AtomExpr("10"), AtomExpr("2"));
TestResult(MD_EvaluateExpr_I64(expr) == 5); TestResult(MD_C_EvaluateExpr_I64(expr) == 5);
} }
// NOTE(rjf): (3 + 4) * (2 + 6) // NOTE(rjf): (3 + 4) * (2 + 6)
{ {
MD_Expr *left = BinOpExpr(MD_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("3"), AtomExpr("4"));
MD_Expr *right = BinOpExpr(MD_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); MD_C_Expr *right = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("2"), AtomExpr("6"));
MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, left, right); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, left, right);
TestResult(MD_EvaluateExpr_I64(expr) == 56); TestResult(MD_C_EvaluateExpr_I64(expr) == 56);
} }
} }
@@ -321,20 +322,20 @@ int main(void)
{ {
{ {
MD_String8 string = MD_S8Lit("(1 + 2)"); 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)); TestResult(MatchParsedWithExpr(string, expr));
} }
{ {
MD_String8 string = MD_S8Lit("((3 + 4) * (2 + 6))"); MD_String8 string = MD_S8Lit("((3 + 4) * (2 + 6))");
MD_Expr *left = BinOpExpr(MD_ExprKind_Add, AtomExpr("3"), AtomExpr("4")); MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("3"), AtomExpr("4"));
MD_Expr *right = BinOpExpr(MD_ExprKind_Add, AtomExpr("2"), AtomExpr("6")); MD_C_Expr *right = BinOpExpr(MD_C_ExprKind_Add, AtomExpr("2"), AtomExpr("6"));
MD_Expr *expr = BinOpExpr(MD_ExprKind_Multiply, left, right); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Multiply, left, right);
TestResult(MatchParsedWithExpr(string, expr)); TestResult(MatchParsedWithExpr(string, expr));
} }
{ {
MD_String8 string = MD_S8Lit("(1*2+3)"); MD_String8 string = MD_S8Lit("(1*2+3)");
MD_Expr *left = BinOpExpr(MD_ExprKind_Multiply, AtomExpr("1"), AtomExpr("2")); MD_C_Expr *left = BinOpExpr(MD_C_ExprKind_Multiply, AtomExpr("1"), AtomExpr("2"));
MD_Expr *expr = BinOpExpr(MD_ExprKind_Add, left, AtomExpr("3")); MD_C_Expr *expr = BinOpExpr(MD_C_ExprKind_Add, left, AtomExpr("3"));
TestResult(MatchParsedWithExpr(string, expr)); TestResult(MatchParsedWithExpr(string, expr));
} }
} }
@@ -343,22 +344,22 @@ int main(void)
{ {
{ {
MD_String8 string = MD_S8Lit("(i32)"); MD_String8 string = MD_S8Lit("(i32)");
MD_Expr *expr = AtomExpr("i32"); MD_C_Expr *expr = AtomExpr("i32");
TestResult(MatchParsedWithType(string, expr)); TestResult(MatchParsedWithType(string, expr));
} }
{ {
MD_String8 string = MD_S8Lit("(*i32)"); 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)); TestResult(MatchParsedWithType(string, expr));
} }
{ {
MD_String8 string = MD_S8Lit("(**i32)"); 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)); TestResult(MatchParsedWithType(string, expr));
} }
{ {
MD_String8 string = MD_S8Lit("(*void)"); 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)); TestResult(MatchParsedWithType(string, expr));
} }
} }