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

starting to review mdesk.h/c

Browse Source
This commit is contained in:
ed
2025-02-08 11:10:23 -05:00
parent 43baf82a8b
commit 68fadce5c6
21 changed files with 1166 additions and 1153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/base/strings.c
+7 -11
View File
@@ -1057,16 +1057,12 @@ str8_path_list_join_by_style_alloc(AllocatorInfo ainfo, String8List* path, PathS
//////////////////////////////// ////////////////////////////////
//~ rjf: UTF-8 & UTF-16 Decoding/Encoding //~ rjf: UTF-8 & UTF-16 Decoding/Encoding
read_only global U8 utf8_class[32] = {
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5,
};
UnicodeDecode UnicodeDecode
utf8_decode(U8* str, U64 max) utf8_decode(U8* str, U64 max)
{ {
UnicodeDecode result = {1, MAX_U32}; UnicodeDecode result = {1, MAX_U32};
U8 byte = str[0]; U8 byte = str[0];
U8 byte_class = utf8_class[byte >> 3]; U8 byte_class = utf8_class(byte >> 3);
switch (byte_class) switch (byte_class)
{ {
case 1: case 1:
@@ -1080,7 +1076,7 @@ utf8_decode(U8* str, U64 max)
if (2 < max) if (2 < max)
{ {
U8 cont_byte = str[1]; U8 cont_byte = str[1];
if (utf8_class[cont_byte >> 3] == 0) if (utf8_class(cont_byte >> 3) == 0)
{ {
result.codepoint = (byte & BITMASK5) << 6; result.codepoint = (byte & BITMASK5) << 6;
result.codepoint |= (cont_byte & BITMASK6); result.codepoint |= (cont_byte & BITMASK6);
@@ -1095,8 +1091,8 @@ utf8_decode(U8* str, U64 max)
if (2 < max) if (2 < max)
{ {
U8 cont_byte[2] = {str[1], str[2]}; U8 cont_byte[2] = {str[1], str[2]};
if (utf8_class[cont_byte[0] >> 3] == 0 && if (utf8_class(cont_byte[0] >> 3) == 0 &&
utf8_class[cont_byte[1] >> 3] == 0) utf8_class(cont_byte[1] >> 3) == 0)
{ {
result.codepoint = (byte & BITMASK4) << 12; result.codepoint = (byte & BITMASK4) << 12;
result.codepoint |= ((cont_byte[0] & BITMASK6) << 6); result.codepoint |= ((cont_byte[0] & BITMASK6) << 6);
@@ -1112,9 +1108,9 @@ utf8_decode(U8* str, U64 max)
if (3 < max) if (3 < max)
{ {
U8 cont_byte[3] = {str[1], str[2], str[3]}; U8 cont_byte[3] = {str[1], str[2], str[3]};
if (utf8_class[cont_byte[0] >> 3] == 0 && if (utf8_class(cont_byte[0] >> 3) == 0 &&
utf8_class[cont_byte[1] >> 3] == 0 && utf8_class(cont_byte[1] >> 3) == 0 &&
utf8_class[cont_byte[2] >> 3] == 0) utf8_class(cont_byte[2] >> 3) == 0)
{ {
result.codepoint = (byte & BITMASK3) << 18; result.codepoint = (byte & BITMASK3) << 18;
result.codepoint |= ((cont_byte[0] & BITMASK6) << 12); result.codepoint |= ((cont_byte[0] & BITMASK6) << 12);
code/base/strings.h
+10
View File
@@ -822,6 +822,16 @@ MD_API String8 str8_path_list_join_by_style_alloc (AllocatorInfo ainfo, Str
//////////////////////////////// ////////////////////////////////
//~ rjf: UTF-8 & UTF-16 Decoding/Encoding //~ rjf: UTF-8 & UTF-16 Decoding/Encoding
inline U8
utf8_class(U8 value)
{
read_only local_persist thread_local
U8 lookup_table[32] = {
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5,
};
return lookup_table[value];
}
MD_API UnicodeDecode utf8_decode (U8* str, U64 max); MD_API UnicodeDecode utf8_decode (U8* str, U64 max);
UnicodeDecode utf16_decode (U16* str, U64 max); UnicodeDecode utf16_decode (U16* str, U64 max);
MD_API U32 utf8_encode (U8* str, U32 codepoint); MD_API U32 utf8_encode (U8* str, U32 codepoint);
code/mdesk/mdesk.c
+259 -259
View File
File diff suppressed because it is too large Load Diff
code/mdesk/mdesk.h
+185 -178
View File
@@ -1,9 +1,7 @@
#if INTELLISENSE_DIRECTIVES #if INTELLISENSE_DIRECTIVES
#pragma once # pragma once
#include "base/base_types.h" # include "base/base.h"
#include "base/math.h" # include "os/os.h"
#include "base/arena.h"
#include "base/string.h"
#endif #endif
// Copyright (c) 2024 Epic Games Tools // Copyright (c) 2024 Epic Games Tools
@@ -14,11 +12,11 @@
typedef enum MsgKind typedef enum MsgKind
{ {
MsgKind_Null, MsgKind_Null,
MsgKind_Note, MsgKind_Note,
MsgKind_Warning, MsgKind_Warning,
MsgKind_Error, MsgKind_Error,
MsgKind_FatalError, MsgKind_FatalError,
} }
MsgKind; MsgKind;
@@ -26,19 +24,19 @@ typedef struct Node Node;
typedef struct Msg Msg; typedef struct Msg Msg;
struct Msg struct Msg
{ {
Msg* next; Msg* next;
Node* node; Node* node;
MsgKind kind; MsgKind kind;
String8 string; String8 string;
}; };
typedef struct MsgList MsgList; typedef struct MsgList MsgList;
struct MsgList struct MsgList
{ {
Msg* first; Msg* first;
Msg* last; Msg* last;
U64 count; U64 count;
MsgKind worst_message_kind; MsgKind worst_message_kind;
}; };
//////////////////////////////// ////////////////////////////////
@@ -47,69 +45,69 @@ struct MsgList
typedef U32 TokenFlags; typedef U32 TokenFlags;
enum enum
{ {
// rjf: base kind info // rjf: base kind info
TokenFlag_Identifier = (1<<0), TokenFlag_Identifier = (1<<0),
TokenFlag_Numeric = (1<<1), TokenFlag_Numeric = (1<<1),
TokenFlag_StringLiteral = (1<<2), TokenFlag_StringLiteral = (1<<2),
TokenFlag_Symbol = (1<<3), TokenFlag_Symbol = (1<<3),
TokenFlag_Reserved = (1<<4), TokenFlag_Reserved = (1<<4),
TokenFlag_Comment = (1<<5), TokenFlag_Comment = (1<<5),
TokenFlag_Whitespace = (1<<6), TokenFlag_Whitespace = (1<<6),
TokenFlag_Newline = (1<<7), TokenFlag_Newline = (1<<7),
// rjf: decoration info // rjf: decoration info
TokenFlag_StringSingleQuote = (1<<8), TokenFlag_StringSingleQuote = (1<<8),
TokenFlag_StringDoubleQuote = (1<<9), TokenFlag_StringDoubleQuote = (1<<9),
TokenFlag_StringTick = (1<<10), TokenFlag_StringTick = (1<<10),
TokenFlag_StringTriplet = (1<<11), TokenFlag_StringTriplet = (1<<11),
// rjf: error info // rjf: error info
TokenFlag_BrokenComment = (1<<12), TokenFlag_BrokenComment = (1<<12),
TokenFlag_BrokenStringLiteral = (1<<13), TokenFlag_BrokenStringLiteral = (1<<13),
TokenFlag_BadCharacter = (1<<14), TokenFlag_BadCharacter = (1<<14),
}; };
typedef U32 TokenGroups; typedef U32 TokenGroups;
enum enum
{ {
TokenGroup_Comment = TokenFlag_Comment, TokenGroup_Comment = TokenFlag_Comment,
TokenGroup_Whitespace = (TokenFlag_Whitespace| TokenFlag_Newline), TokenGroup_Whitespace = (TokenFlag_Whitespace| TokenFlag_Newline),
TokenGroup_Irregular = (TokenGroup_Comment | TokenGroup_Whitespace), TokenGroup_Irregular = (TokenGroup_Comment | TokenGroup_Whitespace),
TokenGroup_Regular = ~TokenGroup_Irregular, TokenGroup_Regular = ~TokenGroup_Irregular,
TokenGroup_Label = (TokenFlag_Identifier | TokenFlag_Numeric | TokenFlag_StringLiteral | TokenFlag_Symbol), TokenGroup_Label = (TokenFlag_Identifier | TokenFlag_Numeric | TokenFlag_StringLiteral | TokenFlag_Symbol),
TokenGroup_Error = (TokenFlag_BrokenComment | TokenFlag_BrokenStringLiteral | TokenFlag_BadCharacter), TokenGroup_Error = (TokenFlag_BrokenComment | TokenFlag_BrokenStringLiteral | TokenFlag_BadCharacter),
}; };
typedef struct Token Token; typedef struct Token Token;
struct Token struct Token
{ {
Rng1U64 range; Rng1U64 range;
TokenFlags flags; TokenFlags flags;
}; };
typedef struct TokenChunkNode TokenChunkNode; typedef struct TokenChunkNode TokenChunkNode;
struct TokenChunkNode struct TokenChunkNode
{ {
TokenChunkNode *next; TokenChunkNode* next;
Token *v; Token* v;
U64 count; U64 count;
U64 cap; U64 cap;
}; };
typedef struct TokenChunkList TokenChunkList; typedef struct TokenChunkList TokenChunkList;
struct TokenChunkList struct TokenChunkList
{ {
TokenChunkNode* first; TokenChunkNode* first;
TokenChunkNode* last; TokenChunkNode* last;
U64 chunk_count; U64 chunk_count;
U64 total_token_count; U64 total_token_count;
}; };
typedef struct TokenArray TokenArray; typedef struct TokenArray TokenArray;
struct TokenArray struct TokenArray
{ {
Token* v; Token* v;
U64 count; U64 count;
}; };
//////////////////////////////// ////////////////////////////////
@@ -117,208 +115,217 @@ struct TokenArray
typedef enum NodeKind typedef enum NodeKind
{ {
NodeKind_Nil, NodeKind_Nil,
NodeKind_File, NodeKind_File,
NodeKind_ErrorMarker, NodeKind_ErrorMarker,
NodeKind_Main, NodeKind_Main,
NodeKind_Tag, NodeKind_Tag,
NodeKind_List, NodeKind_List,
NodeKind_Reference, NodeKind_Reference,
NodeKind_COUNT NodeKind_COUNT
} }
NodeKind; NodeKind;
typedef U32 NodeFlags; typedef U32 NodeFlags;
enum enum
{ {
NodeFlag_MaskSetDelimiters = (0x3F<<0), NodeFlag_MaskSetDelimiters = (0x3F<<0),
NodeFlag_HasParenLeft = (1<<0), NodeFlag_HasParenLeft = (1<<0),
NodeFlag_HasParenRight = (1<<1), NodeFlag_HasParenRight = (1<<1),
NodeFlag_HasBracketLeft = (1<<2), NodeFlag_HasBracketLeft = (1<<2),
NodeFlag_HasBracketRight = (1<<3), NodeFlag_HasBracketRight = (1<<3),
NodeFlag_HasBraceLeft = (1<<4), NodeFlag_HasBraceLeft = (1<<4),
NodeFlag_HasBraceRight = (1<<5), NodeFlag_HasBraceRight = (1<<5),
NodeFlag_MaskSeparators = (0xF<<6), NodeFlag_MaskSeparators = (0xF<<6),
NodeFlag_IsBeforeSemicolon = (1<<6), NodeFlag_IsBeforeSemicolon = (1<<6),
NodeFlag_IsAfterSemicolon = (1<<7), NodeFlag_IsAfterSemicolon = (1<<7),
NodeFlag_IsBeforeComma = (1<<8), NodeFlag_IsBeforeComma = (1<<8),
NodeFlag_IsAfterComma = (1<<9), NodeFlag_IsAfterComma = (1<<9),
NodeFlag_MaskStringDelimiters = (0xF<<10), NodeFlag_MaskStringDelimiters = (0xF<<10),
NodeFlag_StringSingleQuote = (1<<10), NodeFlag_StringSingleQuote = (1<<10),
NodeFlag_StringDoubleQuote = (1<<11), NodeFlag_StringDoubleQuote = (1<<11),
NodeFlag_StringTick = (1<<12), NodeFlag_StringTick = (1<<12),
NodeFlag_StringTriplet = (1<<13), NodeFlag_StringTriplet = (1<<13),
NodeFlag_MaskLabelKind = (0xF<<14), NodeFlag_MaskLabelKind = (0xF<<14),
NodeFlag_Numeric = (1<<14), NodeFlag_Numeric = (1<<14),
NodeFlag_Identifier = (1<<15), NodeFlag_Identifier = (1<<15),
NodeFlag_StringLiteral = (1<<16), NodeFlag_StringLiteral = (1<<16),
NodeFlag_Symbol = (1<<17), NodeFlag_Symbol = (1<<17),
}; };
#define NodeFlag_AfterFromBefore(f) ((f) << 1) #define NodeFlag_AfterFromBefore(f) ((f) << 1)
typedef struct MD_Node MD_Node; typedef struct Node Node;
struct MD_Node struct Node
{ {
// rjf: tree links // rjf: tree links
MD_Node *next; Node* next;
MD_Node *prev; Node* prev;
MD_Node *parent; Node* parent;
MD_Node *first; Node* first;
MD_Node *last; Node* last;
// rjf: tag links // rjf: tag links
MD_Node *first_tag; Node* first_tag;
MD_Node *last_tag; Node* last_tag;
// rjf: node info // rjf: node info
MD_NodeKind kind; NodeKind kind;
MD_NodeFlags flags; NodeFlags flags;
String8 string; String8 string;
String8 raw_string; String8 raw_string;
// rjf: source code info // rjf: source code info
U64 src_offset; U64 src_offset;
// rjf: user-controlled generation number // rjf: user-controlled generation number
// //
// (unused by mdesk layer, but can be used by usage code to use MD_Node trees // (unused by mdesk layer, but can be used by usage code to use Node trees
// in a "retained mode" way, where stable generational handles can be formed // in a "retained mode" way, where stable generational handles can be formed
// to nodes) // to nodes)
U64 user_gen; U64 user_gen;
// rjf: extra padding to 128 bytes // rjf: extra padding to 128 bytes
U64 _unused_[2]; U64 _unused_[2];
}; };
typedef struct MD_NodeRec MD_NodeRec; typedef struct NodeRec NodeRec;
struct MD_NodeRec struct NodeRec
{ {
MD_Node *next; Node* next;
S32 push_count; S32 push_count;
S32 pop_count; S32 pop_count;
}; };
//////////////////////////////// ////////////////////////////////
//~ rjf: Text -> Tokens Types //~ rjf: Text -> Tokens Types
typedef struct MD_TokenizeResult MD_TokenizeResult; typedef struct TokenizeResult TokenizeResult;
struct MD_TokenizeResult struct TokenizeResult
{ {
MD_TokenArray tokens; TokenArray tokens;
MD_MsgList msgs; MsgList msgs;
}; };
//////////////////////////////// ////////////////////////////////
//~ rjf: Tokens -> Tree Types //~ rjf: Tokens -> Tree Types
typedef struct MD_ParseResult MD_ParseResult; typedef struct ParseResult ParseResult;
struct MD_ParseResult struct ParseResult
{ {
MD_Node *root; Node* root;
MD_MsgList msgs; MsgList msgs;
}; };
//////////////////////////////// ////////////////////////////////
//~ rjf: Globals //~ rjf: Globals
global read_only MD_Node md_nil_node = inline Node*
nil_node()
{ {
&md_nil_node, read_only thread_local local_persist
&md_nil_node, nil = {
&md_nil_node, &nil,
&md_nil_node, &nil,
&md_nil_node, &nil,
&md_nil_node, &nil,
&md_nil_node, &nil,
}; &nil,
&nil,
};
return &nil;
}
//////////////////////////////// ////////////////////////////////
//~ rjf: Message Type Functions //~ rjf: Message Type Functions
internal void md_msg_list_push(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, String8 string); internal void md_msg_list_push (Arena* arena, MsgList* msgs, Node* node, MsgKind kind, String8 string);
internal void md_msg_list_pushf(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, char *fmt, ...); internal void md_msg_list_pushf(Arena* arena, MsgList* msgs, Node* node, MsgKind kind, char *fmt, ...);
internal void md_msg_list_concat_in_place(MD_MsgList *dst, MD_MsgList *to_push);
internal void md_msg_list_concat_in_place(MsgList* dst, MsgList* to_push);
//////////////////////////////// ////////////////////////////////
//~ rjf: Token Type Functions //~ rjf: Token Type Functions
internal MD_Token md_token_make(Rng1U64 range, TokenFlags flags); internal Token md_token_make (Rng1U64 range, TokenFlags flags);
internal B32 md_token_match(MD_Token a, MD_Token b); internal B32 md_token_match (Token a, Token b);
internal String8List md_string_list_from_token_flags(Arena *arena, TokenFlags flags); internal String8List md_string_list_from_token_flags (Arena *arena, TokenFlags flags);
internal void md_token_chunk_list_push(Arena *arena, MD_TokenChunkList *list, U64 cap, MD_Token token); internal void md_token_chunk_list_push (Arena *arena, TokenChunkList *list, U64 cap, Token token);
internal MD_TokenArray md_token_array_from_chunk_list(Arena *arena, MD_TokenChunkList *chunks); internal TokenArray md_token_array_from_chunk_list (Arena *arena, TokenChunkList *chunks);
internal String8 md_content_string_from_token_flags_str8(TokenFlags flags, String8 string); internal String8 md_content_string_from_token_flags_str8(TokenFlags flags, String8 string);
//////////////////////////////// ////////////////////////////////
//~ rjf: Node Type Functions //~ rjf: Node Type Functions
//- rjf: flag conversions //- rjf: flag conversions
internal MD_NodeFlags md_node_flags_from_token_flags(TokenFlags flags); internal NodeFlags md_node_flags_from_token_flags(TokenFlags flags);
//- rjf: nil //- rjf: nil
internal B32 md_node_is_nil(MD_Node *node); internal B32 md_node_is_nil(Node *node);
//- rjf: iteration //- rjf: iteration
#define MD_EachNode(it, first) (MD_Node *it = first; !md_node_is_nil(it); it = it->next) #define MD_EachNode(it, first) (Node *it = first; !md_node_is_nil(it); it = it->next)
internal MD_NodeRec md_node_rec_depth_first(MD_Node *node, MD_Node *subtree_root, U64 child_off, U64 sib_off);
#define md_node_rec_depth_first_pre(node, subtree_root) md_node_rec_depth_first((node), (subtree_root), OffsetOf(MD_Node, first), OffsetOf(MD_Node, next)) internal NodeRec node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off);
#define md_node_rec_depth_first_pre_rev(node, subtree_root) md_node_rec_depth_first((node), (subtree_root), OffsetOf(MD_Node, last), OffsetOf(MD_Node, prev))
#define node_rec_depth_first_pre(node, subtree_root) node_rec_depth_first((node), (subtree_root), offset_of(Node, first), offset_of(Node, next))
#define node_rec_depth_first_pre_rev(node, subtree_root) node_rec_depth_first((node), (subtree_root), offset_of(Node, last), offset_of(Node, prev))
//- rjf: tree building //- rjf: tree building
internal MD_Node* md_push_node(Arena *arena, MD_NodeKind kind, MD_NodeFlags flags, String8 string, String8 raw_string, U64 src_offset); internal Node* md_push_node (Arena *arena, NodeKind kind, NodeFlags flags, String8 string, String8 raw_string, U64 src_offset);
internal void md_node_insert_tag(MD_Node *parent, MD_Node *prev_child, MD_Node *node); internal void md_node_insert_tag (Node *parent, Node *prev_child, Node *node);
internal void md_node_insert_child(MD_Node *parent, MD_Node *prev_child, MD_Node *node); internal void md_node_insert_child(Node *parent, Node *prev_child, Node *node);
internal void md_node_push_child(MD_Node *parent, MD_Node *node); internal void md_node_push_child (Node *parent, Node *node);
internal void md_node_push_tag(MD_Node *parent, MD_Node *node); internal void md_node_push_tag (Node *parent, Node *node);
internal void md_unhook(MD_Node *node); internal void md_unhook (Node *node);
//- rjf: tree introspection //- rjf: tree introspection
internal MD_Node * md_node_from_chain_string(MD_Node *first, MD_Node *opl, String8 string, StringMatchFlags flags); internal Node* md_node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFlags flags);
internal MD_Node * md_node_from_chain_index(MD_Node *first, MD_Node *opl, U64 index); internal Node* md_node_from_chain_index (Node *first, Node *opl, U64 index);
internal MD_Node * md_node_from_chain_flags(MD_Node *first, MD_Node *opl, MD_NodeFlags flags); internal Node* md_node_from_chain_flags (Node *first, Node *opl, NodeFlags flags);
internal U64 md_index_from_node(MD_Node *node); internal U64 md_index_from_node (Node *node);
internal MD_Node * md_root_from_node(MD_Node *node); internal Node* md_root_from_node (Node *node);
internal MD_Node * md_child_from_string(MD_Node *node, String8 child_string, StringMatchFlags flags); internal Node* md_child_from_string (Node *node, String8 child_string, StringMatchFlags flags);
internal MD_Node * md_tag_from_string(MD_Node *node, String8 tag_string, StringMatchFlags flags); internal Node* md_tag_from_string (Node *node, String8 tag_string, StringMatchFlags flags);
internal MD_Node * md_child_from_index(MD_Node *node, U64 index); internal Node* md_child_from_index (Node *node, U64 index);
internal MD_Node * md_tag_from_index(MD_Node *node, U64 index); internal Node* md_tag_from_index (Node *node, U64 index);
internal MD_Node * md_tag_arg_from_index(MD_Node *node, String8 tag_string, StringMatchFlags flags, U64 index); internal Node* md_tag_arg_from_index (Node *node, String8 tag_string, StringMatchFlags flags, U64 index);
internal MD_Node * md_tag_arg_from_string(MD_Node *node, String8 tag_string, StringMatchFlags tag_str_flags, String8 arg_string, StringMatchFlags arg_str_flags); internal Node* md_tag_arg_from_string (Node *node, String8 tag_string, StringMatchFlags tag_str_flags, String8 arg_string, StringMatchFlags arg_str_flags);
internal B32 md_node_has_child(MD_Node *node, String8 string, StringMatchFlags flags); internal B32 md_node_has_child (Node *node, String8 string, StringMatchFlags flags);
internal B32 md_node_has_tag(MD_Node *node, String8 string, StringMatchFlags flags); internal B32 md_node_has_tag (Node *node, String8 string, StringMatchFlags flags);
internal U64 md_child_count_from_node(MD_Node *node); internal U64 md_child_count_from_node (Node *node);
internal U64 md_tag_count_from_node(MD_Node *node); internal U64 md_tag_count_from_node (Node *node);
internal String8 md_string_from_children(Arena *arena, MD_Node *root);
internal String8 md_string_from_children (Arena *arena, Node *root);
//- rjf: tree comparison //- rjf: tree comparison
internal B32 md_tree_match(MD_Node *a, MD_Node *b, StringMatchFlags flags); internal B32 md_tree_match(Node *a, Node *b, StringMatchFlags flags);
internal B32 md_node_match(MD_Node *a, MD_Node *b, StringMatchFlags flags); internal B32 md_node_match(Node *a, Node *b, StringMatchFlags flags);
//- rjf: tree duplication //- rjf: tree duplication
internal MD_Node *md_tree_copy(Arena *arena, MD_Node *src_root); internal Node* md_tree_copy(Arena *arena, Node *src_root);
// MD_Node* tree_copy_arena(MD_Node* src_root, Arena* arena); // Node* tree_copy_arena(Node* src_root, Arena* arena);
// MD_Node* tree_copy_ainfo(MD_Node* src_root, AllocatorInfo info); // Node* tree_copy_ainfo(Node* src_root, AllocatorInfo info);
//////////////////////////////// ////////////////////////////////
//~ rjf: Text -> Tokens Functions //~ rjf: Text -> Tokens Functions
internal MD_TokenizeResult md_tokenize_from_text(Arena *arena, String8 text); internal TokenizeResult md_tokenize_from_text(Arena *arena, String8 text);
//////////////////////////////// ////////////////////////////////
//~ rjf: Tokens -> Tree Functions //~ rjf: Tokens -> Tree Functions
internal MD_ParseResult md_parse_from_text_tokens(Arena *arena, String8 filename, String8 text, MD_TokenArray tokens); internal ParseResult md_parse_from_text_tokens(Arena *arena, String8 filename, String8 text, TokenArray tokens);
//////////////////////////////// ////////////////////////////////
//~ rjf: Bundled Text -> Tree Functions //~ rjf: Bundled Text -> Tree Functions
internal MD_ParseResult md_parse_from_text(Arena *arena, String8 filename, String8 text); internal ParseResult md_parse_from_text(Arena *arena, String8 filename, String8 text);
#define md_tree_from_string(arena, string) (md_parse_from_text((arena), str8_zero(), (string)).root) #define md_tree_from_string(arena, string) (md_parse_from_text((arena), str8_zero(), (string)).root)
//////////////////////////////// ////////////////////////////////
//~ rjf: Tree -> Text Functions //~ rjf: Tree -> Text Functions
internal String8List md_debug_string_list_from_tree(Arena *arena, MD_Node *root); internal String8List md_debug_string_list_from_tree(Arena *arena, Node *root);
code/metagen/metagen.c
+30 -30
View File
@@ -354,7 +354,7 @@ mg_map_insert_ptr(Arena *arena, MG_Map *map, String8 string, void *val)
//~ rjf: String Expression Parsing //~ rjf: String Expression Parsing
internal MG_StrExpr * internal MG_StrExpr *
mg_push_str_expr(Arena *arena, MG_StrExprOp op, MD_Node *node) mg_push_str_expr(Arena *arena, MG_StrExprOp op, Node *node)
{ {
MG_StrExpr *expr = push_array(arena, MG_StrExpr, 1); MG_StrExpr *expr = push_array(arena, MG_StrExpr, 1);
MemoryCopyStruct(expr, &mg_str_expr_nil); MemoryCopyStruct(expr, &mg_str_expr_nil);
@@ -364,11 +364,11 @@ mg_push_str_expr(Arena *arena, MG_StrExprOp op, MD_Node *node)
} }
internal MG_StrExprParseResult internal MG_StrExprParseResult
mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node *opl, S8 min_prec) mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl, S8 min_prec)
{ {
MG_StrExprParseResult parse = {&mg_str_expr_nil}; MG_StrExprParseResult parse = {&mg_str_expr_nil};
{ {
MD_Node *it = first; Node *it = first;
//- rjf: consume prefix operators //- rjf: consume prefix operators
MG_StrExpr *leafmost_op = &mg_str_expr_nil; MG_StrExpr *leafmost_op = &mg_str_expr_nil;
@@ -407,7 +407,7 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node
//- rjf: parse atom //- rjf: parse atom
{ {
MG_StrExpr *atom = &mg_str_expr_nil; MG_StrExpr *atom = &mg_str_expr_nil;
if(it->flags & (MD_NodeFlag_Identifier|MD_NodeFlag_Numeric|MD_NodeFlag_StringLiteral) && if(it->flags & (NodeFlag_Identifier|NodeFlag_Numeric|NodeFlag_StringLiteral) &&
md_node_is_nil(it->first)) md_node_is_nil(it->first))
{ {
atom = mg_push_str_expr(arena, MG_StrExprOp_Null, it); atom = mg_push_str_expr(arena, MG_StrExprOp_Null, it);
@@ -415,7 +415,7 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node
} }
else if(!md_node_is_nil(it->first)) else if(!md_node_is_nil(it->first))
{ {
MG_StrExprParseResult subparse = mg_str_expr_parse_from_first_opl__min_prec(arena, it->first, &md_nil_node, 0); MG_StrExprParseResult subparse = mg_str_expr_parse_from_first_opl__min_prec(arena, it->first, &nil_node(), 0);
atom = subparse.root; atom = subparse.root;
md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs); md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
it = it->next; it = it->next;
@@ -471,7 +471,7 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node
md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs); md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
if(subparse.root == &mg_str_expr_nil) if(subparse.root == &mg_str_expr_nil)
{ {
md_msg_list_pushf(arena, &parse.msgs, it, MD_MsgKind_Error, "Missing right-hand-side of '%S'.", mg_str_expr_op_symbol_string_table[found_op]); md_msg_list_pushf(arena, &parse.msgs, it, MsgKind_Error, "Missing right-hand-side of '%S'.", mg_str_expr_op_symbol_string_table[found_op]);
} }
it = subparse.next_node; it = subparse.next_node;
} }
@@ -483,16 +483,16 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node
} }
internal MG_StrExprParseResult internal MG_StrExprParseResult
mg_str_expr_parse_from_first_opl(Arena *arena, MD_Node *first, MD_Node *opl) mg_str_expr_parse_from_first_opl(Arena *arena, Node *first, Node *opl)
{ {
MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, first, opl, 0); MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, first, opl, 0);
return parse; return parse;
} }
internal MG_StrExprParseResult internal MG_StrExprParseResult
mg_str_expr_parse_from_root(Arena *arena, MD_Node *root) mg_str_expr_parse_from_root(Arena *arena, Node *root)
{ {
MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, root->first, &md_nil_node, 0); MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, root->first, &nil_node(), 0);
return parse; return parse;
} }
@@ -504,16 +504,16 @@ mg_node_array_make(Arena *arena, U64 count)
{ {
MG_NodeArray result = {0}; MG_NodeArray result = {0};
result.count = count; result.count = count;
result.v = push_array(arena, MD_Node *, result.count); result.v = push_array(arena, Node *, result.count);
for(U64 idx = 0; idx < result.count; idx += 1) for(U64 idx = 0; idx < result.count; idx += 1)
{ {
result.v[idx] = &md_nil_node; result.v[idx] = &nil_node();
} }
return result; return result;
} }
internal MG_NodeArray internal MG_NodeArray
mg_child_array_from_node(Arena *arena, MD_Node *node) mg_child_array_from_node(Arena *arena, Node *node)
{ {
MG_NodeArray children = mg_node_array_make(arena, md_child_count_from_node(node)); MG_NodeArray children = mg_node_array_make(arena, md_child_count_from_node(node));
U64 idx = 0; U64 idx = 0;
@@ -526,7 +526,7 @@ mg_child_array_from_node(Arena *arena, MD_Node *node)
} }
internal MG_NodeGrid internal MG_NodeGrid
mg_node_grid_make_from_node(Arena *arena, MD_Node *root) mg_node_grid_make_from_node(Arena *arena, Node *root)
{ {
MG_NodeGrid grid = {0}; MG_NodeGrid grid = {0};
@@ -593,10 +593,10 @@ mg_column_from_index(Arena *arena, MG_NodeGrid grid, U64 index)
return result; return result;
} }
internal MD_Node * internal Node *
mg_node_from_grid_xy(MG_NodeGrid grid, U64 x, U64 y) mg_node_from_grid_xy(MG_NodeGrid grid, U64 x, U64 y)
{ {
MD_Node *result = &md_nil_node; Node *result = &nil_node();
U64 idx = x*grid.x_stride + y*grid.y_stride; U64 idx = x*grid.x_stride + y*grid.y_stride;
if(0 <= idx && idx < grid.cells.count) if(0 <= idx && idx < grid.cells.count)
{ {
@@ -616,7 +616,7 @@ mg_column_desc_array_make(Arena *arena, U64 count, MG_ColumnDesc *descs)
} }
internal MG_ColumnDescArray internal MG_ColumnDescArray
mg_column_desc_array_from_tag(Arena *arena, MD_Node *tag) mg_column_desc_array_from_tag(Arena *arena, Node *tag)
{ {
MG_ColumnDescArray result = {0}; MG_ColumnDescArray result = {0};
result.count = md_child_count_from_node(tag); result.count = md_child_count_from_node(tag);
@@ -657,7 +657,7 @@ mg_column_index_from_name(MG_ColumnDescArray descs, String8 name)
} }
internal String8 internal String8
mg_string_from_row_desc_idx(MD_Node *row_parent, MG_ColumnDescArray descs, U64 idx) mg_string_from_row_desc_idx(Node *row_parent, MG_ColumnDescArray descs, U64 idx)
{ {
String8 result = {0}; String8 result = {0};
@@ -686,21 +686,21 @@ mg_string_from_row_desc_idx(MD_Node *row_parent, MG_ColumnDescArray descs, U64 i
cell_idx -= 1; cell_idx -= 1;
} }
} }
MD_Node *node = md_child_from_index(row_parent, cell_idx); Node *node = md_child_from_index(row_parent, cell_idx);
result = node->string; result = node->string;
}break; }break;
case MG_ColumnKind_CheckForTag: case MG_ColumnKind_CheckForTag:
{ {
String8 tag_name = desc->name; String8 tag_name = desc->name;
MD_Node *tag = md_tag_from_string(row_parent, tag_name, 0); Node *tag = md_tag_from_string(row_parent, tag_name, 0);
result = md_node_is_nil(tag) ? str8_lit("0") : str8_lit("1"); result = md_node_is_nil(tag) ? str8_lit("0") : str8_lit("1");
}break; }break;
case MG_ColumnKind_TagChild: case MG_ColumnKind_TagChild:
{ {
String8 tag_name = desc->tag_name; String8 tag_name = desc->tag_name;
MD_Node *tag = md_tag_from_string(row_parent, tag_name, 0); Node *tag = md_tag_from_string(row_parent, tag_name, 0);
result = tag->first->string; result = tag->first->string;
}break; }break;
} }
@@ -836,9 +836,9 @@ mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpand
{ {
// rjf: grab left/right // rjf: grab left/right
MG_StrExpr *left_expr = expr->left; MG_StrExpr *left_expr = expr->left;
MD_Node *left_node = left_expr->node; Node *left_node = left_expr->node;
MG_StrExpr *right_expr = expr->right; MG_StrExpr *right_expr = expr->right;
MD_Node *right_node = right_expr->node; Node *right_node = right_expr->node;
// rjf: grab table name (LHS of .) and column lookup string (RHS of .) // rjf: grab table name (LHS of .) and column lookup string (RHS of .)
String8 expand_label = left_node->string; String8 expand_label = left_node->string;
@@ -862,7 +862,7 @@ mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpand
} }
// rjf: grab row parent // rjf: grab row parent
MD_Node *row_parent = &md_nil_node; Node *row_parent = &nil_node();
if(grid && (0 <= row_idx && row_idx < grid->row_parents.count)) if(grid && (0 <= row_idx && row_idx < grid->row_parents.count))
{ {
row_parent = grid->row_parents.v[row_idx]; row_parent = grid->row_parents.v[row_idx];
@@ -880,13 +880,13 @@ mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpand
else else
{ {
// NOTE(rjf): numeric column lookup (column index) // NOTE(rjf): numeric column lookup (column index)
if(right_node->flags & MD_NodeFlag_Numeric) if(right_node->flags & NodeFlag_Numeric)
{ {
try_u64_from_str8_c_rules(column_lookup, &column_idx); try_u64_from_str8_c_rules(column_lookup, &column_idx);
} }
// NOTE(rjf): string column lookup (column name) // NOTE(rjf): string column lookup (column name)
if(right_node->flags & (MD_NodeFlag_Identifier|MD_NodeFlag_StringLiteral)) if(right_node->flags & (NodeFlag_Identifier|NodeFlag_StringLiteral))
{ {
column_idx = mg_column_index_from_name(column_descs, column_lookup); column_idx = mg_column_index_from_name(column_descs, column_lookup);
} }
@@ -999,8 +999,8 @@ mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo
} }
} }
String8 expr_string = str8_substr(string, expr_range); String8 expr_string = str8_substr(string, expr_range);
MD_TokenizeResult expr_tokenize = md_tokenize_from_text(scratch.arena, expr_string); TokenizeResult expr_tokenize = md_tokenize_from_text(scratch.arena, expr_string);
MD_ParseResult expr_base_parse = md_parse_from_text_tokens(scratch.arena, str8_lit(""), expr_string, expr_tokenize.tokens); ParseResult expr_base_parse = md_parse_from_text_tokens(scratch.arena, str8_lit(""), expr_string, expr_tokenize.tokens);
MG_StrExprParseResult expr_parse = mg_str_expr_parse_from_root(scratch.arena, expr_base_parse.root->first); MG_StrExprParseResult expr_parse = mg_str_expr_parse_from_root(scratch.arena, expr_base_parse.root->first);
mg_eval_table_expand_expr__string(arena, expr_parse.root, info, &expansion_strs); mg_eval_table_expand_expr__string(arena, expr_parse.root, info, &expansion_strs);
char_idx = start = char_idx + 1 + expr_range.max; char_idx = start = char_idx + 1 + expr_range.max;
@@ -1022,7 +1022,7 @@ mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo
} }
internal String8List internal String8List
mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_column_desc_map, String8 fallback, MD_Node *gen) mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_column_desc_map, String8 fallback, Node *gen)
{ {
String8List result = {0}; String8List result = {0};
Temp scratch = scratch_begin(&arena, 1); Temp scratch = scratch_begin(&arena, 1);
@@ -1041,8 +1041,8 @@ mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_co
if(str8_match(tag->string, str8_lit("expand"), 0)) if(str8_match(tag->string, str8_lit("expand"), 0))
{ {
// rjf: grab args for this expansion // rjf: grab args for this expansion
MD_Node *table_name_node = md_child_from_index(tag, 0); Node *table_name_node = md_child_from_index(tag, 0);
MD_Node *expand_label_node = md_child_from_index(tag, 1); Node *expand_label_node = md_child_from_index(tag, 1);
String8 table_name = table_name_node->string; String8 table_name = table_name_node->string;
String8 expand_label = expand_label_node->string; String8 expand_label = expand_label_node->string;
code/metagen/metagen.h
+15 -15
View File
@@ -36,7 +36,7 @@ struct MG_MsgList
typedef struct MG_FileParse MG_FileParse; typedef struct MG_FileParse MG_FileParse;
struct MG_FileParse struct MG_FileParse
{ {
MD_Node *root; Node *root;
}; };
typedef struct MG_FileParseNode MG_FileParseNode; typedef struct MG_FileParseNode MG_FileParseNode;
@@ -133,15 +133,15 @@ struct MG_StrExpr
MG_StrExpr *left; MG_StrExpr *left;
MG_StrExpr *right; MG_StrExpr *right;
MG_StrExprOp op; MG_StrExprOp op;
MD_Node *node; Node *node;
}; };
typedef struct MG_StrExprParseResult MG_StrExprParseResult; typedef struct MG_StrExprParseResult MG_StrExprParseResult;
struct MG_StrExprParseResult struct MG_StrExprParseResult
{ {
MG_StrExpr *root; MG_StrExpr *root;
MD_MsgList msgs; MsgList msgs;
MD_Node *next_node; Node *next_node;
}; };
//////////////////////////////// ////////////////////////////////
@@ -150,7 +150,7 @@ struct MG_StrExprParseResult
typedef struct MG_NodeArray MG_NodeArray; typedef struct MG_NodeArray MG_NodeArray;
struct MG_NodeArray struct MG_NodeArray
{ {
MD_Node **v; Node **v;
U64 count; U64 count;
}; };
@@ -295,30 +295,30 @@ internal void mg_map_insert_ptr(Arena *arena, MG_Map *map, String8 string, void
//////////////////////////////// ////////////////////////////////
//~ rjf: String Expression Parsing //~ rjf: String Expression Parsing
internal MG_StrExpr *mg_push_str_expr(Arena *arena, MG_StrExprOp op, MD_Node *node); internal MG_StrExpr *mg_push_str_expr(Arena *arena, MG_StrExprOp op, Node *node);
internal MG_StrExprParseResult mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node *opl, S8 min_prec); internal MG_StrExprParseResult mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl, S8 min_prec);
internal MG_StrExprParseResult mg_str_expr_parse_from_first_opl(Arena *arena, MD_Node *first, MD_Node *opl); internal MG_StrExprParseResult mg_str_expr_parse_from_first_opl(Arena *arena, Node *first, Node *opl);
internal MG_StrExprParseResult mg_str_expr_parse_from_root(Arena *arena, MD_Node *root); internal MG_StrExprParseResult mg_str_expr_parse_from_root(Arena *arena, Node *root);
//////////////////////////////// ////////////////////////////////
//~ rjf: Table Generation Functions //~ rjf: Table Generation Functions
internal MG_NodeArray mg_node_array_make(Arena *arena, U64 count); internal MG_NodeArray mg_node_array_make(Arena *arena, U64 count);
internal MG_NodeArray mg_child_array_from_node(Arena *arena, MD_Node *node); internal MG_NodeArray mg_child_array_from_node(Arena *arena, Node *node);
internal MG_NodeGrid mg_node_grid_make_from_node(Arena *arena, MD_Node *root); internal MG_NodeGrid mg_node_grid_make_from_node(Arena *arena, Node *root);
internal MG_NodeArray mg_row_from_index(MG_NodeGrid grid, U64 index); internal MG_NodeArray mg_row_from_index(MG_NodeGrid grid, U64 index);
internal MG_NodeArray mg_column_from_index(Arena *arena, MG_NodeGrid grid, U64 index); internal MG_NodeArray mg_column_from_index(Arena *arena, MG_NodeGrid grid, U64 index);
internal MD_Node *mg_node_from_grid_xy(MG_NodeGrid grid, U64 x, U64 y); internal Node *mg_node_from_grid_xy(MG_NodeGrid grid, U64 x, U64 y);
internal MG_ColumnDescArray mg_column_desc_array_make(Arena *arena, U64 count, MG_ColumnDesc *descs); internal MG_ColumnDescArray mg_column_desc_array_make(Arena *arena, U64 count, MG_ColumnDesc *descs);
internal MG_ColumnDescArray mg_column_desc_array_from_tag(Arena *arena, MD_Node *tag); internal MG_ColumnDescArray mg_column_desc_array_from_tag(Arena *arena, Node *tag);
internal U64 mg_column_index_from_name(MG_ColumnDescArray descs, String8 name); internal U64 mg_column_index_from_name(MG_ColumnDescArray descs, String8 name);
internal String8 mg_string_from_row_desc_idx(MD_Node *row_parent, MG_ColumnDescArray descs, U64 idx); internal String8 mg_string_from_row_desc_idx(Node *row_parent, MG_ColumnDescArray descs, U64 idx);
internal S64 mg_eval_table_expand_expr__numeric(MG_StrExpr *expr, MG_TableExpandInfo *info); internal S64 mg_eval_table_expand_expr__numeric(MG_StrExpr *expr, MG_TableExpandInfo *info);
internal void mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpandInfo *info, String8List *out); internal void mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpandInfo *info, String8List *out);
internal void mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo *info, MG_TableExpandTask *task, String8List *out); internal void mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo *info, MG_TableExpandTask *task, String8List *out);
internal String8List mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_column_desc_map, String8 fallback, MD_Node *gen); internal String8List mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_column_desc_map, String8 fallback, Node *gen);
//////////////////////////////// ////////////////////////////////
//~ rjf: Layer Lookup Functions //~ rjf: Layer Lookup Functions
code/metagen/metagen_main.c
+22 -22
View File
@@ -92,9 +92,9 @@ entry_point(CmdLine *cmdline)
if(str8_match(file_ext, str8_lit("mdesk"), 0)) if(str8_match(file_ext, str8_lit("mdesk"), 0))
{ {
String8 data = os_data_from_file_path(mg_arena, file_path); String8 data = os_data_from_file_path(mg_arena, file_path);
MD_TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data); TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data);
MD_ParseResult parse = md_parse_from_text_tokens(mg_arena, file_path, data, tokenize.tokens); ParseResult parse = md_parse_from_text_tokens(mg_arena, file_path, data, tokenize.tokens);
for(MD_Msg *m = parse.msgs.first; m != 0; m = m->next) for(Msg *m = parse.msgs.first; m != 0; m = m->next)
{ {
TxtPt pt = mg_txt_pt_from_string_off(data, m->node->src_offset); TxtPt pt = mg_txt_pt_from_string_off(data, m->node->src_offset);
String8 msg_kind_string = {0}; String8 msg_kind_string = {0};
@@ -102,8 +102,8 @@ entry_point(CmdLine *cmdline)
{ {
default:{}break; default:{}break;
case MD_MsgKind_Note: {msg_kind_string = str8_lit("note");}break; case MD_MsgKind_Note: {msg_kind_string = str8_lit("note");}break;
case MD_MsgKind_Warning: {msg_kind_string = str8_lit("warning");}break; case MsgKind_Warning: {msg_kind_string = str8_lit("warning");}break;
case MD_MsgKind_Error: {msg_kind_string = str8_lit("error");}break; case MsgKind_Error: {msg_kind_string = str8_lit("error");}break;
case MD_MsgKind_FatalError: {msg_kind_string = str8_lit("fatal error");}break; case MD_MsgKind_FatalError: {msg_kind_string = str8_lit("fatal error");}break;
} }
String8 location = push_str8f(mg_arena, "%S:%I64d:%I64d", file_path, pt.line, pt.column); String8 location = push_str8f(mg_arena, "%S:%I64d:%I64d", file_path, pt.line, pt.column);
@@ -128,10 +128,10 @@ entry_point(CmdLine *cmdline)
{ {
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *table_tag = md_tag_from_string(node, str8_lit("table"), 0); Node *table_tag = md_tag_from_string(node, str8_lit("table"), 0);
if(!md_node_is_nil(table_tag)) if(!md_node_is_nil(table_tag))
{ {
MG_NodeGrid *table = push_array(mg_arena, MG_NodeGrid, 1); MG_NodeGrid *table = push_array(mg_arena, MG_NodeGrid, 1);
@@ -151,7 +151,7 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
String8 layer_key = mg_layer_key_from_path(file->string); String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key); MG_Layer *layer = mg_layer_from_key(layer_key);
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
@@ -219,10 +219,10 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *tag = md_tag_from_string(node, str8_lit("enum"), 0); Node *tag = md_tag_from_string(node, str8_lit("enum"), 0);
if(!md_node_is_nil(tag)) if(!md_node_is_nil(tag))
{ {
String8 enum_name = node->string; String8 enum_name = node->string;
@@ -266,10 +266,10 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *tag = md_tag_from_string(node, str8_lit("xlist"), 0); Node *tag = md_tag_from_string(node, str8_lit("xlist"), 0);
if(!md_node_is_nil(tag)) if(!md_node_is_nil(tag))
{ {
String8 layer_key = mg_layer_key_from_path(file->string); String8 layer_key = mg_layer_key_from_path(file->string);
@@ -291,7 +291,7 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
if(md_node_has_tag(node, str8_lit("struct"), 0)) if(md_node_has_tag(node, str8_lit("struct"), 0))
@@ -316,10 +316,10 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *tag = md_tag_from_string(node, str8_lit("data"), 0); Node *tag = md_tag_from_string(node, str8_lit("data"), 0);
if(!md_node_is_nil(tag)) if(!md_node_is_nil(tag))
{ {
String8 element_type = tag->first->string; String8 element_type = tag->first->string;
@@ -346,10 +346,10 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *tag = md_tag_from_string(node, str8_lit("enum2string_switch"), 0); Node *tag = md_tag_from_string(node, str8_lit("enum2string_switch"), 0);
if(!md_node_is_nil(tag)) if(!md_node_is_nil(tag))
{ {
String8 enum_type = tag->first->string; String8 enum_type = tag->first->string;
@@ -379,10 +379,10 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
MD_Node *tag = md_tag_from_string(node, str8_lit("gen"), 0); Node *tag = md_tag_from_string(node, str8_lit("gen"), 0);
if(!md_node_is_nil(tag)) if(!md_node_is_nil(tag))
{ {
String8 layer_key = mg_layer_key_from_path(file->string); String8 layer_key = mg_layer_key_from_path(file->string);
@@ -411,7 +411,7 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
if(md_node_has_tag(node, str8_lit("embed_string"), 0)) if(md_node_has_tag(node, str8_lit("embed_string"), 0))
@@ -445,14 +445,14 @@ entry_point(CmdLine *cmdline)
// //
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next) for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{ {
MD_Node *file = n->v.root; Node *file = n->v.root;
for MD_EachNode(node, file->first) for MD_EachNode(node, file->first)
{ {
//- rjf: generate markdown page //- rjf: generate markdown page
if(md_node_has_tag(node, str8_lit("markdown"), 0)) if(md_node_has_tag(node, str8_lit("markdown"), 0))
{ {
String8List md_strs = {0}; String8List md_strs = {0};
for(MD_Node *piece = node->first; !md_node_is_nil(piece); piece = piece->next) for(Node *piece = node->first; !md_node_is_nil(piece); piece = piece->next)
{ {
if(md_node_has_tag(piece, str8_lit("title"), 0)) if(md_node_has_tag(piece, str8_lit("title"), 0))
{ {
examples/expr/expr_c_like.c
+13 -13
View File
@@ -83,7 +83,7 @@ print_expression(FILE *out, MD_Expr *expr)
MD_ExprOpr *op = expr->op; MD_ExprOpr *op = expr->op;
if (op == 0) if (op == 0)
{ {
MD_Node *node = expr->md_node; Node *node = expr->md_node;
if (node->raw_string.size != 0) if (node->raw_string.size != 0)
{ {
fprintf(out, "%.*s", MD_S8VArg(node->raw_string)); fprintf(out, "%.*s", MD_S8VArg(node->raw_string));
@@ -92,27 +92,27 @@ print_expression(FILE *out, MD_Expr *expr)
{ {
char c1 = 0; char c1 = 0;
char c2 = 0; char c2 = 0;
if (node->flags & MD_NodeFlag_HasParenLeft) if (node->flags & NodeFlag_HasParenLeft)
{ {
c1 = '('; c1 = '(';
} }
if (node->flags & MD_NodeFlag_HasBraceLeft) if (node->flags & NodeFlag_HasBraceLeft)
{ {
c1 = '{'; c1 = '{';
} }
if (node->flags & MD_NodeFlag_HasBracketLeft) if (node->flags & NodeFlag_HasBracketLeft)
{ {
c1 = '['; c1 = '[';
} }
if (node->flags & MD_NodeFlag_HasParenRight) if (node->flags & NodeFlag_HasParenRight)
{ {
c2 = ')'; c2 = ')';
} }
if (node->flags & MD_NodeFlag_HasBraceRight) if (node->flags & NodeFlag_HasBraceRight)
{ {
c2 = '}'; c2 = '}';
} }
if (node->flags & MD_NodeFlag_HasBracketRight) if (node->flags & NodeFlag_HasBracketRight)
{ {
c2 = ']'; c2 = ']';
} }
@@ -131,7 +131,7 @@ print_expression(FILE *out, MD_Expr *expr)
{ {
default: default:
{ {
MD_Node *node = expr->md_node; Node *node = expr->md_node;
MD_CodeLoc loc = MD_CodeLocFromNode(node); MD_CodeLoc loc = MD_CodeLocFromNode(node);
MD_PrintMessage(stderr, loc, MD_MessageKind_FatalError, MD_PrintMessage(stderr, loc, MD_MessageKind_FatalError,
MD_S8Lit("this is an unknown kind of operator")); MD_S8Lit("this is an unknown kind of operator"));
@@ -139,7 +139,7 @@ print_expression(FILE *out, MD_Expr *expr)
case MD_ExprOprKind_Prefix: case MD_ExprOprKind_Prefix:
{ {
MD_Node *node = expr->md_node; Node *node = expr->md_node;
fprintf(out, "%.*s(", MD_S8VArg(op->string)); fprintf(out, "%.*s(", MD_S8VArg(op->string));
print_expression(out, expr->unary_operand); print_expression(out, expr->unary_operand);
fprintf(out, ")"); fprintf(out, ")");
@@ -150,7 +150,7 @@ print_expression(FILE *out, MD_Expr *expr)
fprintf(out, "("); fprintf(out, "(");
print_expression(out, expr->unary_operand); print_expression(out, expr->unary_operand);
MD_String8 op_string = op->string; MD_String8 op_string = op->string;
if ((expr->md_node->flags & MD_NodeFlag_MaskSetDelimiters) != 0) if ((expr->md_node->flags & NodeFlag_MaskSetDelimiters) != 0)
{ {
fprintf(out, ")%c...%c", op_string.str[0], op_string.str[1]); fprintf(out, ")%c...%c", op_string.str[0], op_string.str[1]);
} }
@@ -191,13 +191,13 @@ int main(int argc, char **argv)
arena = MD_ArenaAlloc(); arena = MD_ArenaAlloc();
// parse all files passed to the command line // parse all files passed to the command line
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for (int i = 1; i < argc; i += 1) for (int i = 1; i < argc; i += 1)
{ {
// parse the file // parse the file
MD_String8 file_name = MD_S8CString(argv[i]); MD_String8 file_name = MD_S8CString(argv[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// print metadesk errors // print metadesk errors
for (MD_Message *message = parse_result.errors.first; for (MD_Message *message = parse_result.errors.first;
@@ -233,7 +233,7 @@ MD_ExprOprPush(arena, &list, MD_ExprOprKind_##k, p, MD_S8Lit(t), Op##e, 0);
// print the verbose parse results // print the verbose parse results
for (MD_EachNode(root_it, list->first_child)) for (MD_EachNode(root_it, list->first_child))
{ {
MD_Node *root = MD_ResolveNodeFromReference(root_it); Node *root = MD_ResolveNodeFromReference(root_it);
for (MD_EachNode(node, root->first_child)) for (MD_EachNode(node, root->first_child))
{ {
MD_ExprParseResult parse = MD_ExprParse(arena, &table, node->first_child, MD_NilNode()); MD_ExprParseResult parse = MD_ExprParse(arena, &table, node->first_child, MD_NilNode());
examples/expr/expr_intro.c
+8 -8
View File
@@ -40,8 +40,8 @@ print_expression(FILE *out, MD_Expr *expr)
// whether it is a leaf or an operator. This node gives us a way to // whether it is a leaf or an operator. This node gives us a way to
// see information about this leaf, and also gives a way to create an // see information about this leaf, and also gives a way to create an
// MD_CodeLoc for error messages. The same works on operator nodes. // MD_CodeLoc for error messages. The same works on operator nodes.
MD_Node *node = expr->md_node; Node *node = expr->md_node;
if ((node->flags & MD_NodeFlag_MaskSetDelimiters) == 0) if ((node->flags & NodeFlag_MaskSetDelimiters) == 0)
{ {
fprintf(out, "%.*s", MD_S8VArg(node->raw_string)); fprintf(out, "%.*s", MD_S8VArg(node->raw_string));
} }
@@ -86,12 +86,12 @@ eval_expression(MD_Expr *expr)
MD_ExprOpr *op = expr->op; MD_ExprOpr *op = expr->op;
if (op == 0) if (op == 0)
{ {
MD_Node *node = expr->md_node; Node *node = expr->md_node;
if (node->flags & MD_NodeFlag_Numeric) if (node->flags & NodeFlag_Numeric)
{ {
result = MD_CStyleIntFromString(node->string); result = MD_CStyleIntFromString(node->string);
} }
else if (node->flags & MD_NodeFlag_Identifier) else if (node->flags & NodeFlag_Identifier)
{ {
MD_MapSlot *slot = MD_MapLookup(&eval_map, MD_MapKeyStr(node->string)); MD_MapSlot *slot = MD_MapLookup(&eval_map, MD_MapKeyStr(node->string));
if (slot != 0) if (slot != 0)
@@ -140,13 +140,13 @@ int main(int argc, char **argv)
arena = MD_ArenaAlloc(); arena = MD_ArenaAlloc();
// parse all files passed to the command line // parse all files passed to the command line
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for (int i = 1; i < argc; i += 1) for (int i = 1; i < argc; i += 1)
{ {
// parse the file // parse the file
MD_String8 file_name = MD_S8CString(argv[i]); MD_String8 file_name = MD_S8CString(argv[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// print metadesk errors // print metadesk errors
for (MD_Message *message = parse_result.errors.first; for (MD_Message *message = parse_result.errors.first;
@@ -215,7 +215,7 @@ int main(int argc, char **argv)
// init eval map // init eval map
eval_map = MD_MapMake(arena); eval_map = MD_MapMake(arena);
MD_Node *root = MD_ResolveNodeFromReference(root_it); Node *root = MD_ResolveNodeFromReference(root_it);
for (MD_EachNode(node, root->first_child)) for (MD_EachNode(node, root->first_child))
{ {
// @notes An expression parse is an extra stage of analysis on top // @notes An expression parse is an extra stage of analysis on top
examples/integration/memory_management.c
+2 -2
View File
@@ -61,7 +61,7 @@ typedef struct ConfigFile{
MD_Arena *arena; MD_Arena *arena;
MD_String8 file_name; MD_String8 file_name;
MD_String8 contents; MD_String8 contents;
MD_Node *root; Node *root;
MD_MessageList errors; MD_MessageList errors;
} ConfigFile; } ConfigFile;
@@ -86,7 +86,7 @@ new_config_file_from_file_name(char *file_name_cstr)
// explicitly so that we can save the contents and the parse in the // explicitly so that we can save the contents and the parse in the
// ConfigFile. // ConfigFile.
MD_String8 contents = MD_LoadEntireFile(arena, file_name); MD_String8 contents = MD_LoadEntireFile(arena, file_name);
MD_ParseResult parse = MD_ParseWholeString(arena, file_name, contents); ParseResult parse = MD_ParseWholeString(arena, file_name, contents);
// @notes This part can be a little bit subtle. First we allocated the // @notes This part can be a little bit subtle. First we allocated the
// arena with MD_ArenaAlloc. Then we used the arena to allocate a // arena with MD_ArenaAlloc. Then we used the arena to allocate a
examples/integration/multi_threaded.c
+4 -4
View File
@@ -67,7 +67,7 @@ typedef struct ThreadData
// unique-to-thread // unique-to-thread
MD_Arena *arena; MD_Arena *arena;
MD_Node *list; Node *list;
MD_MessageList errors; MD_MessageList errors;
} ThreadData; } ThreadData;
@@ -86,7 +86,7 @@ parse_worker_loop(ThreadData *thread_data)
// load and parse the file specified by this task. // load and parse the file specified by this task.
MD_String8 file_name = MD_S8CString(task->tasks[task_index]); MD_String8 file_name = MD_S8CString(task->tasks[task_index]);
MD_ParseResult parse = MD_ParseWholeFile(thread_data->arena, file_name); ParseResult parse = MD_ParseWholeFile(thread_data->arena, file_name);
MD_MessageListConcat(&thread_data->errors, &parse.errors); MD_MessageListConcat(&thread_data->errors, &parse.errors);
MD_PushNewReference(thread_data->arena, thread_data->list, parse.node); MD_PushNewReference(thread_data->arena, thread_data->list, parse.node);
} }
@@ -186,7 +186,7 @@ main(int argc, char **argv)
// print the name of each root // print the name of each root
for (MD_EachNode(root_it, threads[i].list->first_child)) for (MD_EachNode(root_it, threads[i].list->first_child))
{ {
MD_Node *root = MD_ResolveNodeFromReference(root_it); Node *root = MD_ResolveNodeFromReference(root_it);
fprintf(stdout, "%.*s\n", MD_S8VArg(root->string)); fprintf(stdout, "%.*s\n", MD_S8VArg(root->string));
} }
@@ -221,7 +221,7 @@ main(int argc, char **argv)
// combine results // combine results
MD_Arena *arena = threads[0].arena; MD_Arena *arena = threads[0].arena;
MD_Node *list = threads[0].list; Node *list = threads[0].list;
MD_MessageList errors = threads[0].errors; MD_MessageList errors = threads[0].errors;
for (int i = 1; i < THREAD_COUNT; i += 1) for (int i = 1; i < THREAD_COUNT; i += 1)
{ {
examples/intro/data_desk_like_template.c
+5 -5
View File
@@ -27,7 +27,7 @@ static MD_Arena *arena = 0;
//~ Declare user defined functions (the data desk "custom layer") ////////////// //~ Declare user defined functions (the data desk "custom layer") //////////////
static void Initialize(void); // Runs at the beginning of generation. static void Initialize(void); // Runs at the beginning of generation.
static void TopLevel(MD_Node *node); // Runs once for each top-level node from each file. static void TopLevel(Node *node); // Runs once for each top-level node from each file.
static void CleanUp(void); // Runs at the end of generation. static void CleanUp(void); // Runs at the end of generation.
@@ -40,13 +40,13 @@ int main(int argument_count, char **arguments)
// parse all files passed to the command line // parse all files passed to the command line
MD_b32 failed_parse = 0; MD_b32 failed_parse = 0;
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for(int i = 1; i < argument_count; i += 1) for(int i = 1; i < argument_count; i += 1)
{ {
// parse the file // parse the file
MD_String8 file_name = MD_S8CString(arguments[i]); MD_String8 file_name = MD_S8CString(arguments[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// print metadesk errors // print metadesk errors
for (MD_Message *message = parse_result.errors.first; for (MD_Message *message = parse_result.errors.first;
@@ -73,7 +73,7 @@ int main(int argument_count, char **arguments)
Initialize(); Initialize();
for(MD_EachNode(ref, list->first_child)) for(MD_EachNode(ref, list->first_child))
{ {
MD_Node *root = MD_ResolveNodeFromReference(ref); Node *root = MD_ResolveNodeFromReference(ref);
for(MD_EachNode(node, root->first_child)) for(MD_EachNode(node, root->first_child))
{ {
TopLevel(node); TopLevel(node);
@@ -95,7 +95,7 @@ Initialize(void)
} }
static void static void
TopLevel(MD_Node *node) TopLevel(Node *node)
{ {
/*TODO*/ /*TODO*/
} }
examples/intro/hello_world.c
+1 -1
View File
@@ -20,7 +20,7 @@ main(int argc, char **argv)
// parse a string // parse a string
MD_String8 name = MD_S8Lit("<name>"); MD_String8 name = MD_S8Lit("<name>");
MD_String8 hello_world = MD_S8Lit("hello world"); MD_String8 hello_world = MD_S8Lit("hello world");
MD_ParseResult parse = MD_ParseWholeString(arena, name, hello_world); ParseResult parse = MD_ParseWholeString(arena, name, hello_world);
// print the results // print the results
MD_PrintDebugDumpFromNode(stdout, parse.node, MD_GenerateFlags_All); MD_PrintDebugDumpFromNode(stdout, parse.node, MD_GenerateFlags_All);
examples/intro/parse_check.c
+7 -7
View File
@@ -25,7 +25,7 @@ int main(int argc, char **argv)
arena = MD_ArenaAlloc(); arena = MD_ArenaAlloc();
// parse all files passed to the command line // parse all files passed to the command line
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for (int i = 1; i < argc; i += 1) for (int i = 1; i < argc; i += 1)
{ {
@@ -35,7 +35,7 @@ int main(int argc, char **argv)
// this metadesk's default implementations for the overrides make // this metadesk's default implementations for the overrides make
// this work. // this work.
MD_String8 file_name = MD_S8CString(argv[i]); MD_String8 file_name = MD_S8CString(argv[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// print metadesk errors // print metadesk errors
for (MD_Message *message = parse_result.errors.first; for (MD_Message *message = parse_result.errors.first;
@@ -65,21 +65,21 @@ int main(int argc, char **argv)
// print the verbose parse results // print the verbose parse results
// @notes The Metadesk library provides a macros for iterating chains of // @notes The Metadesk library provides a macros for iterating chains of
// MD_Node as shown here. The first parameter to the macro names an // Node as shown here. The first parameter to the macro names an
// MD_Node pointer in the for loop that iterates through each node in the // Node pointer in the for loop that iterates through each node in the
// list. The second parameter is a pointer to the first node of the list. // list. The second parameter is a pointer to the first node of the list.
// Generally we past the `first_child` of a list or parent MD_Node, but we // Generally we past the `first_child` of a list or parent Node, but we
// don't always have to. // don't always have to.
for (MD_EachNode(root_it, list->first_child)) for (MD_EachNode(root_it, list->first_child))
{ {
// @notes The `list` we have been building does not contain a normal // @notes The `list` we have been building does not contain a normal
// MD_Node chain like in the trees returned from the parser. Instead // Node chain like in the trees returned from the parser. Instead
// it contains a chain of 'reference' nodes, which can point to any // it contains a chain of 'reference' nodes, which can point to any
// metadesk node from a previous parse. So our `root_it` is iterating // metadesk node from a previous parse. So our `root_it` is iterating
// a list of reference nodes. Here we resolve the reference node to // a list of reference nodes. Here we resolve the reference node to
// get the root of the parse tree. // get the root of the parse tree.
MD_Node *root = MD_ResolveNodeFromReference(root_it); Node *root = MD_ResolveNodeFromReference(root_it);
for (MD_EachNode(node, root->first_child)) for (MD_EachNode(node, root->first_child))
{ {
examples/type_metadata/type_metadata.c
+48 -48
View File
@@ -59,7 +59,7 @@ FILE *error_file = 0;
// @notes As we analyze the Metadesk tree we create more data. In this example // @notes As we analyze the Metadesk tree we create more data. In this example
// the new data is stored in two major types GEN_TypeInfo and GEN_MapInfo. // the new data is stored in two major types GEN_TypeInfo and GEN_MapInfo.
// We form a list for each type of these "processed" types holds a pointer // We form a list for each type of these "processed" types holds a pointer
// back to the original MD_Node that generated it, and room for information // back to the original Node that generated it, and room for information
// that will be equiped to the "processed" type in later stages of analysis. // that will be equiped to the "processed" type in later stages of analysis.
// We also use the MD_Map helper to create a string -> pointer mapping so that // We also use the MD_Map helper to create a string -> pointer mapping so that
// we can look up the "processed" info pointers by name after the initial // we can look up the "processed" info pointers by name after the initial
@@ -76,11 +76,11 @@ MD_Map map_map = {0};
//~ helpers /////////////////////////////////////////////////////////////////// //~ helpers ///////////////////////////////////////////////////////////////////
MD_Node* Node*
gen_get_child_value(MD_Node *parent, MD_String8 child_name) gen_get_child_value(Node *parent, MD_String8 child_name)
{ {
MD_Node *child = MD_ChildFromString(parent, child_name, 0); Node *child = MD_ChildFromString(parent, child_name, 0);
MD_Node *result = child->first_child; Node *result = child->first_child;
return(result); return(result);
} }
@@ -103,7 +103,7 @@ gen_resolve_type_info_from_string(MD_String8 name)
} }
GEN_TypeInfo* GEN_TypeInfo*
gen_resolve_type_info_from_referencer(MD_Node *reference) gen_resolve_type_info_from_referencer(Node *reference)
{ {
GEN_TypeInfo *result = gen_resolve_type_info_from_string(reference->string); GEN_TypeInfo *result = gen_resolve_type_info_from_string(reference->string);
return(result); return(result);
@@ -143,10 +143,10 @@ gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant)
return(result); return(result);
} }
MD_Node* Node*
gen_get_symbol_md_node_by_name(MD_String8 name) gen_get_symbol_md_node_by_name(MD_String8 name)
{ {
MD_Node *result = MD_NilNode(); Node *result = MD_NilNode();
MD_MapSlot *type_slot = MD_MapLookup(&type_map, MD_MapKeyStr(name)); MD_MapSlot *type_slot = MD_MapLookup(&type_map, MD_MapKeyStr(name));
if (type_slot != 0) if (type_slot != 0)
{ {
@@ -163,7 +163,7 @@ gen_get_symbol_md_node_by_name(MD_String8 name)
} }
void void
gen_type_resolve_error(MD_Node *reference) gen_type_resolve_error(Node *reference)
{ {
MD_CodeLoc loc = MD_CodeLocFromNode(reference); MD_CodeLoc loc = MD_CodeLocFromNode(reference);
MD_PrintMessageFmt(error_file, loc, MD_MessageKind_Error, MD_PrintMessageFmt(error_file, loc, MD_MessageKind_Error,
@@ -171,7 +171,7 @@ gen_type_resolve_error(MD_Node *reference)
} }
void void
gen_duplicate_symbol_error(MD_Node *new_node, MD_Node *existing_node) gen_duplicate_symbol_error(Node *new_node, Node *existing_node)
{ {
MD_CodeLoc loc = MD_CodeLocFromNode(new_node); MD_CodeLoc loc = MD_CodeLocFromNode(new_node);
MD_PrintMessageFmt(error_file, loc, MD_MessageKind_Error, MD_PrintMessageFmt(error_file, loc, MD_MessageKind_Error,
@@ -184,9 +184,9 @@ gen_duplicate_symbol_error(MD_Node *new_node, MD_Node *existing_node)
} }
void void
gen_check_and_do_duplicate_symbol_error(MD_Node *new_node) gen_check_and_do_duplicate_symbol_error(Node *new_node)
{ {
MD_Node *existing = gen_get_symbol_md_node_by_name(new_node->string); Node *existing = gen_get_symbol_md_node_by_name(new_node->string);
if (!MD_NodeIsNil(existing)) if (!MD_NodeIsNil(existing))
{ {
gen_duplicate_symbol_error(new_node, existing); gen_duplicate_symbol_error(new_node, existing);
@@ -206,22 +206,22 @@ gen_check_and_do_duplicate_symbol_error(MD_Node *new_node)
// where the kind field is not one of the expected values. // where the kind field is not one of the expected values.
void void
gen_gather_types_and_maps(MD_Node *list) gen_gather_types_and_maps(Node *list)
{ {
for(MD_EachNode(ref, list->first_child)) for(MD_EachNode(ref, list->first_child))
{ {
MD_Node *root = MD_ResolveNodeFromReference(ref); Node *root = MD_ResolveNodeFromReference(ref);
for(MD_EachNode(node, root->first_child)) for(MD_EachNode(node, root->first_child))
{ {
// gather type // gather type
MD_Node *type_tag = MD_TagFromString(node, MD_S8Lit("type"), 0); Node *type_tag = MD_TagFromString(node, MD_S8Lit("type"), 0);
if (!MD_NodeIsNil(type_tag)) if (!MD_NodeIsNil(type_tag))
{ {
gen_check_and_do_duplicate_symbol_error(node); gen_check_and_do_duplicate_symbol_error(node);
GEN_TypeKind kind = GEN_TypeKind_Null; GEN_TypeKind kind = GEN_TypeKind_Null;
MD_Node *tag_arg_node = type_tag->first_child; Node *tag_arg_node = type_tag->first_child;
MD_String8 tag_arg_str = tag_arg_node->string; MD_String8 tag_arg_str = tag_arg_node->string;
if (MD_S8Match(tag_arg_str, MD_S8Lit("basic"), 0)) if (MD_S8Match(tag_arg_str, MD_S8Lit("basic"), 0))
{ {
@@ -274,7 +274,7 @@ gen_check_duplicate_member_names(void)
type != 0; type != 0;
type = type->next) type = type->next)
{ {
MD_Node *type_root_node = type->node; Node *type_root_node = type->node;
for (MD_EachNode(member_node, type_root_node->first_child)) for (MD_EachNode(member_node, type_root_node->first_child))
{ {
MD_String8 name = member_node->string; MD_String8 name = member_node->string;
@@ -315,8 +315,8 @@ gen_equip_basic_type_size(void)
// extract the size // extract the size
int size = 0; int size = 0;
MD_Node *size_node = type->node->first_child; Node *size_node = type->node->first_child;
MD_Node *error_at = 0; Node *error_at = 0;
if (MD_NodeIsNil(size_node)) if (MD_NodeIsNil(size_node))
{ {
error_at = type->node; error_at = type->node;
@@ -361,10 +361,10 @@ gen_equip_struct_members(void)
GEN_TypeMember *last_member = 0; GEN_TypeMember *last_member = 0;
int member_count = 0; int member_count = 0;
MD_Node *type_root_node = type->node; Node *type_root_node = type->node;
for (MD_EachNode(member_node, type_root_node->first_child)) for (MD_EachNode(member_node, type_root_node->first_child))
{ {
MD_Node *type_name_node = member_node->first_child; Node *type_name_node = member_node->first_child;
// missing type node? // missing type node?
if (MD_NodeIsNil(type_name_node)) if (MD_NodeIsNil(type_name_node))
@@ -392,10 +392,10 @@ gen_equip_struct_members(void)
if (got_list) if (got_list)
{ {
GEN_TypeMember *array_count = 0; GEN_TypeMember *array_count = 0;
MD_Node *array_tag = MD_TagFromString(type_name_node, MD_S8Lit("array"), 0); Node *array_tag = MD_TagFromString(type_name_node, MD_S8Lit("array"), 0);
if (!MD_NodeIsNil(array_tag)) if (!MD_NodeIsNil(array_tag))
{ {
MD_Node *array_count_referencer = array_tag->first_child; Node *array_count_referencer = array_tag->first_child;
if (array_count_referencer->string.size == 0) if (array_count_referencer->string.size == 0)
{ {
MD_CodeLoc loc = MD_CodeLocFromNode(array_tag); MD_CodeLoc loc = MD_CodeLocFromNode(array_tag);
@@ -404,7 +404,7 @@ gen_equip_struct_members(void)
} }
else else
{ {
MD_Node *array_count_member_node = Node *array_count_member_node =
MD_ChildFromString(type_root_node, array_count_referencer->string, 0); MD_ChildFromString(type_root_node, array_count_referencer->string, 0);
if (MD_NodeIsNil(array_count_member_node)) if (MD_NodeIsNil(array_count_member_node))
{ {
@@ -471,10 +471,10 @@ gen_equip_enum_underlying_type(void)
// extract underlying type // extract underlying type
GEN_TypeInfo *underlying_type = 0; GEN_TypeInfo *underlying_type = 0;
MD_Node *type_node = type->node; Node *type_node = type->node;
MD_Node *type_tag = MD_TagFromString(type_node, MD_S8Lit("type"), 0); Node *type_tag = MD_TagFromString(type_node, MD_S8Lit("type"), 0);
MD_Node *type_tag_param = type_tag->first_child; Node *type_tag_param = type_tag->first_child;
MD_Node *underlying_type_ref = type_tag_param->first_child; Node *underlying_type_ref = type_tag_param->first_child;
if (!MD_NodeIsNil(underlying_type_ref)) if (!MD_NodeIsNil(underlying_type_ref))
{ {
GEN_TypeInfo *resolved_type = gen_resolve_type_info_from_referencer(underlying_type_ref); GEN_TypeInfo *resolved_type = gen_resolve_type_info_from_referencer(underlying_type_ref);
@@ -522,10 +522,10 @@ gen_equip_enum_members(void)
int next_implicit_value = 0; int next_implicit_value = 0;
MD_Node *type_root_node = type->node; Node *type_root_node = type->node;
for (MD_EachNode(enumerant_node, type_root_node->first_child)) for (MD_EachNode(enumerant_node, type_root_node->first_child))
{ {
MD_Node *value_node = enumerant_node->first_child; Node *value_node = enumerant_node->first_child;
int value = 0; int value = 0;
// missing value node? // missing value node?
@@ -581,19 +581,19 @@ gen_equip_map_in_out_types(void)
map != 0; map != 0;
map = map->next) map = map->next)
{ {
MD_Node *map_root_node = map->node; Node *map_root_node = map->node;
MD_Node *map_tag = MD_TagFromString(map_root_node, MD_S8Lit("map"), 0); Node *map_tag = MD_TagFromString(map_root_node, MD_S8Lit("map"), 0);
// NOTE we could use an expression parser here to make this fancier // NOTE we could use an expression parser here to make this fancier
// and check for the 'In -> Out' semicolon delimited syntax more // and check for the 'In -> Out' semicolon delimited syntax more
// carefully, this isn't checking it very rigorously. But there are // carefully, this isn't checking it very rigorously. But there are
// no other cases we need to expect so far so being a bit sloppy // no other cases we need to expect so far so being a bit sloppy
// buys us a lot of simplicity. // buys us a lot of simplicity.
MD_Node *in_node = map_tag->first_child; Node *in_node = map_tag->first_child;
MD_Node *arrow = in_node->next; Node *arrow = in_node->next;
MD_Node *out_node = arrow->next; Node *out_node = arrow->next;
{ {
MD_Node *error_at = 0; Node *error_at = 0;
if (MD_NodeIsNil(in_node)) if (MD_NodeIsNil(in_node))
{ {
error_at = map_tag; error_at = map_tag;
@@ -666,8 +666,8 @@ gen_equip_map_in_out_types(void)
// check for named children in the map tag // check for named children in the map tag
int is_complete = MD_NodeHasChild(map_tag, MD_S8Lit("complete"), 0); int is_complete = MD_NodeHasChild(map_tag, MD_S8Lit("complete"), 0);
MD_Node *default_val = gen_get_child_value(map_tag, MD_S8Lit("default")); Node *default_val = gen_get_child_value(map_tag, MD_S8Lit("default"));
MD_Node *auto_val = gen_get_child_value(map_tag, MD_S8Lit("auto")); Node *auto_val = gen_get_child_value(map_tag, MD_S8Lit("auto"));
// save to map // save to map
map->typed_map = typed_map; map->typed_map = typed_map;
@@ -697,16 +697,16 @@ gen_equip_map_cases(void)
GEN_MapCase *last_case = 0; GEN_MapCase *last_case = 0;
int case_count = 0; int case_count = 0;
MD_Node *map_root_node = map->node; Node *map_root_node = map->node;
for (MD_Node *case_node = map_root_node->first_child; for (Node *case_node = map_root_node->first_child;
!MD_NodeIsNil(case_node); !MD_NodeIsNil(case_node);
case_node = MD_FirstNodeWithFlags(case_node->next, MD_NodeFlag_IsAfterComma)) case_node = MD_FirstNodeWithFlags(case_node->next, NodeFlag_IsAfterComma))
{ {
// extract in & out // extract in & out
MD_Node *in = case_node; Node *in = case_node;
MD_Node *arrow = in->next; Node *arrow = in->next;
MD_Node *out = arrow->next; Node *out = arrow->next;
if (!MD_S8Match(arrow->string, MD_S8Lit("->"), 0) || if (!MD_S8Match(arrow->string, MD_S8Lit("->"), 0) ||
MD_NodeIsNil(out)) MD_NodeIsNil(out))
{ {
@@ -1237,12 +1237,12 @@ main(int argc, char **argv)
error_file = stderr; error_file = stderr;
// parse all files passed to the command line // parse all files passed to the command line
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for (int i = 1; i < argc; i += 1) for (int i = 1; i < argc; i += 1)
{ {
// parse the file // parse the file
MD_String8 file_name = MD_S8CString(argv[i]); MD_String8 file_name = MD_S8CString(argv[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// print metadesk errors // print metadesk errors
for (MD_Message *message = parse_result.errors.first; for (MD_Message *message = parse_result.errors.first;
@@ -1323,7 +1323,7 @@ main(int argc, char **argv)
case GEN_TypeKind_Enum: kind_string = "enum"; break; case GEN_TypeKind_Enum: kind_string = "enum"; break;
} }
MD_Node *node = type->node; Node *node = type->node;
printf("%.*s: %s\n", MD_S8VArg(node->string), kind_string); printf("%.*s: %s\n", MD_S8VArg(node->string), kind_string);
// print member lists // print member lists
@@ -1351,7 +1351,7 @@ main(int argc, char **argv)
map != 0; map != 0;
map = map->next) map = map->next)
{ {
MD_Node *node = map->node; Node *node = map->node;
printf("%.*s: map\n", MD_S8VArg(node->string)); printf("%.*s: map\n", MD_S8VArg(node->string));
// print case list // print case list
examples/type_metadata/type_metadata.h
+15 -15
View File
@@ -24,7 +24,7 @@ struct GEN_TypeInfo
{ {
GEN_TypeInfo *next; GEN_TypeInfo *next;
GEN_TypeKind kind; GEN_TypeKind kind;
MD_Node *node; Node *node;
// basic // basic
int size; int size;
@@ -45,10 +45,10 @@ typedef struct GEN_TypeMember GEN_TypeMember;
struct GEN_TypeMember struct GEN_TypeMember
{ {
GEN_TypeMember *next; GEN_TypeMember *next;
MD_Node *node; Node *node;
GEN_TypeInfo *type; GEN_TypeInfo *type;
struct GEN_TypeMember *array_count; struct GEN_TypeMember *array_count;
//MD_Node *array_count; //Node *array_count;
int member_index; int member_index;
}; };
@@ -56,7 +56,7 @@ typedef struct GEN_TypeEnumerant GEN_TypeEnumerant;
struct GEN_TypeEnumerant struct GEN_TypeEnumerant
{ {
GEN_TypeEnumerant *next; GEN_TypeEnumerant *next;
MD_Node *node; Node *node;
int value; int value;
}; };
@@ -64,13 +64,13 @@ typedef struct GEN_MapInfo GEN_MapInfo;
struct GEN_MapInfo struct GEN_MapInfo
{ {
GEN_MapInfo *next; GEN_MapInfo *next;
MD_Node *node; Node *node;
struct GEN_TypedMapInfo *typed_map; struct GEN_TypedMapInfo *typed_map;
int is_complete; int is_complete;
MD_Node *default_val; Node *default_val;
MD_Node *auto_val; Node *auto_val;
struct GEN_MapCase *first_case; struct GEN_MapCase *first_case;
struct GEN_MapCase *last_case; struct GEN_MapCase *last_case;
@@ -95,29 +95,29 @@ struct GEN_MapCase
{ {
GEN_MapCase *next; GEN_MapCase *next;
GEN_TypeEnumerant *in_enumerant; GEN_TypeEnumerant *in_enumerant;
MD_Node *out; Node *out;
}; };
//~ helpers /////////////////////////////////////////////////////////////////// //~ helpers ///////////////////////////////////////////////////////////////////
MD_Node* gen_get_child_value(MD_Node *parent, MD_String8 child_name); Node* gen_get_child_value(Node *parent, MD_String8 child_name);
GEN_TypeInfo* gen_resolve_type_info_from_string(MD_String8 name); GEN_TypeInfo* gen_resolve_type_info_from_string(MD_String8 name);
GEN_TypeInfo* gen_resolve_type_info_from_referencer(MD_Node *reference); GEN_TypeInfo* gen_resolve_type_info_from_referencer(Node *reference);
GEN_TypeEnumerant* gen_enumerant_from_name(GEN_TypeInfo *enum_type, MD_String8 name); GEN_TypeEnumerant* gen_enumerant_from_name(GEN_TypeInfo *enum_type, MD_String8 name);
GEN_MapCase* gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant); GEN_MapCase* gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant);
MD_Node* gen_get_symbol_md_node_by_name(MD_String8 name); Node* gen_get_symbol_md_node_by_name(MD_String8 name);
void gen_type_resolve_error(MD_Node *reference); void gen_type_resolve_error(Node *reference);
void gen_duplicate_symbol_error(MD_Node *new_node, MD_Node *existing_node); void gen_duplicate_symbol_error(Node *new_node, Node *existing_node);
void gen_check_and_do_duplicate_symbol_error(MD_Node *new_node); void gen_check_and_do_duplicate_symbol_error(Node *new_node);
//~ analyzers ///////////////////////////////////////////////////////////////// //~ analyzers /////////////////////////////////////////////////////////////////
void gen_gather_types_and_maps(MD_Node *list); void gen_gather_types_and_maps(Node *list);
void gen_check_duplicate_member_names(void); void gen_check_duplicate_member_names(void);
void gen_equip_basic_type_size(void); void gen_equip_basic_type_size(void);
void gen_equip_struct_members(void); void gen_equip_struct_members(void);
examples/user_errors/user_errors.c
+6 -6
View File
@@ -28,12 +28,12 @@ int main(int argc, char **argv)
arena = MD_ArenaAlloc(); arena = MD_ArenaAlloc();
// parse all files passed to the command line // parse all files passed to the command line
MD_Node *list = MD_MakeList(arena); Node *list = MD_MakeList(arena);
for(int i = 1; i < argc; i += 1) for(int i = 1; i < argc; i += 1)
{ {
// parse the file // parse the file
MD_String8 file_name = MD_S8CString(argv[i]); MD_String8 file_name = MD_S8CString(argv[i]);
MD_ParseResult parse_result = MD_ParseWholeFile(arena, file_name); ParseResult parse_result = MD_ParseWholeFile(arena, file_name);
// @notes Here we are printing out all the messages that came back from // @notes Here we are printing out all the messages that came back from
// the parser. We could try to wait and print all the errors at once, // the parser. We could try to wait and print all the errors at once,
@@ -60,7 +60,7 @@ int main(int argc, char **argv)
// check for custom errors // check for custom errors
for(MD_EachNode(ref, list->first_child)) for(MD_EachNode(ref, list->first_child))
{ {
MD_Node *root = MD_ResolveNodeFromReference(ref); Node *root = MD_ResolveNodeFromReference(ref);
// @notes The custom rules in this example apply to the top level nodes // @notes The custom rules in this example apply to the top level nodes
// so we can check for them by visiting each node from the root. // so we can check for them by visiting each node from the root.
@@ -74,7 +74,7 @@ int main(int argc, char **argv)
// as an array and access it by index. If there's a tag at index 1 // as an array and access it by index. If there's a tag at index 1
// then we know there are at least two tags, which is against // then we know there are at least two tags, which is against
// the first custom rule. // the first custom rule.
MD_Node *tag_2 = MD_TagFromIndex(node, 1); Node *tag_2 = MD_TagFromIndex(node, 1);
if (!MD_NodeIsNil(tag_2)) if (!MD_NodeIsNil(tag_2))
{ {
// @notes The MD_PrintMessage helper formats a message for us // @notes The MD_PrintMessage helper formats a message for us
@@ -97,8 +97,8 @@ int main(int argc, char **argv)
// @notes The second custom rule applies to sets with "[]" // @notes The second custom rule applies to sets with "[]"
// delimiters. We can easily detect nodes for those sets by // delimiters. We can easily detect nodes for those sets by
// checking the node flags: // checking the node flags:
if ((node->flags & MD_NodeFlag_HasBracketLeft) || if ((node->flags & NodeFlag_HasBracketLeft) ||
(node->flags & MD_NodeFlag_HasBracketRight)) (node->flags & NodeFlag_HasBracketRight))
{ {
if (node->string.size > 0) if (node->string.size > 0)
{ {
source/md.c
+215 -215
View File
File diff suppressed because it is too large Load Diff
source/md.h
+114 -114
View File
@@ -548,88 +548,88 @@ MD_IdentifierStyle;
//~ Node types that are used to build all ASTs. //~ Node types that are used to build all ASTs.
typedef enum MD_NodeKind typedef enum NodeKind
{ {
// NOTE(rjf): @maintenance Must be kept in sync with MD_StringFromNodeKind. // NOTE(rjf): @maintenance Must be kept in sync with MD_StringFromNodeKind.
MD_NodeKind_Nil, NodeKind_Nil,
// NOTE(rjf): Generated by parser // NOTE(rjf): Generated by parser
MD_NodeKind_File, NodeKind_File,
MD_NodeKind_ErrorMarker, NodeKind_ErrorMarker,
// NOTE(rjf): Parsed from user Metadesk code // NOTE(rjf): Parsed from user Metadesk code
MD_NodeKind_Main, NodeKind_Main,
MD_NodeKind_Tag, NodeKind_Tag,
// NOTE(rjf): User-created data structures // NOTE(rjf): User-created data structures
MD_NodeKind_List, NodeKind_List,
MD_NodeKind_Reference, NodeKind_Reference,
MD_NodeKind_COUNT, NodeKind_COUNT,
} }
MD_NodeKind; NodeKind;
typedef MD_u64 MD_NodeFlags; typedef MD_u64 NodeFlags;
#define MD_NodeFlag_AfterFromBefore(f) ((f) << 1) #define NodeFlag_AfterFromBefore(f) ((f) << 1)
enum enum
{ {
// NOTE(rjf): @maintenance Must be kept in sync with MD_StringListFromNodeFlags. // NOTE(rjf): @maintenance Must be kept in sync with MD_StringListFromNodeFlags.
// NOTE(rjf): @maintenance Because of MD_NodeFlag_AfterFromBefore, it is // NOTE(rjf): @maintenance Because of NodeFlag_AfterFromBefore, it is
// *required* that every single pair of "Before*" or "After*" flags be in // *required* that every single pair of "Before*" or "After*" flags be in
// the correct order which is that the Before* flag comes first, and the // the correct order which is that the Before* flag comes first, and the
// After* flag comes immediately after (After* being the more significant // After* flag comes immediately after (After* being the more significant
// bit). // bit).
MD_NodeFlag_HasParenLeft = (1<<0), NodeFlag_HasParenLeft = (1<<0),
MD_NodeFlag_HasParenRight = (1<<1), NodeFlag_HasParenRight = (1<<1),
MD_NodeFlag_HasBracketLeft = (1<<2), NodeFlag_HasBracketLeft = (1<<2),
MD_NodeFlag_HasBracketRight = (1<<3), NodeFlag_HasBracketRight = (1<<3),
MD_NodeFlag_HasBraceLeft = (1<<4), NodeFlag_HasBraceLeft = (1<<4),
MD_NodeFlag_HasBraceRight = (1<<5), NodeFlag_HasBraceRight = (1<<5),
MD_NodeFlag_MaskSetDelimiters = (0x3F<<0), NodeFlag_MaskSetDelimiters = (0x3F<<0),
MD_NodeFlag_IsBeforeSemicolon = (1<<6), NodeFlag_IsBeforeSemicolon = (1<<6),
MD_NodeFlag_IsAfterSemicolon = (1<<7), NodeFlag_IsAfterSemicolon = (1<<7),
MD_NodeFlag_IsBeforeComma = (1<<8), NodeFlag_IsBeforeComma = (1<<8),
MD_NodeFlag_IsAfterComma = (1<<9), NodeFlag_IsAfterComma = (1<<9),
MD_NodeFlag_MaskSeperators = (0xF<<6), NodeFlag_MaskSeperators = (0xF<<6),
MD_NodeFlag_StringSingleQuote = (1<<10), NodeFlag_StringSingleQuote = (1<<10),
MD_NodeFlag_StringDoubleQuote = (1<<11), NodeFlag_StringDoubleQuote = (1<<11),
MD_NodeFlag_StringTick = (1<<12), NodeFlag_StringTick = (1<<12),
MD_NodeFlag_StringTriplet = (1<<13), NodeFlag_StringTriplet = (1<<13),
MD_NodeFlag_MaskStringDelimiters = (0xF<<10), NodeFlag_MaskStringDelimiters = (0xF<<10),
MD_NodeFlag_Numeric = (1<<14), NodeFlag_Numeric = (1<<14),
MD_NodeFlag_Identifier = (1<<15), NodeFlag_Identifier = (1<<15),
MD_NodeFlag_StringLiteral = (1<<16), NodeFlag_StringLiteral = (1<<16),
MD_NodeFlag_Symbol = (1<<17), NodeFlag_Symbol = (1<<17),
MD_NodeFlag_MaskLabelKind = (0xF<<14), NodeFlag_MaskLabelKind = (0xF<<14),
}; };
typedef struct MD_Node MD_Node; typedef struct Node Node;
struct MD_Node struct Node
{ {
// Tree relationship data. // Tree relationship data.
MD_Node *next; Node *next;
MD_Node *prev; Node *prev;
MD_Node *parent; Node *parent;
MD_Node *first_child; Node *first_child;
MD_Node *last_child; Node *last_child;
// Tag list. // Tag list.
MD_Node *first_tag; Node *first_tag;
MD_Node *last_tag; Node *last_tag;
// Node info. // Node info.
MD_NodeKind kind; NodeKind kind;
MD_NodeFlags flags; NodeFlags flags;
MD_String8 string; MD_String8 string;
MD_String8 raw_string; MD_String8 raw_string;
@@ -637,7 +637,7 @@ struct MD_Node
MD_u64 offset; MD_u64 offset;
// Reference. // Reference.
MD_Node *ref_target; Node *ref_target;
// Comments. // Comments.
// @usage prev_comment/next_comment should be considered "hidden". Rely on // @usage prev_comment/next_comment should be considered "hidden". Rely on
@@ -710,26 +710,26 @@ enum
typedef MD_u32 MD_TokenGroups; typedef MD_u32 MD_TokenGroups;
enum enum
{ {
MD_TokenGroup_Comment = MD_TokenKind_Comment, TokenGroup_Comment = MD_TokenKind_Comment,
MD_TokenGroup_Whitespace = (MD_TokenKind_Whitespace| TokenGroup_Whitespace = (MD_TokenKind_Whitespace|
MD_TokenKind_Newline), MD_TokenKind_Newline),
MD_TokenGroup_Irregular = (MD_TokenGroup_Comment| TokenGroup_Irregular = (TokenGroup_Comment|
MD_TokenGroup_Whitespace), TokenGroup_Whitespace),
MD_TokenGroup_Regular = ~MD_TokenGroup_Irregular, TokenGroup_Regular = ~TokenGroup_Irregular,
MD_TokenGroup_Label = (MD_TokenKind_Identifier| TokenGroup_Label = (MD_TokenKind_Identifier|
MD_TokenKind_Numeric| MD_TokenKind_Numeric|
MD_TokenKind_StringLiteral| MD_TokenKind_StringLiteral|
MD_TokenKind_Symbol), MD_TokenKind_Symbol),
MD_TokenGroup_Error = (MD_TokenKind_BrokenComment| TokenGroup_Error = (MD_TokenKind_BrokenComment|
MD_TokenKind_BrokenStringLiteral| MD_TokenKind_BrokenStringLiteral|
MD_TokenKind_BadCharacter), MD_TokenKind_BadCharacter),
}; };
typedef struct MD_Token MD_Token; typedef struct Token Token;
struct MD_Token struct Token
{ {
MD_TokenKind kind; MD_TokenKind kind;
MD_NodeFlags node_flags; NodeFlags node_flags;
MD_String8 string; MD_String8 string;
MD_String8 raw_string; MD_String8 raw_string;
}; };
@@ -752,7 +752,7 @@ typedef struct MD_Message MD_Message;
struct MD_Message struct MD_Message
{ {
MD_Message *next; MD_Message *next;
MD_Node *node; Node *node;
MD_MessageKind kind; MD_MessageKind kind;
MD_String8 string; MD_String8 string;
void *user_ptr; void *user_ptr;
@@ -774,10 +774,10 @@ typedef enum MD_ParseSetRule
MD_ParseSetRule_Global, MD_ParseSetRule_Global,
} MD_ParseSetRule; } MD_ParseSetRule;
typedef struct MD_ParseResult MD_ParseResult; typedef struct ParseResult ParseResult;
struct MD_ParseResult struct ParseResult
{ {
MD_Node *node; Node *node;
MD_u64 string_advance; MD_u64 string_advance;
MD_MessageList errors; MD_MessageList errors;
}; };
@@ -831,7 +831,7 @@ struct MD_Expr
}; };
struct MD_Expr *right; struct MD_Expr *right;
MD_ExprOpr *op; MD_ExprOpr *op;
MD_Node *md_node; Node *md_node;
}; };
typedef struct MD_ExprParseResult MD_ExprParseResult; typedef struct MD_ExprParseResult MD_ExprParseResult;
@@ -852,7 +852,7 @@ struct MD_ExprParseCtx
struct struct
{ {
MD_ExprOpr *postfix_set_ops[MD_POSTFIX_SETLIKE_OP_COUNT]; MD_ExprOpr *postfix_set_ops[MD_POSTFIX_SETLIKE_OP_COUNT];
MD_NodeFlags postfix_set_flags[MD_POSTFIX_SETLIKE_OP_COUNT]; NodeFlags postfix_set_flags[MD_POSTFIX_SETLIKE_OP_COUNT];
} accel; } accel;
#undef MD_POSTFIX_SETLIKE_OP_COUNT #undef MD_POSTFIX_SETLIKE_OP_COUNT
@@ -1060,8 +1060,8 @@ MD_FUNCTION MD_String8 MD_CStyleHexStringFromU64(MD_Arena *arena, MD_u64 x, MD_b
//~ Enum/Flag Strings //~ Enum/Flag Strings
MD_FUNCTION MD_String8 MD_StringFromNodeKind(MD_NodeKind kind); MD_FUNCTION MD_String8 MD_StringFromNodeKind(NodeKind kind);
MD_FUNCTION MD_String8List MD_StringListFromNodeFlags(MD_Arena *arena, MD_NodeFlags flags); MD_FUNCTION MD_String8List MD_StringListFromNodeFlags(MD_Arena *arena, NodeFlags flags);
//~ Map Table Data Structure //~ Map Table Data Structure
@@ -1080,25 +1080,25 @@ MD_FUNCTION MD_MapSlot* MD_MapOverwrite(MD_Arena *arena, MD_Map *map, MD_MapKey
//~ Parsing //~ Parsing
MD_FUNCTION MD_Token MD_TokenFromString(MD_String8 string); MD_FUNCTION Token MD_TokenFromString(MD_String8 string);
MD_FUNCTION MD_u64 MD_LexAdvanceFromSkips(MD_String8 string, MD_TokenKind skip_kinds); MD_FUNCTION MD_u64 MD_LexAdvanceFromSkips(MD_String8 string, MD_TokenKind skip_kinds);
MD_FUNCTION MD_ParseResult MD_ParseResultZero(void); MD_FUNCTION ParseResult MD_ParseResultZero(void);
MD_FUNCTION MD_ParseResult MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *parent, MD_FUNCTION ParseResult MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, Node *parent,
MD_ParseSetRule rule); MD_ParseSetRule rule);
MD_FUNCTION MD_ParseResult MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset); MD_FUNCTION ParseResult MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset);
MD_FUNCTION MD_ParseResult MD_ParseWholeString(MD_Arena *arena, MD_String8 filename, MD_String8 contents); MD_FUNCTION ParseResult MD_ParseWholeString(MD_Arena *arena, MD_String8 filename, MD_String8 contents);
MD_FUNCTION MD_ParseResult MD_ParseWholeFile(MD_Arena *arena, MD_String8 filename); MD_FUNCTION ParseResult MD_ParseWholeFile(MD_Arena *arena, MD_String8 filename);
//~ Messages (Errors/Warnings) //~ Messages (Errors/Warnings)
MD_FUNCTION MD_Node* MD_MakeErrorMarkerNode(MD_Arena *arena, MD_String8 parse_contents, MD_FUNCTION Node* MD_MakeErrorMarkerNode(MD_Arena *arena, MD_String8 parse_contents,
MD_u64 offset); MD_u64 offset);
MD_FUNCTION MD_Message*MD_MakeNodeError(MD_Arena *arena, MD_Node *node, MD_FUNCTION MD_Message*MD_MakeNodeError(MD_Arena *arena, Node *node,
MD_MessageKind kind, MD_String8 str); MD_MessageKind kind, MD_String8 str);
MD_FUNCTION MD_Message*MD_MakeTokenError(MD_Arena *arena, MD_String8 parse_contents, MD_FUNCTION MD_Message*MD_MakeTokenError(MD_Arena *arena, MD_String8 parse_contents,
MD_Token token, MD_MessageKind kind, Token token, MD_MessageKind kind,
MD_String8 str); MD_String8 str);
MD_FUNCTION void MD_MessageListPush(MD_MessageList *list, MD_Message *message); MD_FUNCTION void MD_MessageListPush(MD_MessageList *list, MD_Message *message);
@@ -1107,49 +1107,49 @@ MD_FUNCTION void MD_MessageListConcat(MD_MessageList *list, MD_MessageList
//~ Location Conversion //~ Location Conversion
MD_FUNCTION MD_CodeLoc MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u64 offset); MD_FUNCTION MD_CodeLoc MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u64 offset);
MD_FUNCTION MD_CodeLoc MD_CodeLocFromNode(MD_Node *node); MD_FUNCTION MD_CodeLoc MD_CodeLocFromNode(Node *node);
//~ Tree/List Building //~ Tree/List Building
MD_FUNCTION MD_b32 MD_NodeIsNil(MD_Node *node); MD_FUNCTION MD_b32 MD_NodeIsNil(Node *node);
MD_FUNCTION MD_Node *MD_NilNode(void); MD_FUNCTION Node *MD_NilNode(void);
MD_FUNCTION MD_Node *MD_MakeNode(MD_Arena *arena, MD_NodeKind kind, MD_String8 string, MD_FUNCTION Node *MD_MakeNode(MD_Arena *arena, NodeKind kind, MD_String8 string,
MD_String8 raw_string, MD_u64 offset); MD_String8 raw_string, MD_u64 offset);
MD_FUNCTION void MD_PushChild(MD_Node *parent, MD_Node *new_child); MD_FUNCTION void MD_PushChild(Node *parent, Node *new_child);
MD_FUNCTION void MD_PushTag(MD_Node *node, MD_Node *tag); MD_FUNCTION void MD_PushTag(Node *node, Node *tag);
MD_FUNCTION MD_Node *MD_MakeList(MD_Arena *arena); MD_FUNCTION Node *MD_MakeList(MD_Arena *arena);
MD_FUNCTION void MD_ListConcatInPlace(MD_Node *list, MD_Node *to_push); MD_FUNCTION void MD_ListConcatInPlace(Node *list, Node *to_push);
MD_FUNCTION MD_Node *MD_PushNewReference(MD_Arena *arena, MD_Node *list, MD_Node *target); MD_FUNCTION Node *MD_PushNewReference(MD_Arena *arena, Node *list, Node *target);
//~ Introspection Helpers //~ Introspection Helpers
// These calls are for getting info from nodes, and introspecting // These calls are for getting info from nodes, and introspecting
// on trees that are returned to you by the parser. // on trees that are returned to you by the parser.
MD_FUNCTION MD_Node * MD_FirstNodeWithString(MD_Node *first, MD_String8 string, MD_MatchFlags flags); MD_FUNCTION Node * MD_FirstNodeWithString(Node *first, MD_String8 string, MD_MatchFlags flags);
MD_FUNCTION MD_Node * MD_NodeAtIndex(MD_Node *first, int n); MD_FUNCTION Node * MD_NodeAtIndex(Node *first, int n);
MD_FUNCTION MD_Node * MD_FirstNodeWithFlags(MD_Node *first, MD_NodeFlags flags); MD_FUNCTION Node * MD_FirstNodeWithFlags(Node *first, NodeFlags flags);
MD_FUNCTION int MD_IndexFromNode(MD_Node *node); MD_FUNCTION int MD_IndexFromNode(Node *node);
MD_FUNCTION MD_Node * MD_RootFromNode(MD_Node *node); MD_FUNCTION Node * MD_RootFromNode(Node *node);
MD_FUNCTION MD_Node * MD_ChildFromString(MD_Node *node, MD_String8 child_string, MD_MatchFlags flags); MD_FUNCTION Node * MD_ChildFromString(Node *node, MD_String8 child_string, MD_MatchFlags flags);
MD_FUNCTION MD_Node * MD_TagFromString(MD_Node *node, MD_String8 tag_string, MD_MatchFlags flags); MD_FUNCTION Node * MD_TagFromString(Node *node, MD_String8 tag_string, MD_MatchFlags flags);
MD_FUNCTION MD_Node * MD_ChildFromIndex(MD_Node *node, int n); MD_FUNCTION Node * MD_ChildFromIndex(Node *node, int n);
MD_FUNCTION MD_Node * MD_TagFromIndex(MD_Node *node, int n); MD_FUNCTION Node * MD_TagFromIndex(Node *node, int n);
MD_FUNCTION MD_Node * MD_TagArgFromIndex(MD_Node *node, MD_String8 tag_string, MD_MatchFlags flags, int n); MD_FUNCTION Node * MD_TagArgFromIndex(Node *node, MD_String8 tag_string, MD_MatchFlags flags, int n);
MD_FUNCTION MD_Node * MD_TagArgFromString(MD_Node *node, MD_String8 tag_string, MD_MatchFlags tag_str_flags, MD_String8 arg_string, MD_MatchFlags arg_str_flags); MD_FUNCTION Node * MD_TagArgFromString(Node *node, MD_String8 tag_string, MD_MatchFlags tag_str_flags, MD_String8 arg_string, MD_MatchFlags arg_str_flags);
MD_FUNCTION MD_b32 MD_NodeHasChild(MD_Node *node, MD_String8 string, MD_MatchFlags flags); MD_FUNCTION MD_b32 MD_NodeHasChild(Node *node, MD_String8 string, MD_MatchFlags flags);
MD_FUNCTION MD_b32 MD_NodeHasTag(MD_Node *node, MD_String8 string, MD_MatchFlags flags); MD_FUNCTION MD_b32 MD_NodeHasTag(Node *node, MD_String8 string, MD_MatchFlags flags);
MD_FUNCTION MD_i64 MD_ChildCountFromNode(MD_Node *node); MD_FUNCTION MD_i64 MD_ChildCountFromNode(Node *node);
MD_FUNCTION MD_i64 MD_TagCountFromNode(MD_Node *node); MD_FUNCTION MD_i64 MD_TagCountFromNode(Node *node);
MD_FUNCTION MD_Node * MD_ResolveNodeFromReference(MD_Node *node); MD_FUNCTION Node * MD_ResolveNodeFromReference(Node *node);
MD_FUNCTION MD_Node* MD_NodeNextWithLimit(MD_Node *node, MD_Node *opl); MD_FUNCTION Node* MD_NodeNextWithLimit(Node *node, Node *opl);
MD_FUNCTION MD_String8 MD_PrevCommentFromNode(MD_Node *node); MD_FUNCTION MD_String8 MD_PrevCommentFromNode(Node *node);
MD_FUNCTION MD_String8 MD_NextCommentFromNode(MD_Node *node); MD_FUNCTION MD_String8 MD_NextCommentFromNode(Node *node);
// NOTE(rjf): For-Loop Helpers // NOTE(rjf): For-Loop Helpers
#define MD_EachNode(it, first) MD_Node *it = (first); !MD_NodeIsNil(it); it = it->next #define MD_EachNode(it, first) Node *it = (first); !MD_NodeIsNil(it); it = it->next
//~ Error/Warning Helpers //~ Error/Warning Helpers
@@ -1173,8 +1173,8 @@ MD_FUNCTION void MD_PrintMessageFmt(FILE *file, MD_CodeLoc code_loc, MD_MessageK
//~ Tree Comparison/Verification //~ Tree Comparison/Verification
MD_FUNCTION MD_b32 MD_NodeMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags); MD_FUNCTION MD_b32 MD_NodeMatch(Node *a, Node *b, MD_MatchFlags flags);
MD_FUNCTION MD_b32 MD_NodeDeepMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags); MD_FUNCTION MD_b32 MD_NodeDeepMatch(Node *a, Node *b, MD_MatchFlags flags);
//~ Expression Parsing //~ Expression Parsing
@@ -1189,34 +1189,34 @@ MD_FUNCTION MD_ExprOpr* MD_ExprOprFromKindString(MD_ExprOprTable *table,
MD_ExprOprKind kind, MD_String8 s); MD_ExprOprKind kind, MD_String8 s);
MD_FUNCTION MD_ExprParseResult MD_ExprParse(MD_Arena *arena, MD_ExprOprTable *op_table, MD_FUNCTION MD_ExprParseResult MD_ExprParse(MD_Arena *arena, MD_ExprOprTable *op_table,
MD_Node *first, MD_Node *one_past_last); Node *first, Node *one_past_last);
MD_FUNCTION MD_Expr* MD_Expr_NewLeaf(MD_Arena *arena, MD_Node *node); MD_FUNCTION MD_Expr* MD_Expr_NewLeaf(MD_Arena *arena, Node *node);
MD_FUNCTION MD_Expr* MD_Expr_NewOpr(MD_Arena *arena, MD_ExprOpr *op, MD_Node *op_node, MD_FUNCTION MD_Expr* MD_Expr_NewOpr(MD_Arena *arena, MD_ExprOpr *op, Node *op_node,
MD_Expr *left, MD_Expr *right); MD_Expr *left, MD_Expr *right);
MD_FUNCTION MD_ExprParseCtx MD_ExprParse_MakeContext(MD_ExprOprTable *table); MD_FUNCTION MD_ExprParseCtx MD_ExprParse_MakeContext(MD_ExprOprTable *table);
MD_FUNCTION MD_Expr* MD_ExprParse_TopLevel(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_FUNCTION MD_Expr* MD_ExprParse_TopLevel(MD_Arena *arena, MD_ExprParseCtx *ctx,
MD_Node *first, MD_Node *opl); Node *first, Node *opl);
MD_FUNCTION MD_b32 MD_ExprParse_OprConsume(MD_ExprParseCtx *ctx, MD_FUNCTION MD_b32 MD_ExprParse_OprConsume(MD_ExprParseCtx *ctx,
MD_Node **iter, MD_Node *opl, Node **iter, Node *opl,
MD_ExprOprKind kind, MD_ExprOprKind kind,
MD_u32 min_precedence, MD_u32 min_precedence,
MD_ExprOpr **op_out); MD_ExprOpr **op_out);
MD_FUNCTION MD_Expr* MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_FUNCTION MD_Expr* MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx,
MD_Node **iter, MD_Node *first, MD_Node *opl); Node **iter, Node *first, Node *opl);
MD_FUNCTION MD_Expr* MD_ExprParse_MinPrecedence(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_FUNCTION MD_Expr* MD_ExprParse_MinPrecedence(MD_Arena *arena, MD_ExprParseCtx *ctx,
MD_Node **iter, MD_Node *first, MD_Node *opl, Node **iter, Node *first, Node *opl,
MD_u32 min_precedence); MD_u32 min_precedence);
//~ String Generation //~ String Generation
MD_FUNCTION void MD_DebugDumpFromNode(MD_Arena *arena, MD_String8List *out, MD_Node *node, MD_FUNCTION void MD_DebugDumpFromNode(MD_Arena *arena, MD_String8List *out, Node *node,
int indent, MD_String8 indent_string, int indent, MD_String8 indent_string,
MD_GenerateFlags flags); MD_GenerateFlags flags);
MD_FUNCTION void MD_ReconstructionFromNode(MD_Arena *arena, MD_String8List *out, MD_Node *node, MD_FUNCTION void MD_ReconstructionFromNode(MD_Arena *arena, MD_String8List *out, Node *node,
int indent, MD_String8 indent_string); int indent, MD_String8 indent_string);
//~ Command Line Argument Helper //~ Command Line Argument Helper
tests/expression_tests.c
+15 -15
View File
@@ -86,7 +86,7 @@ typedef enum{
} Op; } Op;
#undef X #undef X
static MD_String8 node_raw_contents(MD_Node *node, MD_b32 exclude_outer) static MD_String8 node_raw_contents(Node *node, MD_b32 exclude_outer)
{ {
MD_String8 result = {0}; MD_String8 result = {0};
@@ -98,7 +98,7 @@ static MD_String8 node_raw_contents(MD_Node *node, MD_b32 exclude_outer)
MD_u64 end = beg; MD_u64 end = beg;
{ {
MD_Node *last_descendant = node; Node *last_descendant = node;
for(;!MD_NodeIsNil(last_descendant->last_child);) for(;!MD_NodeIsNil(last_descendant->last_child);)
{ {
last_descendant = last_descendant->last_child; last_descendant = last_descendant->last_child;
@@ -106,7 +106,7 @@ static MD_String8 node_raw_contents(MD_Node *node, MD_b32 exclude_outer)
end = last_descendant->offset + last_descendant->raw_string.size; end = last_descendant->offset + last_descendant->raw_string.size;
} }
MD_Node *root = node; Node *root = node;
for(;!MD_NodeIsNil(root->parent);) for(;!MD_NodeIsNil(root->parent);)
{ {
root = root->parent; root = root->parent;
@@ -185,29 +185,29 @@ static void parenthesize_exclude_outer(MD_Arena *arena, OperatorDescription *des
} }
else else
{ {
if(node->md_node->flags & MD_NodeFlag_HasParenLeft) if(node->md_node->flags & NodeFlag_HasParenLeft)
{ {
MD_S8ListPush(arena, l, MD_S8Lit("(")); MD_S8ListPush(arena, l, MD_S8Lit("("));
} }
else if(node->md_node->flags & MD_NodeFlag_HasBraceLeft) else if(node->md_node->flags & NodeFlag_HasBraceLeft)
{ {
MD_S8ListPush(arena, l, MD_S8Lit("{")); MD_S8ListPush(arena, l, MD_S8Lit("{"));
} }
else if(node->md_node->flags & MD_NodeFlag_HasBracketLeft) else if(node->md_node->flags & NodeFlag_HasBracketLeft)
{ {
MD_S8ListPush(arena, l, MD_S8Lit("[")); MD_S8ListPush(arena, l, MD_S8Lit("["));
} }
MD_S8ListPush(arena, l, MD_S8Lit("...")); MD_S8ListPush(arena, l, MD_S8Lit("..."));
if(node->md_node->flags & MD_NodeFlag_HasParenRight) if(node->md_node->flags & NodeFlag_HasParenRight)
{ {
MD_S8ListPush(arena, l, MD_S8Lit(")")); MD_S8ListPush(arena, l, MD_S8Lit(")"));
} }
else if(node->md_node->flags & MD_NodeFlag_HasBraceRight){ else if(node->md_node->flags & NodeFlag_HasBraceRight){
MD_S8ListPush(arena, l, MD_S8Lit("}")); MD_S8ListPush(arena, l, MD_S8Lit("}"));
} }
else if(node->md_node->flags & MD_NodeFlag_HasBracketRight){ else if(node->md_node->flags & NodeFlag_HasBracketRight){
MD_S8ListPush(arena, l, MD_S8Lit("]")); MD_S8ListPush(arena, l, MD_S8Lit("]"));
} }
} }
@@ -259,10 +259,10 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
MD_String8 plus = MD_S8Lit("+"); MD_String8 plus = MD_S8Lit("+");
MD_String8 minus = MD_S8Lit("-"); MD_String8 minus = MD_S8Lit("-");
MD_String8 cast = MD_S8Lit("()"); MD_String8 cast = MD_S8Lit("()");
MD_Node *plus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0); Node *plus_node = MD_MakeNode(g_arena, NodeKind_Main, plus, plus, 0);
MD_Node *cast_node = MD_MakeNode(g_arena, MD_NodeKind_Main, cast, cast, 0); Node *cast_node = MD_MakeNode(g_arena, NodeKind_Main, cast, cast, 0);
MD_Node *minus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, minus, minus, 0); Node *minus_node = MD_MakeNode(g_arena, NodeKind_Main, minus, minus, 0);
MD_Node *plus_node_bis = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0); Node *plus_node_bis = MD_MakeNode(g_arena, NodeKind_Main, plus, plus, 0);
MD_ExprSetBakeOperatorErrorHandler(bake_operator_error_handler); MD_ExprSetBakeOperatorErrorHandler(bake_operator_error_handler);
@@ -341,7 +341,7 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
for(Op op = Op_Null+1; op < Op_COUNT; ++op) for(Op op = Op_Null+1; op < Op_COUNT; ++op)
{ {
OperatorDescription *desc = operator_array + op; OperatorDescription *desc = operator_array + op;
MD_Node *node = MD_MakeNode(g_arena, MD_NodeKind_Main, desc->s, desc->s, 0); Node *node = MD_MakeNode(g_arena, NodeKind_Main, desc->s, desc->s, 0);
MD_ExprOprPush(g_arena, &operator_list, desc->op.kind, desc->op.precedence, desc->s, MD_ExprOprPush(g_arena, &operator_list, desc->op.kind, desc->op.precedence, desc->s,
op, node); op, node);
} }
@@ -417,7 +417,7 @@ operator_array[Op_##name].op = (MD_ExprOpr){ .op_id = Op_##name, .kind = MD_Expr
MD_String8 q = MD_S8CString(test.q); MD_String8 q = MD_S8CString(test.q);
MD_String8 a = MD_S8CString(test.a); MD_String8 a = MD_S8CString(test.a);
MD_ParseResult parse = MD_ParseWholeString(g_arena, MD_S8Lit("test"), q); ParseResult parse = MD_ParseWholeString(g_arena, MD_S8Lit("test"), q);
if(parse.errors.max_message_kind == MD_MessageKind_Null) if(parse.errors.max_message_kind == MD_MessageKind_Null)
{ {
MD_ExprParseResult expr_parse = MD_ExprParse(g_arena, &op_table, parse.node->first_child, MD_NilNode()); MD_ExprParseResult expr_parse = MD_ExprParse(g_arena, &op_table, parse.node->first_child, MD_NilNode());
tests/sanity_tests.c
+175 -175
View File
@@ -63,21 +63,21 @@ EndTest(void)
#define Test(name) for(int _i_ = (BeginTest(name), 0); !_i_; _i_ += 1, EndTest()) #define Test(name) for(int _i_ = (BeginTest(name), 0); !_i_; _i_ += 1, EndTest())
static MD_Node * static Node *
MakeTestNode(MD_NodeKind kind, MD_String8 string) MakeTestNode(NodeKind kind, MD_String8 string)
{ {
return MD_MakeNode(arena, kind, string, string, 0); return MD_MakeNode(arena, kind, string, string, 0);
} }
static MD_b32 static MD_b32
MatchParsedWithNode(MD_String8 string, MD_Node *tree) MatchParsedWithNode(MD_String8 string, Node *tree)
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, string, 0); ParseResult parse = MD_ParseOneNode(arena, string, 0);
return MD_NodeDeepMatch(tree, parse.node, MD_NodeMatchFlag_Tags | MD_NodeMatchFlag_TagArguments); return MD_NodeDeepMatch(tree, parse.node, MD_NodeMatchFlag_Tags | MD_NodeMatchFlag_TagArguments);
} }
static MD_b32 static MD_b32
TokenMatch(MD_Token token, MD_String8 string, MD_TokenKind kind) TokenMatch(Token token, MD_String8 string, MD_TokenKind kind)
{ {
return MD_S8Match(string, token.string, 0) && token.kind == kind; return MD_S8Match(string, token.string, 0) && token.kind == kind;
} }
@@ -89,10 +89,10 @@ int main(void)
Test("Lexer") Test("Lexer")
{ {
MD_String8 string = MD_S8Lit("abc def 123 456 123_456 abc123 123abc +-*"); MD_String8 string = MD_S8Lit("abc def 123 456 123_456 abc123 123abc +-*");
MD_Token tokens[100]; Token tokens[100];
MD_Token *token = tokens; Token *token = tokens;
MD_Token *token_opl = tokens + MD_ArrayCount(tokens); Token *token_opl = tokens + MD_ArrayCount(tokens);
MD_u64 pos = 0; MD_u64 pos = 0;
for (; pos < string.size && token < token_opl; ) for (; pos < string.size && token < token_opl; )
{ {
@@ -120,37 +120,37 @@ int main(void)
Test("Empty Sets") Test("Empty Sets")
{ {
TestResult(MatchParsedWithNode(MD_S8Lit("{}"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); TestResult(MatchParsedWithNode(MD_S8Lit("{}"), MakeTestNode(NodeKind_Main, MD_S8Lit(""))));
TestResult(MatchParsedWithNode(MD_S8Lit("()"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); TestResult(MatchParsedWithNode(MD_S8Lit("()"), MakeTestNode(NodeKind_Main, MD_S8Lit(""))));
TestResult(MatchParsedWithNode(MD_S8Lit("[]"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); TestResult(MatchParsedWithNode(MD_S8Lit("[]"), MakeTestNode(NodeKind_Main, MD_S8Lit(""))));
TestResult(MatchParsedWithNode(MD_S8Lit("[)"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); TestResult(MatchParsedWithNode(MD_S8Lit("[)"), MakeTestNode(NodeKind_Main, MD_S8Lit(""))));
TestResult(MatchParsedWithNode(MD_S8Lit("(]"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); TestResult(MatchParsedWithNode(MD_S8Lit("(]"), MakeTestNode(NodeKind_Main, MD_S8Lit(""))));
} }
Test("Simple Unnamed Sets") Test("Simple Unnamed Sets")
{ {
{ {
MD_String8 string = MD_S8Lit("{a, b, c}"); MD_String8 string = MD_S8Lit("{a, b, c}");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit(""));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("b")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("c")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
{ {
MD_String8 string = MD_S8Lit("(1 2 3 4 5)"); MD_String8 string = MD_S8Lit("(1 2 3 4 5)");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit(""));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("1"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("1")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("2"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("2")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("3"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("3")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("4"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("4")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("5"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("5")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
{ {
MD_String8 string = MD_S8Lit("{a}"); MD_String8 string = MD_S8Lit("{a}");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit(""));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
} }
@@ -158,10 +158,10 @@ int main(void)
Test("Simple Named Sets") Test("Simple Named Sets")
{ {
MD_String8 string = MD_S8Lit("simple_set: {a, b, c}"); MD_String8 string = MD_S8Lit("simple_set: {a, b, c}");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("simple_set")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("simple_set"));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("b")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("c")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
@@ -169,128 +169,128 @@ int main(void)
{ {
{ {
MD_String8 string = MD_S8Lit("{a b:{1 2 3} c}"); MD_String8 string = MD_S8Lit("{a b:{1 2 3} c}");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit(""));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a")));
{ {
MD_Node *sub = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b")); Node *sub = MakeTestNode(NodeKind_Main, MD_S8Lit("b"));
MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("1"))); MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("1")));
MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("2"))); MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("2")));
MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("3"))); MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("3")));
MD_PushChild(tree, sub); MD_PushChild(tree, sub);
} }
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("c")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
{ {
MD_String8 string = MD_S8Lit("foo: { (size: u64) -> *void }"); MD_String8 string = MD_S8Lit("foo: { (size: u64) -> *void }");
MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("foo")); Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("foo"));
MD_Node *params = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); Node *params = MakeTestNode(NodeKind_Main, MD_S8Lit(""));
MD_Node *size = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("size")); Node *size = MakeTestNode(NodeKind_Main, MD_S8Lit("size"));
MD_PushChild(size, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("u64"))); MD_PushChild(size, MakeTestNode(NodeKind_Main, MD_S8Lit("u64")));
MD_PushChild(params, size); MD_PushChild(params, size);
MD_PushChild(tree, params); MD_PushChild(tree, params);
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("->"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("->")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("*"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("*")));
MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("void"))); MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("void")));
TestResult(MatchParsedWithNode(string, tree)); TestResult(MatchParsedWithNode(string, tree));
} }
} }
Test("Non-Sets") Test("Non-Sets")
{ {
TestResult(MatchParsedWithNode(MD_S8Lit("foo"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("foo")))); TestResult(MatchParsedWithNode(MD_S8Lit("foo"), MakeTestNode(NodeKind_Main, MD_S8Lit("foo"))));
TestResult(MatchParsedWithNode(MD_S8Lit("123"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("123")))); TestResult(MatchParsedWithNode(MD_S8Lit("123"), MakeTestNode(NodeKind_Main, MD_S8Lit("123"))));
TestResult(MatchParsedWithNode(MD_S8Lit("+"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("+")))); TestResult(MatchParsedWithNode(MD_S8Lit("+"), MakeTestNode(NodeKind_Main, MD_S8Lit("+"))));
} }
Test("Set Border Flags") Test("Set Border Flags")
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100)"), 0);
TestResult(parse.node->flags & MD_NodeFlag_HasParenLeft && TestResult(parse.node->flags & NodeFlag_HasParenLeft &&
parse.node->flags & MD_NodeFlag_HasParenRight); parse.node->flags & NodeFlag_HasParenRight);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100]"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100]"), 0);
TestResult(parse.node->flags & MD_NodeFlag_HasParenLeft && TestResult(parse.node->flags & NodeFlag_HasParenLeft &&
parse.node->flags & MD_NodeFlag_HasBracketRight); parse.node->flags & NodeFlag_HasBracketRight);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100)"), 0);
TestResult(parse.node->flags & MD_NodeFlag_HasBracketLeft && TestResult(parse.node->flags & NodeFlag_HasBracketLeft &&
parse.node->flags & MD_NodeFlag_HasParenRight); parse.node->flags & NodeFlag_HasParenRight);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100]"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100]"), 0);
TestResult(parse.node->flags & MD_NodeFlag_HasBracketLeft && TestResult(parse.node->flags & NodeFlag_HasBracketLeft &&
parse.node->flags & MD_NodeFlag_HasBracketRight); parse.node->flags & NodeFlag_HasBracketRight);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("{0, 100}"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("{0, 100}"), 0);
TestResult(parse.node->flags & MD_NodeFlag_HasBraceLeft && TestResult(parse.node->flags & NodeFlag_HasBraceLeft &&
parse.node->flags & MD_NodeFlag_HasBraceRight); parse.node->flags & NodeFlag_HasBraceRight);
} }
} }
Test("Node Separator Flags") Test("Node Separator Flags")
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a, b)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a, b)"), 0);
TestResult(parse.node->first_child->flags & MD_NodeFlag_IsBeforeComma); TestResult(parse.node->first_child->flags & NodeFlag_IsBeforeComma);
TestResult(parse.node->first_child->next->flags & MD_NodeFlag_IsAfterComma); TestResult(parse.node->first_child->next->flags & NodeFlag_IsAfterComma);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a; b)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a; b)"), 0);
TestResult(parse.node->first_child->flags & MD_NodeFlag_IsBeforeSemicolon); TestResult(parse.node->first_child->flags & NodeFlag_IsBeforeSemicolon);
TestResult(parse.node->first_child->next->flags & MD_NodeFlag_IsAfterSemicolon); TestResult(parse.node->first_child->next->flags & NodeFlag_IsAfterSemicolon);
} }
} }
Test("Node Text Flags") Test("Node Text Flags")
{ {
TestResult(MD_ParseOneNode(arena, MD_S8Lit("123"), 0).node->flags & TestResult(MD_ParseOneNode(arena, MD_S8Lit("123"), 0).node->flags &
MD_NodeFlag_Numeric); NodeFlag_Numeric);
TestResult(MD_ParseOneNode(arena, MD_S8Lit("123_456_789"), 0).node->flags & TestResult(MD_ParseOneNode(arena, MD_S8Lit("123_456_789"), 0).node->flags &
MD_NodeFlag_Numeric); NodeFlag_Numeric);
TestResult(MD_ParseOneNode(arena, MD_S8Lit("abc"), 0).node->flags & TestResult(MD_ParseOneNode(arena, MD_S8Lit("abc"), 0).node->flags &
MD_NodeFlag_Identifier); NodeFlag_Identifier);
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"foo\""), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"foo\""), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringDoubleQuote); parse.node->flags & NodeFlag_StringDoubleQuote);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'foo'"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'foo'"), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringSingleQuote); parse.node->flags & NodeFlag_StringSingleQuote);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`foo`"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`foo`"), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringTick); parse.node->flags & NodeFlag_StringTick);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"foo\"\"\""), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"foo\"\"\""), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringDoubleQuote && parse.node->flags & NodeFlag_StringDoubleQuote &&
parse.node->flags & MD_NodeFlag_StringTriplet); parse.node->flags & NodeFlag_StringTriplet);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''foo'''"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''foo'''"), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringSingleQuote && parse.node->flags & NodeFlag_StringSingleQuote &&
parse.node->flags & MD_NodeFlag_StringTriplet); parse.node->flags & NodeFlag_StringTriplet);
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("```foo```"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("```foo```"), 0);
TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && TestResult(parse.node->flags & NodeFlag_StringLiteral &&
parse.node->flags & MD_NodeFlag_StringTick && parse.node->flags & NodeFlag_StringTick &&
parse.node->flags & MD_NodeFlag_StringTriplet); parse.node->flags & NodeFlag_StringTriplet);
} }
} }
@@ -320,12 +320,12 @@ int main(void)
Test("Enum Strings") Test("Enum Strings")
{ {
TestResult(MD_S8Match(MD_StringFromNodeKind(MD_NodeKind_Main), MD_S8Lit("Main"), 0)); TestResult(MD_S8Match(MD_StringFromNodeKind(NodeKind_Main), MD_S8Lit("Main"), 0));
TestResult(MD_S8Match(MD_StringFromNodeKind(MD_NodeKind_Main), MD_S8Lit("Main"), 0)); TestResult(MD_S8Match(MD_StringFromNodeKind(NodeKind_Main), MD_S8Lit("Main"), 0));
MD_String8List list = MD_StringListFromNodeFlags(arena, MD_String8List list = MD_StringListFromNodeFlags(arena,
MD_NodeFlag_StringLiteral | NodeFlag_StringLiteral |
MD_NodeFlag_HasParenLeft | NodeFlag_HasParenLeft |
MD_NodeFlag_IsBeforeSemicolon); NodeFlag_IsBeforeSemicolon);
MD_b32 match = 1; MD_b32 match = 1;
for(MD_String8Node *node = list.first; node; node = node->next) for(MD_String8Node *node = list.first; node; node = node->next)
{ {
@@ -346,18 +346,18 @@ int main(void)
// NOTE(rjf): Pre-Comments: // NOTE(rjf): Pre-Comments:
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("/*foobar*/ (a b c)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("/*foobar*/ (a b c)"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->prev_comment, MD_S8Lit("foobar"), 0)); MD_S8Match(parse.node->prev_comment, MD_S8Lit("foobar"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n(a b c)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n(a b c)"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->prev_comment, MD_S8Lit(" foobar"), 0)); MD_S8Match(parse.node->prev_comment, MD_S8Lit(" foobar"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n\n(a b c)"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n\n(a b c)"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->prev_comment, MD_S8Lit(""), 0)); MD_S8Match(parse.node->prev_comment, MD_S8Lit(""), 0));
} }
} }
@@ -365,23 +365,23 @@ int main(void)
// NOTE(rjf): Post-Comments: // NOTE(rjf): Post-Comments:
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) /*foobar*/"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) /*foobar*/"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->next_comment, MD_S8Lit("foobar"), 0)); MD_S8Match(parse.node->next_comment, MD_S8Lit("foobar"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) // foobar"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) // foobar"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->next_comment, MD_S8Lit(" foobar"), 0)); MD_S8Match(parse.node->next_comment, MD_S8Lit(" foobar"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n// foobar"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n// foobar"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->next_comment, MD_S8Lit(""), 0)); MD_S8Match(parse.node->next_comment, MD_S8Lit(""), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n\n// foobar"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n\n// foobar"), 0);
TestResult(parse.node->kind == MD_NodeKind_Main && TestResult(parse.node->kind == NodeKind_Main &&
MD_S8Match(parse.node->next_comment, MD_S8Lit(""), 0)); MD_S8Match(parse.node->next_comment, MD_S8Lit(""), 0));
} }
} }
@@ -404,7 +404,7 @@ int main(void)
for(int i_test = 0; i_test < MD_ArrayCount(tests); ++i_test) for(int i_test = 0; i_test < MD_ArrayCount(tests); ++i_test)
{ {
MD_ParseResult parse = MD_ParseWholeString(arena, MD_S8Lit("test.mdesk"), MD_S8CString(tests[i_test].s)); ParseResult parse = MD_ParseWholeString(arena, MD_S8Lit("test.mdesk"), MD_S8CString(tests[i_test].s));
MD_b32 columns_match = 1; MD_b32 columns_match = 1;
{ {
@@ -428,8 +428,8 @@ int main(void)
} }
{ {
MD_ParseResult parse = MD_ParseWholeFile(arena, MD_S8Lit("__does_not_exist.mdesk")); ParseResult parse = MD_ParseWholeFile(arena, MD_S8Lit("__does_not_exist.mdesk"));
TestResult(parse.node->kind == MD_NodeKind_File && parse.errors.first != 0); TestResult(parse.node->kind == NodeKind_File && parse.errors.first != 0);
} }
} }
@@ -487,10 +487,10 @@ int main(void)
MD_S8LitComp("```foo-bar```"), MD_S8LitComp("```foo-bar```"),
}; };
MD_Node *nodes[MD_ArrayCount(samples)]; Node *nodes[MD_ArrayCount(samples)];
for (int i = 0; i < MD_ArrayCount(samples); i += 1) for (int i = 0; i < MD_ArrayCount(samples); i += 1)
{ {
MD_ParseResult result = MD_ParseOneNode(arena, samples[i], 0); ParseResult result = MD_ParseOneNode(arena, samples[i], 0);
nodes[i] = result.node; nodes[i] = result.node;
} }
@@ -512,41 +512,41 @@ int main(void)
Test("String escaping") Test("String escaping")
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\``"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\``"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\`"), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\`"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("``` \\``` ```"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("``` \\``` ```"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\``` "), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\``` "), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`````\\````"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`````\\````"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("``\\`"), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("``\\`"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\'`"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\'`"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\'"), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\'"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("''' \\''' '''"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("''' \\''' '''"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\''' "), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\''' "), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''''\\''''"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''''\\''''"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("''\\'"), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("''\\'"), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\\"`"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`\\\"`"), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\\""), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\\\""), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\" \\\"\"\" \"\"\""), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\" \\\"\"\" \"\"\""), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\\"\"\" "), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit(" \\\"\"\" "), 0));
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"\"\"\\\"\"\"\""), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"\"\"\\\"\"\"\""), 0);
TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\"\"\\\""), 0)); TestResult(MD_S8Match(parse.node->string, MD_S8Lit("\"\"\\\""), 0));
} }
} }
@@ -555,10 +555,10 @@ int main(void)
{ {
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{x y z; a b c}"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{x y z; a b c}"), 0);
MD_Node *node = parse.node; Node *node = parse.node;
MD_Node *group_first = node->first_child; Node *group_first = node->first_child;
MD_Node *group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterSemicolon); Node *group_opl = MD_FirstNodeWithFlags(group_first->next, NodeFlag_IsAfterSemicolon);
TestResult(MD_S8Match(group_first->string, MD_S8Lit("x"), 0)); TestResult(MD_S8Match(group_first->string, MD_S8Lit("x"), 0));
TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("y"), 0)); TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("y"), 0));
@@ -566,7 +566,7 @@ int main(void)
TestResult(group_opl == group_first->next->next->next); TestResult(group_opl == group_first->next->next->next);
group_first = group_opl; group_first = group_opl;
group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterSemicolon); group_opl = MD_FirstNodeWithFlags(group_first->next, NodeFlag_IsAfterSemicolon);
TestResult(MD_S8Match(group_first->string, MD_S8Lit("a"), 0)); TestResult(MD_S8Match(group_first->string, MD_S8Lit("a"), 0));
TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("b"), 0)); TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("b"), 0));
@@ -575,27 +575,27 @@ int main(void)
} }
{ {
MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{a b c , d e f , g h i}"), 0); ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{a b c , d e f , g h i}"), 0);
MD_Node *node = parse.node; Node *node = parse.node;
MD_Node *group_first = 0; Node *group_first = 0;
MD_Node *group_opl = 0; Node *group_opl = 0;
group_first = node->first_child; group_first = node->first_child;
group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterComma); group_opl = MD_FirstNodeWithFlags(group_first->next, NodeFlag_IsAfterComma);
TestResult(MD_S8Match(group_first->string, MD_S8Lit("a"), 0)); TestResult(MD_S8Match(group_first->string, MD_S8Lit("a"), 0));
TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("b"), 0)); TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("b"), 0));
TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("c"), 0)); TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("c"), 0));
TestResult(group_opl == group_first->next->next->next); TestResult(group_opl == group_first->next->next->next);
group_first = group_opl; group_first = group_opl;
group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterComma); group_opl = MD_FirstNodeWithFlags(group_first->next, NodeFlag_IsAfterComma);
TestResult(MD_S8Match(group_first->string, MD_S8Lit("d"), 0)); TestResult(MD_S8Match(group_first->string, MD_S8Lit("d"), 0));
TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("e"), 0)); TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("e"), 0));
TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("f"), 0)); TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("f"), 0));
TestResult(group_opl == group_first->next->next->next); TestResult(group_opl == group_first->next->next->next);
group_first = group_opl; group_first = group_opl;
group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterComma); group_opl = MD_FirstNodeWithFlags(group_first->next, NodeFlag_IsAfterComma);
TestResult(MD_S8Match(group_first->string, MD_S8Lit("g"), 0)); TestResult(MD_S8Match(group_first->string, MD_S8Lit("g"), 0));
TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("h"), 0)); TestResult(MD_S8Match(group_first->next->string, MD_S8Lit("h"), 0));
TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("i"), 0)); TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("i"), 0));
@@ -612,16 +612,16 @@ int main(void)
{ {
MD_String8 text = MD_S8Lit("a:\nb:\nc\nd"); MD_String8 text = MD_S8Lit("a:\nb:\nc\nd");
MD_Node *tree = MD_MakeNode(arena, MD_NodeKind_File, file_name, text, 0); Node *tree = MD_MakeNode(arena, NodeKind_File, file_name, text, 0);
MD_Node *a = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a")); Node *a = MakeTestNode(NodeKind_Main, MD_S8Lit("a"));
MD_Node *b = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b")); Node *b = MakeTestNode(NodeKind_Main, MD_S8Lit("b"));
MD_Node *c = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c")); Node *c = MakeTestNode(NodeKind_Main, MD_S8Lit("c"));
MD_Node *d = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("d")); Node *d = MakeTestNode(NodeKind_Main, MD_S8Lit("d"));
MD_PushChild(a, b); MD_PushChild(a, b);
MD_PushChild(b, c); MD_PushChild(b, c);
MD_PushChild(tree, a); MD_PushChild(tree, a);
MD_PushChild(tree, d); MD_PushChild(tree, d);
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_NodeDeepMatch(tree, result.node, 0)); TestResult(MD_NodeDeepMatch(tree, result.node, 0));
} }
@@ -629,7 +629,7 @@ int main(void)
// finished unscoped set // finished unscoped set
{ {
MD_String8 text = MD_S8Lit("a:\nb:\nc"); MD_String8 text = MD_S8Lit("a:\nb:\nc");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(result.node->first_child == result.node->last_child); TestResult(result.node->first_child == result.node->last_child);
} }
@@ -637,31 +637,31 @@ int main(void)
// unfinished unscoped set // unfinished unscoped set
{ {
MD_String8 text = MD_S8Lit("a:\nb:\n\n"); MD_String8 text = MD_S8Lit("a:\nb:\n\n");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
{ {
MD_String8 text = MD_S8Lit("a:\nb:\n"); MD_String8 text = MD_S8Lit("a:\nb:\n");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
{ {
MD_String8 text = MD_S8Lit("a:\nb:"); MD_String8 text = MD_S8Lit("a:\nb:");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
// labeled scoped set in unscoped set // labeled scoped set in unscoped set
{ {
MD_String8 text = MD_S8Lit("a: b: {\nx\n} c"); MD_String8 text = MD_S8Lit("a: b: {\nx\n} c");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_ChildCountFromNode(result.node) == 1); TestResult(MD_ChildCountFromNode(result.node) == 1);
TestResult(MD_ChildCountFromNode(result.node->first_child) == 2); TestResult(MD_ChildCountFromNode(result.node->first_child) == 2);
} }
{ {
MD_String8 text = MD_S8Lit("a: b: {\nx\n}\nc"); MD_String8 text = MD_S8Lit("a: b: {\nx\n}\nc");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_ChildCountFromNode(result.node) == 2); TestResult(MD_ChildCountFromNode(result.node) == 2);
TestResult(MD_ChildCountFromNode(result.node->first_child) == 1); TestResult(MD_ChildCountFromNode(result.node->first_child) == 1);
@@ -670,7 +670,7 @@ int main(void)
// scoped set is not unscoped // scoped set is not unscoped
{ {
MD_String8 text = MD_S8Lit("a: {\nx\ny\n} c"); MD_String8 text = MD_S8Lit("a: {\nx\ny\n} c");
MD_ParseResult result = MD_ParseWholeString(arena, file_name, text); ParseResult result = MD_ParseWholeString(arena, file_name, text);
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(result.node->first_child != result.node->last_child); TestResult(result.node->first_child != result.node->last_child);
} }
@@ -681,19 +681,19 @@ int main(void)
MD_String8 file_name = MD_S8Lit("raw_text"); MD_String8 file_name = MD_S8Lit("raw_text");
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@foo bar")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@foo bar"));
TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("foo"), 0)); TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("foo"), 0));
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@+ bar")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@+ bar"));
TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("+"), 0)); TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("+"), 0));
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@'a b c' bar")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@'a b c' bar"));
TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("a b c"), 0)); TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("a b c"), 0));
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@100 bar")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("@100 bar"));
TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("100"), 0)); TestResult(MD_NodeHasTag(result.node->first_child, MD_S8Lit("100"), 0));
} }
} }
@@ -704,27 +704,27 @@ int main(void)
// tagged in scoped set always legal // tagged in scoped set always legal
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:{@tag {bar}}\n")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:{@tag {bar}}\n"));
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
} }
// tagged label in unscoped set legal // tagged label in unscoped set legal
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:@tag bar\n")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:@tag bar\n"));
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
} }
// unlabeled scoped set in unscoped set illegal // unlabeled scoped set in unscoped set illegal
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:bar {bar}\n")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:bar {bar}\n"));
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:bar @tag {bar}\n")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:bar @tag {bar}\n"));
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:@tag {bar}\n")); ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo:@tag {bar}\n"));
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
} }
@@ -743,10 +743,10 @@ int main(void)
MD_String8 *string = test_strings; MD_String8 *string = test_strings;
for (int i = 0; i < MD_ArrayCount(test_strings); i += 1, string += 1) for (int i = 0; i < MD_ArrayCount(test_strings); i += 1, string += 1)
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, *string); ParseResult result = MD_ParseWholeString(arena, file_name, *string);
TestResult((result.errors.first == 0) && TestResult((result.errors.first == 0) &&
(result.node->first_child == result.node->last_child) && (result.node->first_child == result.node->last_child) &&
(result.node->first_child->flags & MD_NodeFlag_Numeric)); (result.node->first_child->flags & NodeFlag_Numeric));
} }
} }
@@ -769,10 +769,10 @@ int main(void)
MD_String8 *string = test_strings; MD_String8 *string = test_strings;
for (int i = 0; i < MD_ArrayCount(test_strings); i += 1, string += 1) for (int i = 0; i < MD_ArrayCount(test_strings); i += 1, string += 1)
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, *string); ParseResult result = MD_ParseWholeString(arena, file_name, *string);
TestResult((result.errors.first == 0) && TestResult((result.errors.first == 0) &&
(result.node->first_child == result.node->last_child) && (result.node->first_child == result.node->last_child) &&
(result.node->first_child->flags & MD_NodeFlag_Numeric)); (result.node->first_child->flags & NodeFlag_Numeric));
} }
} }
@@ -781,24 +781,24 @@ int main(void)
MD_String8 file_name = MD_S8Lit("raw_text"); MD_String8 file_name = MD_S8Lit("raw_text");
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, ParseResult result = MD_ParseWholeString(arena, file_name,
MD_S8Lit("foo: '(' )")); MD_S8Lit("foo: '(' )"));
TestResult(result.errors.first != 0); TestResult(result.errors.first != 0);
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, ParseResult result = MD_ParseWholeString(arena, file_name,
MD_S8Lit("foo ':' ( )")); MD_S8Lit("foo ':' ( )"));
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_ChildCountFromNode(result.node) == 3); TestResult(MD_ChildCountFromNode(result.node) == 3);
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, ParseResult result = MD_ParseWholeString(arena, file_name,
MD_S8Lit("'@'bar foo")); MD_S8Lit("'@'bar foo"));
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_ChildCountFromNode(result.node) == 3); TestResult(MD_ChildCountFromNode(result.node) == 3);
} }
{ {
MD_ParseResult result = MD_ParseWholeString(arena, file_name, ParseResult result = MD_ParseWholeString(arena, file_name,
MD_S8Lit("foo: '(' ')'")); MD_S8Lit("foo: '(' ')'"));
TestResult(result.errors.first == 0); TestResult(result.errors.first == 0);
TestResult(MD_ChildCountFromNode(result.node) == 1); TestResult(MD_ChildCountFromNode(result.node) == 1);
@@ -811,7 +811,7 @@ int main(void)
{ {
MD_String8 code = MD_S8Lit("@foo @bar @baz a: { b c d e f }"); MD_String8 code = MD_S8Lit("@foo @bar @baz a: { b c d e f }");
MD_String8 expected = MD_S8Lit("@foo\n@bar\n@baz\na:\n{\n b,\n c,\n d,\n e,\n f,\n}"); MD_String8 expected = MD_S8Lit("@foo\n@bar\n@baz\na:\n{\n b,\n c,\n d,\n e,\n f,\n}");
MD_ParseResult parse = MD_ParseOneNode(arena, code, 0); ParseResult parse = MD_ParseOneNode(arena, code, 0);
MD_String8List actual_strings = {0}; MD_String8List actual_strings = {0};
MD_DebugDumpFromNode(arena, &actual_strings, parse.node, MD_DebugDumpFromNode(arena, &actual_strings, parse.node,
0, MD_S8Lit(" "), MD_GenerateFlags_Tree); 0, MD_S8Lit(" "), MD_GenerateFlags_Tree);
@@ -821,7 +821,7 @@ int main(void)
{ {
MD_String8 code = MD_S8Lit("@foo(1, 2, 3) a: { x y }"); MD_String8 code = MD_S8Lit("@foo(1, 2, 3) a: { x y }");
MD_String8 expected = MD_S8Lit("@foo(1,\n 2,\n 3)\na:\n{\n x,\n y,\n}"); MD_String8 expected = MD_S8Lit("@foo(1,\n 2,\n 3)\na:\n{\n x,\n y,\n}");
MD_ParseResult parse = MD_ParseOneNode(arena, code, 0); ParseResult parse = MD_ParseOneNode(arena, code, 0);
MD_String8List actual_strings = {0}; MD_String8List actual_strings = {0};
MD_DebugDumpFromNode(arena, &actual_strings, parse.node, MD_DebugDumpFromNode(arena, &actual_strings, parse.node,
0, MD_S8Lit(" "), MD_GenerateFlags_Tree); 0, MD_S8Lit(" "), MD_GenerateFlags_Tree);
@@ -831,7 +831,7 @@ int main(void)
{ {
MD_String8 code = MD_S8Lit("// foo\na"); MD_String8 code = MD_S8Lit("// foo\na");
MD_String8 expected = MD_S8Lit("/*\n foo\n*/\na"); MD_String8 expected = MD_S8Lit("/*\n foo\n*/\na");
MD_ParseResult parse = MD_ParseOneNode(arena, code, 0); ParseResult parse = MD_ParseOneNode(arena, code, 0);
MD_String8List actual_strings = {0}; MD_String8List actual_strings = {0};
MD_DebugDumpFromNode(arena, &actual_strings, parse.node, 0, MD_S8Lit(" "), MD_DebugDumpFromNode(arena, &actual_strings, parse.node, 0, MD_S8Lit(" "),
MD_GenerateFlags_Tree|MD_GenerateFlag_Comments); MD_GenerateFlags_Tree|MD_GenerateFlag_Comments);
@@ -840,20 +840,20 @@ int main(void)
} }
{ {
MD_String8 code = MD_S8Lit("@foo @bar @baz a: { b c d e f }"); MD_String8 code = MD_S8Lit("@foo @bar @baz a: { b c d e f }");
MD_ParseResult parse1 = MD_ParseOneNode(arena, code, 0); ParseResult parse1 = MD_ParseOneNode(arena, code, 0);
MD_String8List reconstruction_strs = {0}; MD_String8List reconstruction_strs = {0};
MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" "));
MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0); MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0);
MD_ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0); ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0);
TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags)); TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags));
} }
{ {
MD_String8 code = MD_S8Lit("@foo(x: y: z) @bar(a: b: c) @baz(1: 2: 3) abcdefg: { b: 4, c d: 5; e; f, }"); MD_String8 code = MD_S8Lit("@foo(x: y: z) @bar(a: b: c) @baz(1: 2: 3) abcdefg: { b: 4, c d: 5; e; f, }");
MD_ParseResult parse1 = MD_ParseOneNode(arena, code, 0); ParseResult parse1 = MD_ParseOneNode(arena, code, 0);
MD_String8List reconstruction_strs = {0}; MD_String8List reconstruction_strs = {0};
MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" "));
MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0); MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0);
MD_ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0); ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0);
TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags)); TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags));
} }
{ {
@@ -868,11 +868,11 @@ int main(void)
" e;\n" " e;\n"
" f,\n" " f,\n"
"}\n"); "}\n");
MD_ParseResult parse1 = MD_ParseOneNode(arena, code, 0); ParseResult parse1 = MD_ParseOneNode(arena, code, 0);
MD_String8List reconstruction_strs = {0}; MD_String8List reconstruction_strs = {0};
MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" "));
MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0); MD_String8 reconstruction = MD_S8ListJoin(arena, reconstruction_strs, 0);
MD_ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0); ParseResult parse2 = MD_ParseOneNode(arena, reconstruction, 0);
TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags)); TestResult(MD_NodeDeepMatch(parse1.node, parse2.node, MD_NodeMatchFlag_TagArguments|MD_NodeMatchFlag_NodeFlags));
} }
} }