diff --git a/code/base/strings.c b/code/base/strings.c index b14d843..c32ec19 100644 --- a/code/base/strings.c +++ b/code/base/strings.c @@ -1057,16 +1057,12 @@ str8_path_list_join_by_style_alloc(AllocatorInfo ainfo, String8List* path, PathS //////////////////////////////// //~ 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 utf8_decode(U8* str, U64 max) { UnicodeDecode result = {1, MAX_U32}; U8 byte = str[0]; - U8 byte_class = utf8_class[byte >> 3]; + U8 byte_class = utf8_class(byte >> 3); switch (byte_class) { case 1: @@ -1080,7 +1076,7 @@ utf8_decode(U8* str, U64 max) if (2 < max) { 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 |= (cont_byte & BITMASK6); @@ -1095,8 +1091,8 @@ utf8_decode(U8* str, U64 max) if (2 < max) { U8 cont_byte[2] = {str[1], str[2]}; - if (utf8_class[cont_byte[0] >> 3] == 0 && - utf8_class[cont_byte[1] >> 3] == 0) + if (utf8_class(cont_byte[0] >> 3) == 0 && + utf8_class(cont_byte[1] >> 3) == 0) { result.codepoint = (byte & BITMASK4) << 12; result.codepoint |= ((cont_byte[0] & BITMASK6) << 6); @@ -1112,9 +1108,9 @@ utf8_decode(U8* str, U64 max) if (3 < max) { U8 cont_byte[3] = {str[1], str[2], str[3]}; - if (utf8_class[cont_byte[0] >> 3] == 0 && - utf8_class[cont_byte[1] >> 3] == 0 && - utf8_class[cont_byte[2] >> 3] == 0) + if (utf8_class(cont_byte[0] >> 3) == 0 && + utf8_class(cont_byte[1] >> 3) == 0 && + utf8_class(cont_byte[2] >> 3) == 0) { result.codepoint = (byte & BITMASK3) << 18; result.codepoint |= ((cont_byte[0] & BITMASK6) << 12); diff --git a/code/base/strings.h b/code/base/strings.h index a5b1069..1646630 100644 --- a/code/base/strings.h +++ b/code/base/strings.h @@ -822,6 +822,16 @@ MD_API String8 str8_path_list_join_by_style_alloc (AllocatorInfo ainfo, Str //////////////////////////////// //~ 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); UnicodeDecode utf16_decode (U16* str, U64 max); MD_API U32 utf8_encode (U8* str, U32 codepoint); diff --git a/code/mdesk/mdesk.c b/code/mdesk/mdesk.c index db0ae58..e2aef23 100644 --- a/code/mdesk/mdesk.c +++ b/code/mdesk/mdesk.c @@ -1,18 +1,18 @@ +#ifdef INTELLISENSE_DIRECTIVES +# include "mdesk.h" +#endif + // Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) -#ifdef INTELLISENSE_DIRECTIVES -#include "mdesk.h" -#endif - //////////////////////////////// //~ rjf: Message Type Functions internal void -md_msg_list_push(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, String8 string) +md_msg_list_push(Arena *arena, MsgList *msgs, Node *node, MsgKind kind, String8 string) { - MD_Msg* - msg = push_array(arena, MD_Msg, 1); + Msg* + msg = push_array(arena, Msg, 1); msg->node = node; msg->kind = kind; msg->string = string; @@ -24,7 +24,7 @@ md_msg_list_push(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, } internal void -md_msg_list_pushf(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, char *fmt, ...) +md_msg_list_pushf(Arena *arena, MsgList *msgs, Node *node, MsgKind kind, char *fmt, ...) { va_list args; va_start(args, fmt); @@ -34,7 +34,7 @@ md_msg_list_pushf(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind } internal void -md_msg_list_concat_in_place(MD_MsgList *dst, MD_MsgList *to_push) +md_msg_list_concat_in_place(MsgList *dst, MsgList *to_push) { if(to_push->first != 0) { @@ -56,15 +56,15 @@ md_msg_list_concat_in_place(MD_MsgList *dst, MD_MsgList *to_push) //////////////////////////////// //~ rjf: Token Type Functions -internal MD_Token -md_token_make(Rng1U64 range, MD_TokenFlags flags) +internal Token +md_token_make(Rng1U64 range, TokenFlags flags) { - MD_Token token = {range, flags}; + Token token = {range, flags}; return token; } internal B32 -md_token_match(MD_Token a, MD_Token b) +md_token_match(Token a, Token b) { return (a.range.min == b.range.min && a.range.max == b.range.max && @@ -72,32 +72,32 @@ md_token_match(MD_Token a, MD_Token b) } internal String8List -md_string_list_from_token_flags(Arena *arena, MD_TokenFlags flags) +md_string_list_from_token_flags(Arena *arena, TokenFlags flags) { String8List strs = {0}; - if(flags & MD_TokenFlag_Identifier ){str8_list_push(arena, &strs, str8_lit("Identifier"));} - if(flags & MD_TokenFlag_Numeric ){str8_list_push(arena, &strs, str8_lit("Numeric"));} - if(flags & MD_TokenFlag_StringLiteral ){str8_list_push(arena, &strs, str8_lit("StringLiteral"));} - if(flags & MD_TokenFlag_Symbol ){str8_list_push(arena, &strs, str8_lit("Symbol"));} - if(flags & MD_TokenFlag_Reserved ){str8_list_push(arena, &strs, str8_lit("Reserved"));} - if(flags & MD_TokenFlag_Comment ){str8_list_push(arena, &strs, str8_lit("Comment"));} - if(flags & MD_TokenFlag_Whitespace ){str8_list_push(arena, &strs, str8_lit("Whitespace"));} - if(flags & MD_TokenFlag_Newline ){str8_list_push(arena, &strs, str8_lit("Newline"));} - if(flags & MD_TokenFlag_BrokenComment ){str8_list_push(arena, &strs, str8_lit("BrokenComment"));} - if(flags & MD_TokenFlag_BrokenStringLiteral ){str8_list_push(arena, &strs, str8_lit("BrokenStringLiteral"));} - if(flags & MD_TokenFlag_BadCharacter ){str8_list_push(arena, &strs, str8_lit("BadCharacter"));} + if(flags & TokenFlag_Identifier ){str8_list_push(arena, &strs, str8_lit("Identifier"));} + if(flags & TokenFlag_Numeric ){str8_list_push(arena, &strs, str8_lit("Numeric"));} + if(flags & TokenFlag_StringLiteral ){str8_list_push(arena, &strs, str8_lit("StringLiteral"));} + if(flags & TokenFlag_Symbol ){str8_list_push(arena, &strs, str8_lit("Symbol"));} + if(flags & TokenFlag_Reserved ){str8_list_push(arena, &strs, str8_lit("Reserved"));} + if(flags & TokenFlag_Comment ){str8_list_push(arena, &strs, str8_lit("Comment"));} + if(flags & TokenFlag_Whitespace ){str8_list_push(arena, &strs, str8_lit("Whitespace"));} + if(flags & TokenFlag_Newline ){str8_list_push(arena, &strs, str8_lit("Newline"));} + if(flags & TokenFlag_BrokenComment ){str8_list_push(arena, &strs, str8_lit("BrokenComment"));} + if(flags & TokenFlag_BrokenStringLiteral ){str8_list_push(arena, &strs, str8_lit("BrokenStringLiteral"));} + if(flags & TokenFlag_BadCharacter ){str8_list_push(arena, &strs, str8_lit("BadCharacter"));} return strs; } internal void -md_token_chunk_list_push(Arena *arena, MD_TokenChunkList *list, U64 cap, MD_Token token) +md_token_chunk_list_push(Arena *arena, TokenChunkList *list, U64 cap, Token token) { - MD_TokenChunkNode *node = list->last; + TokenChunkNode *node = list->last; if(node == 0 || node->count >= node->cap) { - node = push_array(arena, MD_TokenChunkNode, 1); + node = push_array(arena, TokenChunkNode, 1); node->cap = cap; - node->v = push_array_no_zero(arena, MD_Token, cap); + node->v = push_array_no_zero(arena, Token, cap); SLLQueuePush(list->first, list->last, node); list->chunk_count += 1; } @@ -106,31 +106,31 @@ md_token_chunk_list_push(Arena *arena, MD_TokenChunkList *list, U64 cap, MD_Toke list->total_token_count += 1; } -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) { - MD_TokenArray result = {0}; + TokenArray result = {0}; result.count = chunks->total_token_count; - result.v = push_array_no_zero(arena, MD_Token, result.count); + result.v = push_array_no_zero(arena, Token, result.count); U64 write_idx = 0; - for(MD_TokenChunkNode *n = chunks->first; n != 0; n = n->next) + for(TokenChunkNode *n = chunks->first; n != 0; n = n->next) { - MemoryCopy(result.v+write_idx, n->v, sizeof(MD_Token)*n->count); + MemoryCopy(result.v+write_idx, n->v, sizeof(Token)*n->count); write_idx += n->count; } return result; } internal String8 -md_content_string_from_token_flags_str8(MD_TokenFlags flags, String8 string) +md_content_string_from_token_flags_str8(TokenFlags flags, String8 string) { U64 num_chop = 0; U64 num_skip = 0; { - num_skip += 3*!!(flags & MD_TokenFlag_StringTriplet); - num_chop += 3*!!(flags & MD_TokenFlag_StringTriplet); - num_skip += 1*(!(flags & MD_TokenFlag_StringTriplet) && flags & MD_TokenFlag_StringLiteral); - num_chop += 1*(!(flags & MD_TokenFlag_StringTriplet) && flags & MD_TokenFlag_StringLiteral); + num_skip += 3*!!(flags & TokenFlag_StringTriplet); + num_chop += 3*!!(flags & TokenFlag_StringTriplet); + num_skip += 1*(!(flags & TokenFlag_StringTriplet) && flags & TokenFlag_StringLiteral); + num_chop += 1*(!(flags & TokenFlag_StringTriplet) && flags & TokenFlag_StringLiteral); } String8 result = string; result = str8_chop(result, num_chop); @@ -143,46 +143,46 @@ md_content_string_from_token_flags_str8(MD_TokenFlags flags, String8 string) //- rjf: flag conversions -internal MD_NodeFlags -md_node_flags_from_token_flags(MD_TokenFlags flags) +internal NodeFlags +md_node_flags_from_token_flags(TokenFlags flags) { - MD_NodeFlags result = 0; - result |= MD_NodeFlag_Identifier*!!(flags&MD_TokenFlag_Identifier); - result |= MD_NodeFlag_Numeric*!!(flags&MD_TokenFlag_Numeric); - result |= MD_NodeFlag_StringLiteral*!!(flags&MD_TokenFlag_StringLiteral); - result |= MD_NodeFlag_Symbol*!!(flags&MD_TokenFlag_Symbol); - result |= MD_NodeFlag_StringSingleQuote *!!(flags&MD_TokenFlag_StringSingleQuote); - result |= MD_NodeFlag_StringDoubleQuote *!!(flags&MD_TokenFlag_StringDoubleQuote); - result |= MD_NodeFlag_StringTick*!!(flags&MD_TokenFlag_StringTick); - result |= MD_NodeFlag_StringTriplet*!!(flags&MD_TokenFlag_StringTriplet); + NodeFlags result = 0; + result |= NodeFlag_Identifier*!!(flags&TokenFlag_Identifier); + result |= NodeFlag_Numeric*!!(flags&TokenFlag_Numeric); + result |= NodeFlag_StringLiteral*!!(flags&TokenFlag_StringLiteral); + result |= NodeFlag_Symbol*!!(flags&TokenFlag_Symbol); + result |= NodeFlag_StringSingleQuote *!!(flags&TokenFlag_StringSingleQuote); + result |= NodeFlag_StringDoubleQuote *!!(flags&TokenFlag_StringDoubleQuote); + result |= NodeFlag_StringTick*!!(flags&TokenFlag_StringTick); + result |= NodeFlag_StringTriplet*!!(flags&TokenFlag_StringTriplet); return result; } //- rjf: nil internal B32 -md_node_is_nil(MD_Node *node) +md_node_is_nil(Node *node) { - return (node == 0 || node == &md_nil_node || node->kind == MD_NodeKind_Nil); + return (node == 0 || node == nil_node() || node->kind == NodeKind_Nil); } //- rjf: iteration -internal MD_NodeRec -md_node_rec_depth_first(MD_Node *node, MD_Node *subtree_root, U64 child_off, U64 sib_off) +internal NodeRec +node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off) { - MD_NodeRec rec = {0}; - rec.next = &md_nil_node; - if(!md_node_is_nil(*MemberFromOffset(MD_Node **, node, child_off))) + NodeRec rec = {0}; + rec.next = nil_node(); + if(!md_node_is_nil(*member_from_offset(Node **, node, child_off))) { - rec.next = *MemberFromOffset(MD_Node **, node, child_off); + rec.next = *member_from_offset(Node **, node, child_off); rec.push_count = 1; } - else for(MD_Node *p = node; !md_node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1) + else for(Node *p = node; !md_node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1) { - if(!md_node_is_nil(*MemberFromOffset(MD_Node **, p, sib_off))) + if(!md_node_is_nil(*member_from_offset(Node **, p, sib_off))) { - rec.next = *MemberFromOffset(MD_Node **, p, sib_off); + rec.next = *member_from_offset(Node **, p, sib_off); break; } } @@ -191,11 +191,11 @@ md_node_rec_depth_first(MD_Node *node, MD_Node *subtree_root, U64 child_off, U64 //- 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) { - MD_Node *node = push_array(arena, MD_Node, 1); - node->first = node->last = node->parent = node->next = node->prev = node->first_tag = node->last_tag = &md_nil_node; + Node *node = push_array(arena, Node, 1); + node->first = node->last = node->parent = node->next = node->prev = node->first_tag = node->last_tag = nil_node(); node->kind = kind; node->flags = flags; node->string = string; @@ -205,60 +205,60 @@ md_push_node(Arena *arena, MD_NodeKind kind, MD_NodeFlags flags, String8 string, } internal void -md_node_insert_child(MD_Node *parent, MD_Node *prev_child, MD_Node *node) +md_node_insert_child(Node *parent, Node *prev_child, Node *node) { node->parent = parent; - DLLInsert_NPZ(&md_nil_node, parent->first, parent->last, prev_child, node, next, prev); + dll_insert_npz(nil_node(), parent->first, parent->last, prev_child, node, next, prev); } internal void -md_node_insert_tag(MD_Node *parent, MD_Node *prev_child, MD_Node *node) +md_node_insert_tag(Node *parent, Node *prev_child, Node *node) { - node->kind = MD_NodeKind_Tag; + node->kind = NodeKind_Tag; node->parent = parent; - DLLInsert_NPZ(&md_nil_node, parent->first_tag, parent->last_tag, prev_child, node, next, prev); + dll_insert_npz(nil_node(), parent->first_tag, parent->last_tag, prev_child, node, next, prev); } internal void -md_node_push_child(MD_Node *parent, MD_Node *node) +md_node_push_child(Node *parent, Node *node) { node->parent = parent; - DLLPushBack_NPZ(&md_nil_node, parent->first, parent->last, node, next, prev); + dll_push_back_npz(nil_node(), parent->first, parent->last, node, next, prev); } internal void -md_node_push_tag(MD_Node *parent, MD_Node *node) +md_node_push_tag(Node *parent, Node *node) { - node->kind = MD_NodeKind_Tag; + node->kind = NodeKind_Tag; node->parent = parent; - DLLPushBack_NPZ(&md_nil_node, parent->first_tag, parent->last_tag, node, next, prev); + dll_push_back_npz(nil_node(), parent->first_tag, parent->last_tag, node, next, prev); } internal void -md_unhook(MD_Node *node) +md_unhook(Node *node) { - MD_Node *parent = node->parent; + Node *parent = node->parent; if(!md_node_is_nil(parent)) { - if(node->kind == MD_NodeKind_Tag) + if(node->kind == NodeKind_Tag) { - DLLRemove_NPZ(&md_nil_node, parent->first_tag, parent->last_tag, node, next, prev); + dll_remove_npz(nil_node(), parent->first_tag, parent->last_tag, node, next, prev); } else { - DLLRemove_NPZ(&md_nil_node, parent->first, parent->last, node, next, prev); + dll_remove_npz(nil_node(), parent->first, parent->last, node, next, prev); } - node->parent = &md_nil_node; + node->parent = nil_node(); } } //- 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) { - MD_Node *result = &md_nil_node; - for(MD_Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next) + Node *result = nil_node(); + for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next) { if(str8_match(n->string, string, flags)) { @@ -269,12 +269,12 @@ md_node_from_chain_string(MD_Node *first, MD_Node *opl, String8 string, StringMa return result; } -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) { - MD_Node *result = &md_nil_node; + Node *result = nil_node(); S64 idx = 0; - for(MD_Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next, idx += 1) + for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next, idx += 1) { if(index == idx) { @@ -285,11 +285,11 @@ md_node_from_chain_index(MD_Node *first, MD_Node *opl, U64 index) return result; } -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) { - MD_Node *result = &md_nil_node; - for(MD_Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next) + Node *result = nil_node(); + for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next) { if(n->flags & flags) { @@ -301,83 +301,83 @@ md_node_from_chain_flags(MD_Node *first, MD_Node *opl, MD_NodeFlags flags) } internal U64 -md_index_from_node(MD_Node *node) +md_index_from_node(Node *node) { U64 index = 0; - for(MD_Node *n = node->prev; !md_node_is_nil(n); n = n->prev) + for(Node *n = node->prev; !md_node_is_nil(n); n = n->prev) { index += 1; } return index; } -internal MD_Node * -md_root_from_node(MD_Node *node) +internal Node * +md_root_from_node(Node *node) { - MD_Node *result = node; - for(MD_Node *p = node->parent; (p->kind == MD_NodeKind_Main || p->kind == MD_NodeKind_Tag) && !md_node_is_nil(p); p = p->parent) + Node *result = node; + for(Node *p = node->parent; (p->kind == NodeKind_Main || p->kind == NodeKind_Tag) && !md_node_is_nil(p); p = p->parent) { result = p; } return result; } -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) { - return md_node_from_chain_string(node->first, &md_nil_node, child_string, flags); + return md_node_from_chain_string(node->first, nil_node(), child_string, 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) { - return md_node_from_chain_string(node->first_tag, &md_nil_node, tag_string, flags); + return md_node_from_chain_string(node->first_tag, nil_node(), tag_string, flags); } -internal MD_Node * -md_child_from_index(MD_Node *node, U64 index) +internal Node * +md_child_from_index(Node *node, U64 index) { - return md_node_from_chain_index(node->first, &md_nil_node, index); + return md_node_from_chain_index(node->first, nil_node(), index); } -internal MD_Node * -md_tag_from_index(MD_Node *node, U64 index) +internal Node * +md_tag_from_index(Node *node, U64 index) { - return md_node_from_chain_index(node->first_tag, &md_nil_node, index); + return md_node_from_chain_index(node->first_tag, nil_node(), 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) { - MD_Node *tag = md_tag_from_string(node, tag_string, flags); + Node *tag = md_tag_from_string(node, tag_string, flags); return md_child_from_index(tag, 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) { - MD_Node *tag = md_tag_from_string(node, tag_string, tag_str_flags); - MD_Node *arg = md_child_from_string(tag, arg_string, arg_str_flags); + Node *tag = md_tag_from_string(node, tag_string, tag_str_flags); + Node *arg = md_child_from_string(tag, arg_string, arg_str_flags); return arg; } internal B32 -md_node_has_child(MD_Node *node, String8 string, StringMatchFlags flags) +md_node_has_child(Node *node, String8 string, StringMatchFlags flags) { return !md_node_is_nil(md_child_from_string(node, string, flags)); } internal B32 -md_node_has_tag(MD_Node *node, String8 string, StringMatchFlags flags) +md_node_has_tag(Node *node, String8 string, StringMatchFlags flags) { return !md_node_is_nil(md_tag_from_string(node, string, flags)); } internal U64 -md_child_count_from_node(MD_Node *node) +md_child_count_from_node(Node *node) { U64 result = 0; - for(MD_Node *child = node->first; !md_node_is_nil(child); child = child->next) + for(Node *child = node->first; !md_node_is_nil(child); child = child->next) { result += 1; } @@ -385,10 +385,10 @@ md_child_count_from_node(MD_Node *node) } internal U64 -md_tag_count_from_node(MD_Node *node) +md_tag_count_from_node(Node *node) { U64 result = 0; - for(MD_Node *child = node->first_tag; !md_node_is_nil(child); child = child->next) + for(Node *child = node->first_tag; !md_node_is_nil(child); child = child->next) { result += 1; } @@ -396,9 +396,9 @@ md_tag_count_from_node(MD_Node *node) } internal String8 -md_string_from_children(Arena *arena, MD_Node *root) +md_string_from_children(Arena *arena, Node *root) { - Temp scratch = scratch_begin(&arena, 1); + TempArena scratch = scratch_begin(&arena, 1); String8List strs = {0}; for MD_EachNode(child, root->first) { @@ -416,7 +416,7 @@ md_string_from_children(Arena *arena, MD_Node *root) //- rjf: tree comparison internal B32 -md_node_match(MD_Node *a, MD_Node *b, StringMatchFlags flags) +md_node_match(Node *a, Node *b, StringMatchFlags flags) { B32 result = 0; if(a->kind == b->kind && str8_match(a->string, b->string, flags)) @@ -426,15 +426,15 @@ md_node_match(MD_Node *a, MD_Node *b, StringMatchFlags flags) { result = result && a->flags == b->flags; } - if(result && a->kind != MD_NodeKind_Tag) + if(result && a->kind != NodeKind_Tag) { - for(MD_Node *a_tag = a->first_tag, *b_tag = b->first_tag; + for(Node *a_tag = a->first_tag, *b_tag = b->first_tag; !md_node_is_nil(a_tag) || !md_node_is_nil(b_tag); a_tag = a_tag->next, b_tag = b_tag->next) { if(md_node_match(a_tag, b_tag, flags)) { - for(MD_Node *a_tag_arg = a_tag->first, *b_tag_arg = b_tag->first; + for(Node *a_tag_arg = a_tag->first, *b_tag_arg = b_tag->first; !md_node_is_nil(a_tag_arg) || !md_node_is_nil(b_tag_arg); a_tag_arg = a_tag_arg->next, b_tag_arg = b_tag_arg->next) { @@ -458,12 +458,12 @@ md_node_match(MD_Node *a, MD_Node *b, StringMatchFlags flags) } internal B32 -md_tree_match(MD_Node *a, MD_Node *b, StringMatchFlags flags) +md_tree_match(Node *a, Node *b, StringMatchFlags flags) { B32 result = md_node_match(a, b, flags); if(result) { - for(MD_Node *a_child = a->first, *b_child = b->first; + for(Node *a_child = a->first, *b_child = b->first; !md_node_is_nil(a_child) || !md_node_is_nil(b_child); a_child = a_child->next, b_child = b_child->next) { @@ -480,33 +480,33 @@ md_tree_match(MD_Node *a, MD_Node *b, StringMatchFlags flags) //- 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 *dst_root = &md_nil_node; - MD_Node *dst_parent = dst_root; + Node *dst_root = nil_node(); + Node *dst_parent = dst_root; { - MD_NodeRec rec = {0}; - for(MD_Node *src = src_root; !md_node_is_nil(src); src = rec.next) + NodeRec rec = {0}; + for(Node *src = src_root; !md_node_is_nil(src); src = rec.next) { - MD_Node *dst = push_array(arena, MD_Node, 1); - dst->first = dst->last = dst->parent = dst->next = dst->prev = &md_nil_node; - dst->first_tag = dst->last_tag = &md_nil_node; + Node *dst = push_array(arena, Node, 1); + dst->first = dst->last = dst->parent = dst->next = dst->prev = nil_node(); + dst->first_tag = dst->last_tag = nil_node(); dst->kind = src->kind; dst->flags = src->flags; dst->string = push_str8_copy(arena, src->string); dst->raw_string = push_str8_copy(arena, src->raw_string); dst->src_offset = src->src_offset; dst->parent = dst_parent; - if(dst_parent != &md_nil_node) + if(dst_parent != nil_node()) { - DLLPushBack_NPZ(&md_nil_node, dst_parent->first, dst_parent->last, dst, next, prev); + dll_push_back_npz(nil_node(), dst_parent->first, dst_parent->last, dst, next, prev); } else { dst_root = dst_parent = dst; } - rec = md_node_rec_depth_first_pre(src, src_root); + rec = node_rec_depth_first_pre(src, src_root); if(rec.push_count != 0) { dst_parent = dst; @@ -523,12 +523,12 @@ md_tree_copy(Arena *arena, MD_Node *src_root) //////////////////////////////// //~ rjf: Text -> Tokens Functions -internal MD_TokenizeResult +internal TokenizeResult md_tokenize_from_text(Arena *arena, String8 text) { - Temp scratch = scratch_begin(&arena, 1); - MD_TokenChunkList tokens = {0}; - MD_MsgList msgs = {0}; + TempArena scratch = scratch_begin(&arena, 1); + TokenChunkList tokens = {0}; + MsgList msgs = {0}; U8 *byte_first = text.str; U8 *byte_opl = byte_first + text.size; U8 *byte = byte_first; @@ -536,14 +536,14 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf: scan string & produce tokens for(;byte < byte_opl;) { - MD_TokenFlags token_flags = 0; + TokenFlags token_flags = 0; U8 *token_start = 0; U8 *token_opl = 0; //- rjf: whitespace if(token_flags == 0 && (*byte == ' ' || *byte == '\t' || *byte == '\v' || *byte == '\r')) { - token_flags = MD_TokenFlag_Whitespace; + token_flags = TokenFlag_Whitespace; token_start = byte; token_opl = byte; byte += 1; @@ -560,7 +560,7 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf: newlines if(token_flags == 0 && *byte == '\n') { - token_flags = MD_TokenFlag_Newline; + token_flags = TokenFlag_Newline; token_start = byte; token_opl = byte+1; byte += 1; @@ -569,7 +569,7 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf: single-line comments if(token_flags == 0 && (byte+1 < byte_opl && *byte == '/' && byte[1] == '/')) { - token_flags = MD_TokenFlag_Comment; + token_flags = TokenFlag_Comment; token_start = byte; token_opl = byte+2; byte += 2; @@ -602,7 +602,7 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf: multi-line comments if(token_flags == 0 && (byte+1 < byte_opl && *byte == '/' && byte[1] == '*')) { - token_flags = MD_TokenFlag_Comment; + token_flags = TokenFlag_Comment; token_start = byte; token_opl = byte+2; byte += 2; @@ -611,7 +611,7 @@ md_tokenize_from_text(Arena *arena, String8 text) token_opl += 1; if(byte == byte_opl) { - token_flags |= MD_TokenFlag_BrokenComment; + token_flags |= TokenFlag_BrokenComment; break; } if(byte+1 < byte_opl && byte[0] == '*' && byte[1] == '/') @@ -626,9 +626,9 @@ md_tokenize_from_text(Arena *arena, String8 text) if(token_flags == 0 && (('A' <= *byte && *byte <= 'Z') || ('a' <= *byte && *byte <= 'z') || *byte == '_' || - utf8_class[*byte>>3] >= 2 )) + utf8_class(*byte>>3) >= 2 )) { - token_flags = MD_TokenFlag_Identifier; + token_flags = TokenFlag_Identifier; token_start = byte; token_opl = byte; byte += 1; @@ -640,7 +640,7 @@ md_tokenize_from_text(Arena *arena, String8 text) !('a' <= *byte && *byte <= 'z') && !('0' <= *byte && *byte <= '9') && *byte != '_' && - utf8_class[*byte>>3] < 2)) + utf8_class(*byte>>3) < 2)) { break; } @@ -653,7 +653,7 @@ md_tokenize_from_text(Arena *arena, String8 text) (*byte == '-' && byte+1 < byte_opl && '0' <= byte[1] && byte[1] <= '9') || *byte == '_')) { - token_flags = MD_TokenFlag_Numeric; + token_flags = TokenFlag_Numeric; token_start = byte; token_opl = byte; byte += 1; @@ -679,10 +679,10 @@ md_tokenize_from_text(Arena *arena, String8 text) (byte[0] == '`' && byte[1] == '`' && byte[2] == '`'))) { U8 literal_style = byte[0]; - token_flags = MD_TokenFlag_StringLiteral|MD_TokenFlag_StringTriplet; - token_flags |= (literal_style == '\'')*MD_TokenFlag_StringSingleQuote; - token_flags |= (literal_style == '"')*MD_TokenFlag_StringDoubleQuote; - token_flags |= (literal_style == '`')*MD_TokenFlag_StringTick; + token_flags = TokenFlag_StringLiteral|TokenFlag_StringTriplet; + token_flags |= (literal_style == '\'')*TokenFlag_StringSingleQuote; + token_flags |= (literal_style == '"')*TokenFlag_StringDoubleQuote; + token_flags |= (literal_style == '`')*TokenFlag_StringTick; token_start = byte; token_opl = byte+3; byte += 3; @@ -690,7 +690,7 @@ md_tokenize_from_text(Arena *arena, String8 text) { if(byte == byte_opl) { - token_flags |= MD_TokenFlag_BrokenStringLiteral; + token_flags |= TokenFlag_BrokenStringLiteral; token_opl = byte; break; } @@ -707,10 +707,10 @@ md_tokenize_from_text(Arena *arena, String8 text) if(token_flags == 0 && (byte[0] == '"' || byte[0] == '\'' || byte[0] == '`')) { U8 literal_style = byte[0]; - token_flags = MD_TokenFlag_StringLiteral; - token_flags |= (literal_style == '\'')*MD_TokenFlag_StringSingleQuote; - token_flags |= (literal_style == '"')*MD_TokenFlag_StringDoubleQuote; - token_flags |= (literal_style == '`')*MD_TokenFlag_StringTick; + token_flags = TokenFlag_StringLiteral; + token_flags |= (literal_style == '\'')*TokenFlag_StringSingleQuote; + token_flags |= (literal_style == '"')*TokenFlag_StringDoubleQuote; + token_flags |= (literal_style == '`')*TokenFlag_StringTick; token_start = byte; token_opl = byte+1; byte += 1; @@ -720,7 +720,7 @@ md_tokenize_from_text(Arena *arena, String8 text) if(byte == byte_opl || *byte == '\n') { token_opl = byte; - token_flags |= MD_TokenFlag_BrokenStringLiteral; + token_flags |= TokenFlag_BrokenStringLiteral; break; } if(!escaped && byte[0] == '\\') @@ -746,7 +746,7 @@ md_tokenize_from_text(Arena *arena, String8 text) *byte == '<' || *byte == '.' || *byte == '>' || *byte == '/' || *byte == '?' || *byte == '|')) { - token_flags = MD_TokenFlag_Symbol; + token_flags = TokenFlag_Symbol; token_start = byte; token_opl = byte; byte += 1; @@ -769,7 +769,7 @@ md_tokenize_from_text(Arena *arena, String8 text) *byte == '[' || *byte == ']' || *byte == '#' || *byte == ',' || *byte == '\\'|| *byte == ':' || *byte == ';' || *byte == '@')) { - token_flags = MD_TokenFlag_Reserved; + token_flags = TokenFlag_Reserved; token_start = byte; token_opl = byte+1; byte += 1; @@ -778,7 +778,7 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf: bad characters in all other cases if(token_flags == 0) { - token_flags = MD_TokenFlag_BadCharacter; + token_flags = TokenFlag_BadCharacter; token_start = byte; token_opl = byte+1; byte += 1; @@ -787,29 +787,29 @@ md_tokenize_from_text(Arena *arena, String8 text) //- rjf; push token if formed if(token_flags != 0 && token_start != 0 && token_opl > token_start) { - MD_Token token = {{(U64)(token_start - byte_first), (U64)(token_opl - byte_first)}, token_flags}; + Token token = {{(U64)(token_start - byte_first), (U64)(token_opl - byte_first)}, token_flags}; md_token_chunk_list_push(scratch.arena, &tokens, 4096, token); } //- rjf: push errors on unterminated comments - if(token_flags & MD_TokenFlag_BrokenComment) + if(token_flags & TokenFlag_BrokenComment) { - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); String8 error_string = str8_lit("Unterminated comment."); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Error, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Error, error_string); } //- rjf: push errors on unterminated strings - if(token_flags & MD_TokenFlag_BrokenStringLiteral) + if(token_flags & TokenFlag_BrokenStringLiteral) { - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first); String8 error_string = str8_lit("Unterminated string literal."); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Error, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Error, error_string); } } //- rjf: bake, fill & return - MD_TokenizeResult result = {0}; + TokenizeResult result = {0}; { result.tokens = md_token_array_from_chunk_list(arena, &tokens); result.msgs = msgs; @@ -821,14 +821,14 @@ md_tokenize_from_text(Arena *arena, String8 text) //////////////////////////////// //~ 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) { - Temp scratch = scratch_begin(&arena, 1); + TempArena scratch = scratch_begin(&arena, 1); //- rjf: set up outputs - MD_MsgList msgs = {0}; - MD_Node *root = md_push_node(arena, MD_NodeKind_File, 0, filename, text, 0); + MsgList msgs = {0}; + Node *root = md_push_node(arena, NodeKind_File, 0, filename, text, 0); //- rjf: set up parse rule stack typedef enum MD_ParseWorkKind @@ -844,10 +844,10 @@ md_parse_from_text_tokens(Arena *arena, String8 filename, String8 text, MD_Token { MD_ParseWorkNode *next; MD_ParseWorkKind kind; - MD_Node *parent; - MD_Node *first_gathered_tag; - MD_Node *last_gathered_tag; - MD_NodeFlags gathered_node_flags; + Node *parent; + Node *first_gathered_tag; + Node *last_gathered_tag; + NodeFlags gathered_node_flags; S32 counted_newlines; }; MD_ParseWorkNode first_work = @@ -875,23 +875,23 @@ if(work_top == 0) {work_top = &broken_work;}\ }while(0) //- rjf: parse - MD_Token *tokens_first = tokens.v; - MD_Token *tokens_opl = tokens_first + tokens.count; - MD_Token *token = tokens_first; + Token *tokens_first = tokens.v; + Token *tokens_opl = tokens_first + tokens.count; + Token *token = tokens_first; for(;token < tokens_opl;) { //- rjf: unpack token String8 token_string = str8_substr(text, token[0].range); //- rjf: whitespace -> always no-op & inc - if(token->flags & MD_TokenFlag_Whitespace) + if(token->flags & TokenFlag_Whitespace) { token += 1; goto end_consume; } //- rjf: comments -> always no-op & inc - if(token->flags & MD_TokenGroup_Comment) + if(token->flags & TokenGroup_Comment) { token += 1; goto end_consume; @@ -901,7 +901,7 @@ if(work_top == 0) {work_top = &broken_work;}\ // to scan for explicit delimiters, else parse an implicitly delimited set of children if(work_top->kind == MD_ParseWorkKind_NodeOptionalFollowUp && str8_match(token_string, str8_lit(":"), 0)) { - MD_Node *parent = work_top->parent; + Node *parent = work_top->parent; MD_ParseWorkPop(); MD_ParseWorkPush(MD_ParseWorkKind_NodeChildrenStyleScan, parent); token += 1; @@ -917,24 +917,24 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [main] separators -> mark & inc - if(work_top->kind == MD_ParseWorkKind_Main && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_Main && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit(","), 0) || str8_match(token_string, str8_lit(";"), 0))) { - MD_Node *parent = work_top->parent; + Node *parent = work_top->parent; if(!md_node_is_nil(parent->last)) { - parent->last->flags |= MD_NodeFlag_IsBeforeComma*!!str8_match(token_string, str8_lit(","), 0); - parent->last->flags |= MD_NodeFlag_IsBeforeSemicolon*!!str8_match(token_string, str8_lit(";"), 0); - work_top->gathered_node_flags |= MD_NodeFlag_IsAfterComma*!!str8_match(token_string, str8_lit(","), 0); - work_top->gathered_node_flags |= MD_NodeFlag_IsAfterSemicolon*!!str8_match(token_string, str8_lit(";"), 0); + parent->last->flags |= NodeFlag_IsBeforeComma*!!str8_match(token_string, str8_lit(","), 0); + parent->last->flags |= NodeFlag_IsBeforeSemicolon*!!str8_match(token_string, str8_lit(";"), 0); + work_top->gathered_node_flags |= NodeFlag_IsAfterComma*!!str8_match(token_string, str8_lit(","), 0); + work_top->gathered_node_flags |= NodeFlag_IsAfterSemicolon*!!str8_match(token_string, str8_lit(";"), 0); } token += 1; goto end_consume; } //- rjf: [main_implicit] separators -> pop - if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit(","), 0) || str8_match(token_string, str8_lit(";"), 0))) { @@ -944,28 +944,28 @@ if(work_top == 0) {work_top = &broken_work;}\ //- rjf: [main, main_implicit] unexpected reserved tokens if((work_top->kind == MD_ParseWorkKind_Main || work_top->kind == MD_ParseWorkKind_MainImplicit) && - token->flags & MD_TokenFlag_Reserved && + token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit("#"), 0) || str8_match(token_string, str8_lit("\\"), 0) || str8_match(token_string, str8_lit(":"), 0))) { - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); String8 error_string = push_str8f(arena, "Unexpected reserved symbol \"%S\".", token_string); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Error, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Error, error_string); token += 1; goto end_consume; } //- rjf: [main, main_implicit] tag signifier -> create new tag if((work_top->kind == MD_ParseWorkKind_Main || work_top->kind == MD_ParseWorkKind_MainImplicit) && - token[0].flags & MD_TokenFlag_Reserved && str8_match(token_string, str8_lit("@"), 0)) + token[0].flags & TokenFlag_Reserved && str8_match(token_string, str8_lit("@"), 0)) { if(token+1 >= tokens_opl || - !(token[1].flags & MD_TokenGroup_Label)) + !(token[1].flags & TokenGroup_Label)) { - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); String8 error_string = str8_lit("Tag label expected after @ symbol."); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Error, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Error, error_string); token += 1; goto end_consume; } @@ -973,9 +973,9 @@ if(work_top == 0) {work_top = &broken_work;}\ { String8 tag_name_raw = str8_substr(text, token[1].range); String8 tag_name = md_content_string_from_token_flags_str8(token[1].flags, tag_name_raw); - MD_Node *node = md_push_node(arena, MD_NodeKind_Tag, md_node_flags_from_token_flags(token[1].flags), tag_name, tag_name_raw, token[0].range.min); - DLLPushBack_NPZ(&md_nil_node, work_top->first_gathered_tag, work_top->last_gathered_tag, node, next, prev); - if(token+2 < tokens_opl && token[2].flags & MD_TokenFlag_Reserved && str8_match(str8_substr(text, token[2].range), str8_lit("("), 0)) + Node *node = md_push_node(arena, NodeKind_Tag, md_node_flags_from_token_flags(token[1].flags), tag_name, tag_name_raw, token[0].range.min); + dll_push_back_npz(nil_node(), work_top->first_gathered_tag, work_top->last_gathered_tag, node, next, prev); + if(token+2 < tokens_opl && token[2].flags & TokenFlag_Reserved && str8_match(str8_substr(text, token[2].range), str8_lit("("), 0)) { token += 3; MD_ParseWorkPush(MD_ParseWorkKind_Main, node); @@ -990,20 +990,20 @@ if(work_top == 0) {work_top = &broken_work;}\ //- rjf: [main, main_implicit] label -> create new main if((work_top->kind == MD_ParseWorkKind_Main || work_top->kind == MD_ParseWorkKind_MainImplicit) && - token->flags & MD_TokenGroup_Label) + token->flags & TokenGroup_Label) { String8 node_string_raw = token_string; String8 node_string = md_content_string_from_token_flags_str8(token->flags, node_string_raw); - MD_NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags; + NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags; work_top->gathered_node_flags = 0; - MD_Node *node = md_push_node(arena, MD_NodeKind_Main, flags, node_string, node_string_raw, token[0].range.min); + Node *node = md_push_node(arena, NodeKind_Main, flags, node_string, node_string_raw, token[0].range.min); node->first_tag = work_top->first_gathered_tag; node->last_tag = work_top->last_gathered_tag; - for(MD_Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next) + for(Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next) { tag->parent = node; } - work_top->first_gathered_tag = work_top->last_gathered_tag = &md_nil_node; + work_top->first_gathered_tag = work_top->last_gathered_tag = nil_node(); md_node_push_child(work_top->parent, node); MD_ParseWorkPush(MD_ParseWorkKind_NodeOptionalFollowUp, node); token += 1; @@ -1011,24 +1011,24 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [main] {s, [s, and (s -> create new main - if(work_top->kind == MD_ParseWorkKind_Main && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_Main && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit("{"), 0) || str8_match(token_string, str8_lit("["), 0) || str8_match(token_string, str8_lit("("), 0))) { - MD_NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags; - flags |= MD_NodeFlag_HasBraceLeft*!!str8_match(token_string, str8_lit("{"), 0); - flags |= MD_NodeFlag_HasBracketLeft*!!str8_match(token_string, str8_lit("["), 0); - flags |= MD_NodeFlag_HasParenLeft*!!str8_match(token_string, str8_lit("("), 0); + NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags; + flags |= NodeFlag_HasBraceLeft*!!str8_match(token_string, str8_lit("{"), 0); + flags |= NodeFlag_HasBracketLeft*!!str8_match(token_string, str8_lit("["), 0); + flags |= NodeFlag_HasParenLeft*!!str8_match(token_string, str8_lit("("), 0); work_top->gathered_node_flags = 0; - MD_Node *node = md_push_node(arena, MD_NodeKind_Main, flags, str8_lit(""), str8_lit(""), token[0].range.min); + Node *node = md_push_node(arena, NodeKind_Main, flags, str8_lit(""), str8_lit(""), token[0].range.min); node->first_tag = work_top->first_gathered_tag; node->last_tag = work_top->last_gathered_tag; - for(MD_Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next) + for(Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next) { tag->parent = node; } - work_top->first_gathered_tag = work_top->last_gathered_tag = &md_nil_node; + work_top->first_gathered_tag = work_top->last_gathered_tag = nil_node(); md_node_push_child(work_top->parent, node); MD_ParseWorkPush(MD_ParseWorkKind_Main, node); token += 1; @@ -1036,15 +1036,15 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [node children style scan] {s, [s, and (s -> explicitly delimited children - if(work_top->kind == MD_ParseWorkKind_NodeChildrenStyleScan && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_NodeChildrenStyleScan && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit("{"), 0) || str8_match(token_string, str8_lit("["), 0) || str8_match(token_string, str8_lit("("), 0))) { - MD_Node *parent = work_top->parent; - parent->flags |= MD_NodeFlag_HasBraceLeft*!!str8_match(token_string, str8_lit("{"), 0); - parent->flags |= MD_NodeFlag_HasBracketLeft*!!str8_match(token_string, str8_lit("["), 0); - parent->flags |= MD_NodeFlag_HasParenLeft*!!str8_match(token_string, str8_lit("("), 0); + Node *parent = work_top->parent; + parent->flags |= NodeFlag_HasBraceLeft*!!str8_match(token_string, str8_lit("{"), 0); + parent->flags |= NodeFlag_HasBracketLeft*!!str8_match(token_string, str8_lit("["), 0); + parent->flags |= NodeFlag_HasParenLeft*!!str8_match(token_string, str8_lit("("), 0); MD_ParseWorkPop(); MD_ParseWorkPush(MD_ParseWorkKind_Main, parent); token += 1; @@ -1052,7 +1052,7 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [node children style scan] count newlines - if(work_top->kind == MD_ParseWorkKind_NodeChildrenStyleScan && token->flags & MD_TokenFlag_Newline) + if(work_top->kind == MD_ParseWorkKind_NodeChildrenStyleScan && token->flags & TokenFlag_Newline) { work_top->counted_newlines += 1; token += 1; @@ -1060,7 +1060,7 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [main_implicit] newline -> pop - if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & MD_TokenFlag_Newline) + if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & TokenFlag_Newline) { MD_ParseWorkPop(); token += 1; @@ -1068,7 +1068,7 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [all but main_implicit] newline -> no-op & inc - if(work_top->kind != MD_ParseWorkKind_MainImplicit && token->flags & MD_TokenFlag_Newline) + if(work_top->kind != MD_ParseWorkKind_MainImplicit && token->flags & TokenFlag_Newline) { token += 1; goto end_consume; @@ -1080,15 +1080,15 @@ if(work_top == 0) {work_top = &broken_work;}\ { if(work_top->counted_newlines >= 2) { - MD_Node *node = work_top->parent; - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); + Node *node = work_top->parent; + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); String8 error_string = push_str8f(arena, "More than two newlines following \"%S\", which has implicitly-delimited children, resulting in an empty list of children.", node->string); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Warning, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Warning, error_string); MD_ParseWorkPop(); } else { - MD_Node *parent = work_top->parent; + Node *parent = work_top->parent; MD_ParseWorkPop(); MD_ParseWorkPush(MD_ParseWorkKind_MainImplicit, parent); } @@ -1096,22 +1096,22 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: [main] }s, ]s, and )s -> pop - if(work_top->kind == MD_ParseWorkKind_Main && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_Main && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit("}"), 0) || str8_match(token_string, str8_lit("]"), 0) || str8_match(token_string, str8_lit(")"), 0))) { - MD_Node *parent = work_top->parent; - parent->flags |= MD_NodeFlag_HasBraceRight*!!str8_match(token_string, str8_lit("}"), 0); - parent->flags |= MD_NodeFlag_HasBracketRight*!!str8_match(token_string, str8_lit("]"), 0); - parent->flags |= MD_NodeFlag_HasParenRight*!!str8_match(token_string, str8_lit(")"), 0); + Node *parent = work_top->parent; + parent->flags |= NodeFlag_HasBraceRight*!!str8_match(token_string, str8_lit("}"), 0); + parent->flags |= NodeFlag_HasBracketRight*!!str8_match(token_string, str8_lit("]"), 0); + parent->flags |= NodeFlag_HasParenRight*!!str8_match(token_string, str8_lit(")"), 0); MD_ParseWorkPop(); token += 1; goto end_consume; } //- rjf: [main implicit] }s, ]s, and )s -> pop without advancing - if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & MD_TokenFlag_Reserved && + if(work_top->kind == MD_ParseWorkKind_MainImplicit && token->flags & TokenFlag_Reserved && (str8_match(token_string, str8_lit("}"), 0) || str8_match(token_string, str8_lit("]"), 0) || str8_match(token_string, str8_lit(")"), 0))) @@ -1122,9 +1122,9 @@ if(work_top == 0) {work_top = &broken_work;}\ //- rjf: no consumption -> unexpected token! we don't know what to do with this. { - MD_Node *error = md_push_node(arena, MD_NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); + Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min); String8 error_string = push_str8f(arena, "Unexpected \"%S\" token.", token_string); - md_msg_list_push(arena, &msgs, error, MD_MsgKind_Error, error_string); + md_msg_list_push(arena, &msgs, error, MsgKind_Error, error_string); token += 1; } @@ -1132,7 +1132,7 @@ if(work_top == 0) {work_top = &broken_work;}\ } //- rjf: fill & return - MD_ParseResult result = {0}; + ParseResult result = {0}; result.root = root; result.msgs = msgs; scratch_end(scratch); @@ -1142,12 +1142,12 @@ if(work_top == 0) {work_top = &broken_work;}\ //////////////////////////////// //~ rjf: Bundled Text -> Tree Functions -internal MD_ParseResult +internal ParseResult md_parse_from_text(Arena *arena, String8 filename, String8 text) { - Temp scratch = scratch_begin(&arena, 1); - MD_TokenizeResult tokenize = md_tokenize_from_text(scratch.arena, text); - MD_ParseResult parse = md_parse_from_text_tokens(arena, filename, text, tokenize.tokens); + TempArena scratch = scratch_begin(&arena, 1); + TokenizeResult tokenize = md_tokenize_from_text(scratch.arena, text); + ParseResult parse = md_parse_from_text_tokens(arena, filename, text, tokenize.tokens); scratch_end(scratch); return parse; } @@ -1156,16 +1156,16 @@ md_parse_from_text(Arena *arena, String8 filename, String8 text) //~ rjf: Tree -> Text Functions internal String8List -md_debug_string_list_from_tree(Arena *arena, MD_Node *root) +md_debug_string_list_from_tree(Arena *arena, Node *root) { String8List strings = {0}; { char *indentation = " "; S32 depth = 0; - for(MD_Node *node = root, *next = &md_nil_node; !md_node_is_nil(node); node = next) + for(Node *node = root, *next = nil_node(); !md_node_is_nil(node); node = next) { // rjf: get next recursion - MD_NodeRec rec = md_node_rec_depth_first_pre(node, root); + NodeRec rec = node_rec_depth_first_pre(node, root); next = rec.next; // rjf: extract node info @@ -1173,12 +1173,12 @@ md_debug_string_list_from_tree(Arena *arena, MD_Node *root) switch(node->kind) { default:{}break; - case MD_NodeKind_File: {kind_string = str8_lit("File"); }break; - case MD_NodeKind_ErrorMarker:{kind_string = str8_lit("ErrorMarker");}break; - case MD_NodeKind_Main: {kind_string = str8_lit("Main"); }break; - case MD_NodeKind_Tag: {kind_string = str8_lit("Tag"); }break; - case MD_NodeKind_List: {kind_string = str8_lit("List"); }break; - case MD_NodeKind_Reference: {kind_string = str8_lit("Reference"); }break; + case NodeKind_File: {kind_string = str8_lit("File"); }break; + case NodeKind_ErrorMarker:{kind_string = str8_lit("ErrorMarker");}break; + case NodeKind_Main: {kind_string = str8_lit("Main"); }break; + case NodeKind_Tag: {kind_string = str8_lit("Tag"); }break; + case NodeKind_List: {kind_string = str8_lit("List"); }break; + case NodeKind_Reference: {kind_string = str8_lit("Reference"); }break; } // rjf: push node line diff --git a/code/mdesk/mdesk.h b/code/mdesk/mdesk.h index f38d715..350ab40 100644 --- a/code/mdesk/mdesk.h +++ b/code/mdesk/mdesk.h @@ -1,9 +1,7 @@ #if INTELLISENSE_DIRECTIVES -#pragma once -#include "base/base_types.h" -#include "base/math.h" -#include "base/arena.h" -#include "base/string.h" +# pragma once +# include "base/base.h" +# include "os/os.h" #endif // Copyright (c) 2024 Epic Games Tools @@ -14,11 +12,11 @@ typedef enum MsgKind { - MsgKind_Null, - MsgKind_Note, - MsgKind_Warning, - MsgKind_Error, - MsgKind_FatalError, + MsgKind_Null, + MsgKind_Note, + MsgKind_Warning, + MsgKind_Error, + MsgKind_FatalError, } MsgKind; @@ -26,19 +24,19 @@ typedef struct Node Node; typedef struct Msg Msg; struct Msg { - Msg* next; - Node* node; - MsgKind kind; - String8 string; + Msg* next; + Node* node; + MsgKind kind; + String8 string; }; typedef struct MsgList MsgList; struct MsgList { - Msg* first; - Msg* last; - U64 count; - MsgKind worst_message_kind; + Msg* first; + Msg* last; + U64 count; + MsgKind worst_message_kind; }; //////////////////////////////// @@ -47,69 +45,69 @@ struct MsgList typedef U32 TokenFlags; enum { - // rjf: base kind info - TokenFlag_Identifier = (1<<0), - TokenFlag_Numeric = (1<<1), - TokenFlag_StringLiteral = (1<<2), - TokenFlag_Symbol = (1<<3), - TokenFlag_Reserved = (1<<4), - TokenFlag_Comment = (1<<5), - TokenFlag_Whitespace = (1<<6), - TokenFlag_Newline = (1<<7), - - // rjf: decoration info - TokenFlag_StringSingleQuote = (1<<8), - TokenFlag_StringDoubleQuote = (1<<9), - TokenFlag_StringTick = (1<<10), - TokenFlag_StringTriplet = (1<<11), - - // rjf: error info - TokenFlag_BrokenComment = (1<<12), - TokenFlag_BrokenStringLiteral = (1<<13), - TokenFlag_BadCharacter = (1<<14), + // rjf: base kind info + TokenFlag_Identifier = (1<<0), + TokenFlag_Numeric = (1<<1), + TokenFlag_StringLiteral = (1<<2), + TokenFlag_Symbol = (1<<3), + TokenFlag_Reserved = (1<<4), + TokenFlag_Comment = (1<<5), + TokenFlag_Whitespace = (1<<6), + TokenFlag_Newline = (1<<7), + + // rjf: decoration info + TokenFlag_StringSingleQuote = (1<<8), + TokenFlag_StringDoubleQuote = (1<<9), + TokenFlag_StringTick = (1<<10), + TokenFlag_StringTriplet = (1<<11), + + // rjf: error info + TokenFlag_BrokenComment = (1<<12), + TokenFlag_BrokenStringLiteral = (1<<13), + TokenFlag_BadCharacter = (1<<14), }; typedef U32 TokenGroups; enum { - TokenGroup_Comment = TokenFlag_Comment, - TokenGroup_Whitespace = (TokenFlag_Whitespace| TokenFlag_Newline), - TokenGroup_Irregular = (TokenGroup_Comment | TokenGroup_Whitespace), - TokenGroup_Regular = ~TokenGroup_Irregular, - TokenGroup_Label = (TokenFlag_Identifier | TokenFlag_Numeric | TokenFlag_StringLiteral | TokenFlag_Symbol), - TokenGroup_Error = (TokenFlag_BrokenComment | TokenFlag_BrokenStringLiteral | TokenFlag_BadCharacter), + TokenGroup_Comment = TokenFlag_Comment, + TokenGroup_Whitespace = (TokenFlag_Whitespace| TokenFlag_Newline), + TokenGroup_Irregular = (TokenGroup_Comment | TokenGroup_Whitespace), + TokenGroup_Regular = ~TokenGroup_Irregular, + TokenGroup_Label = (TokenFlag_Identifier | TokenFlag_Numeric | TokenFlag_StringLiteral | TokenFlag_Symbol), + TokenGroup_Error = (TokenFlag_BrokenComment | TokenFlag_BrokenStringLiteral | TokenFlag_BadCharacter), }; typedef struct Token Token; struct Token { - Rng1U64 range; - TokenFlags flags; + Rng1U64 range; + TokenFlags flags; }; typedef struct TokenChunkNode TokenChunkNode; struct TokenChunkNode { - TokenChunkNode *next; - Token *v; - U64 count; - U64 cap; + TokenChunkNode* next; + Token* v; + U64 count; + U64 cap; }; typedef struct TokenChunkList TokenChunkList; struct TokenChunkList { - TokenChunkNode* first; - TokenChunkNode* last; - U64 chunk_count; - U64 total_token_count; + TokenChunkNode* first; + TokenChunkNode* last; + U64 chunk_count; + U64 total_token_count; }; typedef struct TokenArray TokenArray; struct TokenArray { - Token* v; - U64 count; + Token* v; + U64 count; }; //////////////////////////////// @@ -117,208 +115,217 @@ struct TokenArray typedef enum NodeKind { - NodeKind_Nil, - NodeKind_File, - NodeKind_ErrorMarker, - NodeKind_Main, - NodeKind_Tag, - NodeKind_List, - NodeKind_Reference, - NodeKind_COUNT + NodeKind_Nil, + NodeKind_File, + NodeKind_ErrorMarker, + NodeKind_Main, + NodeKind_Tag, + NodeKind_List, + NodeKind_Reference, + NodeKind_COUNT } NodeKind; typedef U32 NodeFlags; enum { - NodeFlag_MaskSetDelimiters = (0x3F<<0), - NodeFlag_HasParenLeft = (1<<0), - NodeFlag_HasParenRight = (1<<1), - NodeFlag_HasBracketLeft = (1<<2), - NodeFlag_HasBracketRight = (1<<3), - NodeFlag_HasBraceLeft = (1<<4), - NodeFlag_HasBraceRight = (1<<5), - - NodeFlag_MaskSeparators = (0xF<<6), - NodeFlag_IsBeforeSemicolon = (1<<6), - NodeFlag_IsAfterSemicolon = (1<<7), - NodeFlag_IsBeforeComma = (1<<8), - NodeFlag_IsAfterComma = (1<<9), - - NodeFlag_MaskStringDelimiters = (0xF<<10), - NodeFlag_StringSingleQuote = (1<<10), - NodeFlag_StringDoubleQuote = (1<<11), - NodeFlag_StringTick = (1<<12), - NodeFlag_StringTriplet = (1<<13), - - NodeFlag_MaskLabelKind = (0xF<<14), - NodeFlag_Numeric = (1<<14), - NodeFlag_Identifier = (1<<15), - NodeFlag_StringLiteral = (1<<16), - NodeFlag_Symbol = (1<<17), + NodeFlag_MaskSetDelimiters = (0x3F<<0), + NodeFlag_HasParenLeft = (1<<0), + NodeFlag_HasParenRight = (1<<1), + NodeFlag_HasBracketLeft = (1<<2), + NodeFlag_HasBracketRight = (1<<3), + NodeFlag_HasBraceLeft = (1<<4), + NodeFlag_HasBraceRight = (1<<5), + + NodeFlag_MaskSeparators = (0xF<<6), + NodeFlag_IsBeforeSemicolon = (1<<6), + NodeFlag_IsAfterSemicolon = (1<<7), + NodeFlag_IsBeforeComma = (1<<8), + NodeFlag_IsAfterComma = (1<<9), + + NodeFlag_MaskStringDelimiters = (0xF<<10), + NodeFlag_StringSingleQuote = (1<<10), + NodeFlag_StringDoubleQuote = (1<<11), + NodeFlag_StringTick = (1<<12), + NodeFlag_StringTriplet = (1<<13), + + NodeFlag_MaskLabelKind = (0xF<<14), + NodeFlag_Numeric = (1<<14), + NodeFlag_Identifier = (1<<15), + NodeFlag_StringLiteral = (1<<16), + NodeFlag_Symbol = (1<<17), }; #define NodeFlag_AfterFromBefore(f) ((f) << 1) -typedef struct MD_Node MD_Node; -struct MD_Node +typedef struct Node Node; +struct Node { - // rjf: tree links - MD_Node *next; - MD_Node *prev; - MD_Node *parent; - MD_Node *first; - MD_Node *last; - - // rjf: tag links - MD_Node *first_tag; - MD_Node *last_tag; - - // rjf: node info - MD_NodeKind kind; - MD_NodeFlags flags; - String8 string; - String8 raw_string; - - // rjf: source code info - U64 src_offset; - - // rjf: user-controlled generation number - // - // (unused by mdesk layer, but can be used by usage code to use MD_Node trees - // in a "retained mode" way, where stable generational handles can be formed - // to nodes) - U64 user_gen; - - // rjf: extra padding to 128 bytes - U64 _unused_[2]; + // rjf: tree links + Node* next; + Node* prev; + Node* parent; + Node* first; + Node* last; + + // rjf: tag links + Node* first_tag; + Node* last_tag; + + // rjf: node info + NodeKind kind; + NodeFlags flags; + String8 string; + String8 raw_string; + + // rjf: source code info + U64 src_offset; + + // rjf: user-controlled generation number + // + // (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 + // to nodes) + U64 user_gen; + + // rjf: extra padding to 128 bytes + U64 _unused_[2]; }; -typedef struct MD_NodeRec MD_NodeRec; -struct MD_NodeRec +typedef struct NodeRec NodeRec; +struct NodeRec { - MD_Node *next; - S32 push_count; - S32 pop_count; + Node* next; + S32 push_count; + S32 pop_count; }; //////////////////////////////// //~ rjf: Text -> Tokens Types -typedef struct MD_TokenizeResult MD_TokenizeResult; -struct MD_TokenizeResult +typedef struct TokenizeResult TokenizeResult; +struct TokenizeResult { - MD_TokenArray tokens; - MD_MsgList msgs; + TokenArray tokens; + MsgList msgs; }; //////////////////////////////// //~ rjf: Tokens -> Tree Types -typedef struct MD_ParseResult MD_ParseResult; -struct MD_ParseResult +typedef struct ParseResult ParseResult; +struct ParseResult { - MD_Node *root; - MD_MsgList msgs; + Node* root; + MsgList msgs; }; //////////////////////////////// //~ rjf: Globals -global read_only MD_Node md_nil_node = +inline Node* +nil_node() { - &md_nil_node, - &md_nil_node, - &md_nil_node, - &md_nil_node, - &md_nil_node, - &md_nil_node, - &md_nil_node, -}; + read_only thread_local local_persist + nil = { + &nil, + &nil, + &nil, + &nil, + &nil, + &nil, + &nil, + }; + return &nil; +} //////////////////////////////// //~ 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_pushf(Arena *arena, MD_MsgList *msgs, MD_Node *node, MD_MsgKind kind, char *fmt, ...); -internal void md_msg_list_concat_in_place(MD_MsgList *dst, MD_MsgList *to_push); +internal void md_msg_list_push (Arena* arena, MsgList* msgs, Node* node, MsgKind kind, String8 string); +internal void md_msg_list_pushf(Arena* arena, MsgList* msgs, Node* node, MsgKind kind, char *fmt, ...); + +internal void md_msg_list_concat_in_place(MsgList* dst, MsgList* to_push); //////////////////////////////// //~ rjf: Token Type Functions -internal MD_Token md_token_make(Rng1U64 range, TokenFlags flags); -internal B32 md_token_match(MD_Token a, MD_Token b); -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 MD_TokenArray md_token_array_from_chunk_list(Arena *arena, MD_TokenChunkList *chunks); -internal String8 md_content_string_from_token_flags_str8(TokenFlags flags, String8 string); +internal Token md_token_make (Rng1U64 range, TokenFlags flags); +internal B32 md_token_match (Token a, Token b); +internal String8List md_string_list_from_token_flags (Arena *arena, TokenFlags flags); +internal void md_token_chunk_list_push (Arena *arena, TokenChunkList *list, U64 cap, Token token); +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); //////////////////////////////// //~ rjf: Node Type Functions //- 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 -internal B32 md_node_is_nil(MD_Node *node); +internal B32 md_node_is_nil(Node *node); //- rjf: iteration -#define MD_EachNode(it, first) (MD_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)) -#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 MD_EachNode(it, first) (Node *it = first; !md_node_is_nil(it); it = it->next) + +internal NodeRec node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off); + +#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 -internal MD_Node* md_push_node(Arena *arena, MD_NodeKind kind, MD_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_child(MD_Node *parent, MD_Node *prev_child, MD_Node *node); -internal void md_node_push_child(MD_Node *parent, MD_Node *node); -internal void md_node_push_tag(MD_Node *parent, MD_Node *node); -internal void md_unhook(MD_Node *node); +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 (Node *parent, Node *prev_child, Node *node); +internal void md_node_insert_child(Node *parent, Node *prev_child, Node *node); +internal void md_node_push_child (Node *parent, Node *node); +internal void md_node_push_tag (Node *parent, Node *node); +internal void md_unhook (Node *node); //- rjf: tree introspection -internal MD_Node * md_node_from_chain_string(MD_Node *first, MD_Node *opl, String8 string, StringMatchFlags flags); -internal MD_Node * md_node_from_chain_index(MD_Node *first, MD_Node *opl, U64 index); -internal MD_Node * md_node_from_chain_flags(MD_Node *first, MD_Node *opl, MD_NodeFlags flags); -internal U64 md_index_from_node(MD_Node *node); -internal MD_Node * md_root_from_node(MD_Node *node); -internal MD_Node * md_child_from_string(MD_Node *node, String8 child_string, StringMatchFlags flags); -internal MD_Node * md_tag_from_string(MD_Node *node, String8 tag_string, StringMatchFlags flags); -internal MD_Node * md_child_from_index(MD_Node *node, U64 index); -internal MD_Node * md_tag_from_index(MD_Node *node, U64 index); -internal MD_Node * md_tag_arg_from_index(MD_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 B32 md_node_has_child(MD_Node *node, String8 string, StringMatchFlags flags); -internal B32 md_node_has_tag(MD_Node *node, String8 string, StringMatchFlags flags); -internal U64 md_child_count_from_node(MD_Node *node); -internal U64 md_tag_count_from_node(MD_Node *node); -internal String8 md_string_from_children(Arena *arena, MD_Node *root); +internal Node* md_node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFlags flags); +internal Node* md_node_from_chain_index (Node *first, Node *opl, U64 index); +internal Node* md_node_from_chain_flags (Node *first, Node *opl, NodeFlags flags); +internal U64 md_index_from_node (Node *node); +internal Node* md_root_from_node (Node *node); +internal Node* md_child_from_string (Node *node, String8 child_string, StringMatchFlags flags); +internal Node* md_tag_from_string (Node *node, String8 tag_string, StringMatchFlags flags); +internal Node* md_child_from_index (Node *node, U64 index); +internal Node* md_tag_from_index (Node *node, U64 index); +internal Node* md_tag_arg_from_index (Node *node, String8 tag_string, StringMatchFlags flags, U64 index); +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 (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 (Node *node); +internal U64 md_tag_count_from_node (Node *node); + +internal String8 md_string_from_children (Arena *arena, Node *root); //- rjf: tree comparison -internal B32 md_tree_match(MD_Node *a, MD_Node *b, StringMatchFlags flags); -internal B32 md_node_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(Node *a, Node *b, StringMatchFlags flags); //- rjf: tree duplication -internal MD_Node *md_tree_copy(Arena *arena, MD_Node *src_root); -// MD_Node* tree_copy_arena(MD_Node* src_root, Arena* arena); -// MD_Node* tree_copy_ainfo(MD_Node* src_root, AllocatorInfo info); +internal Node* md_tree_copy(Arena *arena, Node *src_root); +// Node* tree_copy_arena(Node* src_root, Arena* arena); +// Node* tree_copy_ainfo(Node* src_root, AllocatorInfo info); //////////////////////////////// //~ 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 -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 -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) //////////////////////////////// //~ 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); diff --git a/code/metagen/metagen.c b/code/metagen/metagen.c index 8529327..b92c319 100644 --- a/code/metagen/metagen.c +++ b/code/metagen/metagen.c @@ -354,7 +354,7 @@ mg_map_insert_ptr(Arena *arena, MG_Map *map, String8 string, void *val) //~ rjf: String Expression Parsing 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); 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 -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}; { - MD_Node *it = first; + Node *it = first; //- rjf: consume prefix operators 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 { 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)) { 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)) { - 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; md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs); 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); 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; } @@ -483,16 +483,16 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node } 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); return parse; } 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; } @@ -504,16 +504,16 @@ mg_node_array_make(Arena *arena, U64 count) { MG_NodeArray result = {0}; 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) { - result.v[idx] = &md_nil_node; + result.v[idx] = &nil_node(); } return result; } 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)); U64 idx = 0; @@ -526,7 +526,7 @@ mg_child_array_from_node(Arena *arena, MD_Node *node) } 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}; @@ -593,10 +593,10 @@ mg_column_from_index(Arena *arena, MG_NodeGrid grid, U64 index) return result; } -internal MD_Node * +internal Node * 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; 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 -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}; result.count = md_child_count_from_node(tag); @@ -657,7 +657,7 @@ 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) +mg_string_from_row_desc_idx(Node *row_parent, MG_ColumnDescArray descs, U64 idx) { 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; } } - MD_Node *node = md_child_from_index(row_parent, cell_idx); + Node *node = md_child_from_index(row_parent, cell_idx); result = node->string; }break; case MG_ColumnKind_CheckForTag: { 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"); }break; case MG_ColumnKind_TagChild: { 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; }break; } @@ -836,9 +836,9 @@ mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpand { // rjf: grab left/right 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; - 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 .) 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 - MD_Node *row_parent = &md_nil_node; + Node *row_parent = &nil_node(); if(grid && (0 <= row_idx && row_idx < grid->row_parents.count)) { 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 { // 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); } // 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); } @@ -999,8 +999,8 @@ mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo } } String8 expr_string = str8_substr(string, expr_range); - MD_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); + TokenizeResult expr_tokenize = md_tokenize_from_text(scratch.arena, expr_string); + 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_eval_table_expand_expr__string(arena, expr_parse.root, info, &expansion_strs); 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 -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}; 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)) { // rjf: grab args for this expansion - MD_Node *table_name_node = md_child_from_index(tag, 0); - MD_Node *expand_label_node = md_child_from_index(tag, 1); + Node *table_name_node = md_child_from_index(tag, 0); + Node *expand_label_node = md_child_from_index(tag, 1); String8 table_name = table_name_node->string; String8 expand_label = expand_label_node->string; diff --git a/code/metagen/metagen.h b/code/metagen/metagen.h index 339397c..3365cab 100644 --- a/code/metagen/metagen.h +++ b/code/metagen/metagen.h @@ -36,7 +36,7 @@ struct MG_MsgList typedef struct MG_FileParse MG_FileParse; struct MG_FileParse { - MD_Node *root; + Node *root; }; typedef struct MG_FileParseNode MG_FileParseNode; @@ -133,15 +133,15 @@ struct MG_StrExpr MG_StrExpr *left; MG_StrExpr *right; MG_StrExprOp op; - MD_Node *node; + Node *node; }; typedef struct MG_StrExprParseResult MG_StrExprParseResult; struct MG_StrExprParseResult { MG_StrExpr *root; - MD_MsgList msgs; - MD_Node *next_node; + MsgList msgs; + Node *next_node; }; //////////////////////////////// @@ -150,7 +150,7 @@ struct MG_StrExprParseResult typedef struct MG_NodeArray MG_NodeArray; struct MG_NodeArray { - MD_Node **v; + Node **v; U64 count; }; @@ -295,30 +295,30 @@ internal void mg_map_insert_ptr(Arena *arena, MG_Map *map, String8 string, void //////////////////////////////// //~ rjf: String Expression Parsing -internal MG_StrExpr *mg_push_str_expr(Arena *arena, MG_StrExprOp op, MD_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(Arena *arena, MD_Node *first, MD_Node *opl); -internal MG_StrExprParseResult mg_str_expr_parse_from_root(Arena *arena, MD_Node *root); +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, Node *first, Node *opl, S8 min_prec); +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, Node *root); //////////////////////////////// //~ rjf: Table Generation Functions 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_NodeGrid mg_node_grid_make_from_node(Arena *arena, MD_Node *root); +internal MG_NodeArray mg_child_array_from_node(Arena *arena, Node *node); +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_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_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 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 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 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 diff --git a/code/metagen/metagen_main.c b/code/metagen/metagen_main.c index f79c37f..1ec8638 100644 --- a/code/metagen/metagen_main.c +++ b/code/metagen/metagen_main.c @@ -92,9 +92,9 @@ entry_point(CmdLine *cmdline) if(str8_match(file_ext, str8_lit("mdesk"), 0)) { String8 data = os_data_from_file_path(mg_arena, file_path); - MD_TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data); - MD_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) + TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data); + ParseResult parse = md_parse_from_text_tokens(mg_arena, file_path, data, tokenize.tokens); + for(Msg *m = parse.msgs.first; m != 0; m = m->next) { TxtPt pt = mg_txt_pt_from_string_off(data, m->node->src_offset); String8 msg_kind_string = {0}; @@ -102,8 +102,8 @@ entry_point(CmdLine *cmdline) { default:{}break; case MD_MsgKind_Note: {msg_kind_string = str8_lit("note");}break; - case MD_MsgKind_Warning: {msg_kind_string = str8_lit("warning");}break; - case MD_MsgKind_Error: {msg_kind_string = str8_lit("error");}break; + case MsgKind_Warning: {msg_kind_string = str8_lit("warning");}break; + case MsgKind_Error: {msg_kind_string = str8_lit("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); @@ -128,10 +128,10 @@ entry_point(CmdLine *cmdline) { 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) { - 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)) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; String8 layer_key = mg_layer_key_from_path(file->string); MG_Layer *layer = mg_layer_from_key(layer_key); 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; 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)) { String8 enum_name = node->string; @@ -266,10 +266,10 @@ entry_point(CmdLine *cmdline) // 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) { - 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)) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; for MD_EachNode(node, file->first) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; 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)) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; 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)) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; 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)) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; for MD_EachNode(node, file->first) { 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) { - MD_Node *file = n->v.root; + Node *file = n->v.root; for MD_EachNode(node, file->first) { //- rjf: generate markdown page if(md_node_has_tag(node, str8_lit("markdown"), 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)) { diff --git a/examples/expr/expr_c_like.c b/examples/expr/expr_c_like.c index fecacd1..3ca760b 100644 --- a/examples/expr/expr_c_like.c +++ b/examples/expr/expr_c_like.c @@ -83,7 +83,7 @@ print_expression(FILE *out, MD_Expr *expr) MD_ExprOpr *op = expr->op; if (op == 0) { - MD_Node *node = expr->md_node; + Node *node = expr->md_node; if (node->raw_string.size != 0) { fprintf(out, "%.*s", MD_S8VArg(node->raw_string)); @@ -92,27 +92,27 @@ print_expression(FILE *out, MD_Expr *expr) { char c1 = 0; char c2 = 0; - if (node->flags & MD_NodeFlag_HasParenLeft) + if (node->flags & NodeFlag_HasParenLeft) { c1 = '('; } - if (node->flags & MD_NodeFlag_HasBraceLeft) + if (node->flags & NodeFlag_HasBraceLeft) { c1 = '{'; } - if (node->flags & MD_NodeFlag_HasBracketLeft) + if (node->flags & NodeFlag_HasBracketLeft) { c1 = '['; } - if (node->flags & MD_NodeFlag_HasParenRight) + if (node->flags & NodeFlag_HasParenRight) { c2 = ')'; } - if (node->flags & MD_NodeFlag_HasBraceRight) + if (node->flags & NodeFlag_HasBraceRight) { c2 = '}'; } - if (node->flags & MD_NodeFlag_HasBracketRight) + if (node->flags & NodeFlag_HasBracketRight) { c2 = ']'; } @@ -131,7 +131,7 @@ print_expression(FILE *out, MD_Expr *expr) { default: { - MD_Node *node = expr->md_node; + Node *node = expr->md_node; MD_CodeLoc loc = MD_CodeLocFromNode(node); MD_PrintMessage(stderr, loc, MD_MessageKind_FatalError, MD_S8Lit("this is an unknown kind of operator")); @@ -139,7 +139,7 @@ print_expression(FILE *out, MD_Expr *expr) case MD_ExprOprKind_Prefix: { - MD_Node *node = expr->md_node; + Node *node = expr->md_node; fprintf(out, "%.*s(", MD_S8VArg(op->string)); print_expression(out, expr->unary_operand); fprintf(out, ")"); @@ -150,7 +150,7 @@ print_expression(FILE *out, MD_Expr *expr) fprintf(out, "("); print_expression(out, expr->unary_operand); 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]); } @@ -191,13 +191,13 @@ int main(int argc, char **argv) arena = MD_ArenaAlloc(); // 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) { // parse the file 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 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 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)) { MD_ExprParseResult parse = MD_ExprParse(arena, &table, node->first_child, MD_NilNode()); diff --git a/examples/expr/expr_intro.c b/examples/expr/expr_intro.c index 7a93860..fc41c61 100644 --- a/examples/expr/expr_intro.c +++ b/examples/expr/expr_intro.c @@ -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 // 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_Node *node = expr->md_node; - if ((node->flags & MD_NodeFlag_MaskSetDelimiters) == 0) + Node *node = expr->md_node; + if ((node->flags & NodeFlag_MaskSetDelimiters) == 0) { fprintf(out, "%.*s", MD_S8VArg(node->raw_string)); } @@ -86,12 +86,12 @@ eval_expression(MD_Expr *expr) MD_ExprOpr *op = expr->op; if (op == 0) { - MD_Node *node = expr->md_node; - if (node->flags & MD_NodeFlag_Numeric) + Node *node = expr->md_node; + if (node->flags & NodeFlag_Numeric) { 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)); if (slot != 0) @@ -140,13 +140,13 @@ int main(int argc, char **argv) arena = MD_ArenaAlloc(); // 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) { // parse the file 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 for (MD_Message *message = parse_result.errors.first; @@ -215,7 +215,7 @@ int main(int argc, char **argv) // init eval map 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)) { // @notes An expression parse is an extra stage of analysis on top diff --git a/examples/integration/memory_management.c b/examples/integration/memory_management.c index aa15390..bf3369e 100644 --- a/examples/integration/memory_management.c +++ b/examples/integration/memory_management.c @@ -61,7 +61,7 @@ typedef struct ConfigFile{ MD_Arena *arena; MD_String8 file_name; MD_String8 contents; - MD_Node *root; + Node *root; MD_MessageList errors; } 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 // ConfigFile. 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 // arena with MD_ArenaAlloc. Then we used the arena to allocate a diff --git a/examples/integration/multi_threaded.c b/examples/integration/multi_threaded.c index 3ec50b7..792e33c 100644 --- a/examples/integration/multi_threaded.c +++ b/examples/integration/multi_threaded.c @@ -67,7 +67,7 @@ typedef struct ThreadData // unique-to-thread MD_Arena *arena; - MD_Node *list; + Node *list; MD_MessageList errors; } ThreadData; @@ -86,7 +86,7 @@ parse_worker_loop(ThreadData *thread_data) // load and parse the file specified by this task. 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_PushNewReference(thread_data->arena, thread_data->list, parse.node); } @@ -186,7 +186,7 @@ main(int argc, char **argv) // print the name of each root 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)); } @@ -221,7 +221,7 @@ main(int argc, char **argv) // combine results MD_Arena *arena = threads[0].arena; - MD_Node *list = threads[0].list; + Node *list = threads[0].list; MD_MessageList errors = threads[0].errors; for (int i = 1; i < THREAD_COUNT; i += 1) { diff --git a/examples/intro/data_desk_like_template.c b/examples/intro/data_desk_like_template.c index 3f32309..ea6643e 100644 --- a/examples/intro/data_desk_like_template.c +++ b/examples/intro/data_desk_like_template.c @@ -27,7 +27,7 @@ static MD_Arena *arena = 0; //~ Declare user defined functions (the data desk "custom layer") ////////////// 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. @@ -40,13 +40,13 @@ int main(int argument_count, char **arguments) // parse all files passed to the command line 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) { // parse the file 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 for (MD_Message *message = parse_result.errors.first; @@ -73,7 +73,7 @@ int main(int argument_count, char **arguments) Initialize(); 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)) { TopLevel(node); @@ -95,7 +95,7 @@ Initialize(void) } static void -TopLevel(MD_Node *node) +TopLevel(Node *node) { /*TODO*/ } diff --git a/examples/intro/hello_world.c b/examples/intro/hello_world.c index 31b9751..f531ad6 100644 --- a/examples/intro/hello_world.c +++ b/examples/intro/hello_world.c @@ -20,7 +20,7 @@ main(int argc, char **argv) // parse a string MD_String8 name = MD_S8Lit(""); 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 MD_PrintDebugDumpFromNode(stdout, parse.node, MD_GenerateFlags_All); diff --git a/examples/intro/parse_check.c b/examples/intro/parse_check.c index e458f19..765ebbc 100644 --- a/examples/intro/parse_check.c +++ b/examples/intro/parse_check.c @@ -25,7 +25,7 @@ int main(int argc, char **argv) arena = MD_ArenaAlloc(); // 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) { @@ -35,7 +35,7 @@ int main(int argc, char **argv) // this metadesk's default implementations for the overrides make // this work. 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 for (MD_Message *message = parse_result.errors.first; @@ -65,21 +65,21 @@ int main(int argc, char **argv) // print the verbose parse results // @notes The Metadesk library provides a macros for iterating chains of - // MD_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 as shown here. The first parameter to the macro names an + // 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. - // 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. for (MD_EachNode(root_it, list->first_child)) { // @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 // metadesk node from a previous parse. So our `root_it` is iterating // a list of reference nodes. Here we resolve the reference node to // 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)) { diff --git a/examples/type_metadata/type_metadata.c b/examples/type_metadata/type_metadata.c index 56c34f6..a5ab84d 100644 --- a/examples/type_metadata/type_metadata.c +++ b/examples/type_metadata/type_metadata.c @@ -59,7 +59,7 @@ FILE *error_file = 0; // @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. // 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. // 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 @@ -76,11 +76,11 @@ MD_Map map_map = {0}; //~ 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) { - MD_Node *child = MD_ChildFromString(parent, child_name, 0); - MD_Node *result = child->first_child; + Node *child = MD_ChildFromString(parent, child_name, 0); + Node *result = child->first_child; return(result); } @@ -103,7 +103,7 @@ gen_resolve_type_info_from_string(MD_String8 name) } 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); return(result); @@ -143,10 +143,10 @@ gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant) return(result); } -MD_Node* +Node* 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)); if (type_slot != 0) { @@ -163,7 +163,7 @@ gen_get_symbol_md_node_by_name(MD_String8 name) } void -gen_type_resolve_error(MD_Node *reference) +gen_type_resolve_error(Node *reference) { MD_CodeLoc loc = MD_CodeLocFromNode(reference); MD_PrintMessageFmt(error_file, loc, MD_MessageKind_Error, @@ -171,7 +171,7 @@ gen_type_resolve_error(MD_Node *reference) } 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_PrintMessageFmt(error_file, loc, MD_MessageKind_Error, @@ -184,9 +184,9 @@ gen_duplicate_symbol_error(MD_Node *new_node, MD_Node *existing_node) } 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)) { 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. void -gen_gather_types_and_maps(MD_Node *list) +gen_gather_types_and_maps(Node *list) { 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)) { // 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)) { gen_check_and_do_duplicate_symbol_error(node); 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; if (MD_S8Match(tag_arg_str, MD_S8Lit("basic"), 0)) { @@ -274,7 +274,7 @@ gen_check_duplicate_member_names(void) type != 0; 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)) { MD_String8 name = member_node->string; @@ -315,8 +315,8 @@ gen_equip_basic_type_size(void) // extract the size int size = 0; - MD_Node *size_node = type->node->first_child; - MD_Node *error_at = 0; + Node *size_node = type->node->first_child; + Node *error_at = 0; if (MD_NodeIsNil(size_node)) { error_at = type->node; @@ -361,10 +361,10 @@ gen_equip_struct_members(void) GEN_TypeMember *last_member = 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)) { - MD_Node *type_name_node = member_node->first_child; + Node *type_name_node = member_node->first_child; // missing type node? if (MD_NodeIsNil(type_name_node)) @@ -392,10 +392,10 @@ gen_equip_struct_members(void) if (got_list) { 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)) { - MD_Node *array_count_referencer = array_tag->first_child; + Node *array_count_referencer = array_tag->first_child; if (array_count_referencer->string.size == 0) { MD_CodeLoc loc = MD_CodeLocFromNode(array_tag); @@ -404,7 +404,7 @@ gen_equip_struct_members(void) } else { - MD_Node *array_count_member_node = + Node *array_count_member_node = MD_ChildFromString(type_root_node, array_count_referencer->string, 0); if (MD_NodeIsNil(array_count_member_node)) { @@ -471,10 +471,10 @@ gen_equip_enum_underlying_type(void) // extract underlying type GEN_TypeInfo *underlying_type = 0; - MD_Node *type_node = type->node; - MD_Node *type_tag = MD_TagFromString(type_node, MD_S8Lit("type"), 0); - MD_Node *type_tag_param = type_tag->first_child; - MD_Node *underlying_type_ref = type_tag_param->first_child; + Node *type_node = type->node; + Node *type_tag = MD_TagFromString(type_node, MD_S8Lit("type"), 0); + Node *type_tag_param = type_tag->first_child; + Node *underlying_type_ref = type_tag_param->first_child; if (!MD_NodeIsNil(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; - MD_Node *type_root_node = type->node; + Node *type_root_node = type->node; 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; // missing value node? @@ -581,19 +581,19 @@ gen_equip_map_in_out_types(void) map != 0; map = map->next) { - MD_Node *map_root_node = map->node; - MD_Node *map_tag = MD_TagFromString(map_root_node, MD_S8Lit("map"), 0); + Node *map_root_node = map->node; + Node *map_tag = MD_TagFromString(map_root_node, MD_S8Lit("map"), 0); // NOTE we could use an expression parser here to make this fancier // and check for the 'In -> Out' semicolon delimited syntax more // 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 // buys us a lot of simplicity. - MD_Node *in_node = map_tag->first_child; - MD_Node *arrow = in_node->next; - MD_Node *out_node = arrow->next; + Node *in_node = map_tag->first_child; + Node *arrow = in_node->next; + Node *out_node = arrow->next; { - MD_Node *error_at = 0; + Node *error_at = 0; if (MD_NodeIsNil(in_node)) { error_at = map_tag; @@ -666,8 +666,8 @@ gen_equip_map_in_out_types(void) // check for named children in the map tag int is_complete = MD_NodeHasChild(map_tag, MD_S8Lit("complete"), 0); - MD_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 *default_val = gen_get_child_value(map_tag, MD_S8Lit("default")); + Node *auto_val = gen_get_child_value(map_tag, MD_S8Lit("auto")); // save to map map->typed_map = typed_map; @@ -697,16 +697,16 @@ gen_equip_map_cases(void) GEN_MapCase *last_case = 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); - case_node = MD_FirstNodeWithFlags(case_node->next, MD_NodeFlag_IsAfterComma)) + case_node = MD_FirstNodeWithFlags(case_node->next, NodeFlag_IsAfterComma)) { // extract in & out - MD_Node *in = case_node; - MD_Node *arrow = in->next; - MD_Node *out = arrow->next; + Node *in = case_node; + Node *arrow = in->next; + Node *out = arrow->next; if (!MD_S8Match(arrow->string, MD_S8Lit("->"), 0) || MD_NodeIsNil(out)) { @@ -1237,12 +1237,12 @@ main(int argc, char **argv) error_file = stderr; // 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) { // parse the file 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 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; } - MD_Node *node = type->node; + Node *node = type->node; printf("%.*s: %s\n", MD_S8VArg(node->string), kind_string); // print member lists @@ -1351,7 +1351,7 @@ main(int argc, char **argv) map != 0; map = map->next) { - MD_Node *node = map->node; + Node *node = map->node; printf("%.*s: map\n", MD_S8VArg(node->string)); // print case list diff --git a/examples/type_metadata/type_metadata.h b/examples/type_metadata/type_metadata.h index 90f1bf3..74cbee8 100644 --- a/examples/type_metadata/type_metadata.h +++ b/examples/type_metadata/type_metadata.h @@ -24,7 +24,7 @@ struct GEN_TypeInfo { GEN_TypeInfo *next; GEN_TypeKind kind; - MD_Node *node; + Node *node; // basic int size; @@ -45,10 +45,10 @@ typedef struct GEN_TypeMember GEN_TypeMember; struct GEN_TypeMember { GEN_TypeMember *next; - MD_Node *node; + Node *node; GEN_TypeInfo *type; struct GEN_TypeMember *array_count; - //MD_Node *array_count; + //Node *array_count; int member_index; }; @@ -56,7 +56,7 @@ typedef struct GEN_TypeEnumerant GEN_TypeEnumerant; struct GEN_TypeEnumerant { GEN_TypeEnumerant *next; - MD_Node *node; + Node *node; int value; }; @@ -64,13 +64,13 @@ typedef struct GEN_MapInfo GEN_MapInfo; struct GEN_MapInfo { GEN_MapInfo *next; - MD_Node *node; + Node *node; struct GEN_TypedMapInfo *typed_map; int is_complete; - MD_Node *default_val; - MD_Node *auto_val; + Node *default_val; + Node *auto_val; struct GEN_MapCase *first_case; struct GEN_MapCase *last_case; @@ -95,29 +95,29 @@ struct GEN_MapCase { GEN_MapCase *next; GEN_TypeEnumerant *in_enumerant; - MD_Node *out; + Node *out; }; //~ 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_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_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_duplicate_symbol_error(MD_Node *new_node, MD_Node *existing_node); +void gen_type_resolve_error(Node *reference); +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 ///////////////////////////////////////////////////////////////// -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_equip_basic_type_size(void); void gen_equip_struct_members(void); diff --git a/examples/user_errors/user_errors.c b/examples/user_errors/user_errors.c index b1ec510..9011c3a 100644 --- a/examples/user_errors/user_errors.c +++ b/examples/user_errors/user_errors.c @@ -28,12 +28,12 @@ int main(int argc, char **argv) arena = MD_ArenaAlloc(); // 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) { // parse the file 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 // 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 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 // 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 // then we know there are at least two tags, which is against // the first custom rule. - MD_Node *tag_2 = MD_TagFromIndex(node, 1); + Node *tag_2 = MD_TagFromIndex(node, 1); if (!MD_NodeIsNil(tag_2)) { // @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 "[]" // delimiters. We can easily detect nodes for those sets by // checking the node flags: - if ((node->flags & MD_NodeFlag_HasBracketLeft) || - (node->flags & MD_NodeFlag_HasBracketRight)) + if ((node->flags & NodeFlag_HasBracketLeft) || + (node->flags & NodeFlag_HasBracketRight)) { if (node->string.size > 0) { diff --git a/source/md.c b/source/md.c index 7bb4bdb..1d5f98f 100644 --- a/source/md.c +++ b/source/md.c @@ -715,7 +715,7 @@ MD_GetScratchDefault(MD_Arena **conflicts, MD_u64 count) //~ Nil Node Definition -static MD_Node _md_nil_node = +static Node _md_nil_node = { &_md_nil_node, // next &_md_nil_node, // prev @@ -724,7 +724,7 @@ static MD_Node _md_nil_node = &_md_nil_node, // last_child &_md_nil_node, // first_tag &_md_nil_node, // last_tag - MD_NodeKind_Nil, // kind + NodeKind_Nil, // kind 0, // flags MD_ZERO_STRUCT, // string MD_ZERO_STRUCT, // raw_string @@ -1320,7 +1320,7 @@ MD_S8Stylize(MD_Arena *arena, MD_String8 string, MD_IdentifierStyle word_style, //~ Unicode Conversions -MD_GLOBAL MD_u8 md_utf8_class[32] = { +MD_GLOBAL MD_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, }; @@ -1340,7 +1340,7 @@ MD_DecodeCodepointFromUtf8(MD_u8 *str, MD_u64 max) MD_DecodedCodepoint result = {~((MD_u32)0), 1}; MD_u8 byte = str[0]; - MD_u8 byte_class = md_utf8_class[byte >> 3]; + MD_u8 byte_class = utf8_class[byte >> 3]; switch (byte_class) { case 1: @@ -1353,7 +1353,7 @@ MD_DecodeCodepointFromUtf8(MD_u8 *str, MD_u64 max) if (2 <= max) { MD_u8 cont_byte = str[1]; - if (md_utf8_class[cont_byte >> 3] == 0) + if (utf8_class[cont_byte >> 3] == 0) { result.codepoint = (byte & MD_bitmask5) << 6; result.codepoint |= (cont_byte & MD_bitmask6); @@ -1369,8 +1369,8 @@ MD_DecodeCodepointFromUtf8(MD_u8 *str, MD_u64 max) MD_u8 cont_byte[2] = {0}; cont_byte[0] = str[1]; cont_byte[1] = str[2]; - if (md_utf8_class[cont_byte[0] >> 3] == 0 && - md_utf8_class[cont_byte[1] >> 3] == 0) + if (utf8_class[cont_byte[0] >> 3] == 0 && + utf8_class[cont_byte[1] >> 3] == 0) { result.codepoint = (byte & MD_bitmask4) << 12; result.codepoint |= ((cont_byte[0] & MD_bitmask6) << 6); @@ -1388,9 +1388,9 @@ MD_DecodeCodepointFromUtf8(MD_u8 *str, MD_u64 max) cont_byte[0] = str[1]; cont_byte[1] = str[2]; cont_byte[2] = str[3]; - if (md_utf8_class[cont_byte[0] >> 3] == 0 && - md_utf8_class[cont_byte[1] >> 3] == 0 && - md_utf8_class[cont_byte[2] >> 3] == 0) + if (utf8_class[cont_byte[0] >> 3] == 0 && + utf8_class[cont_byte[1] >> 3] == 0 && + utf8_class[cont_byte[2] >> 3] == 0) { result.codepoint = (byte & MD_bitmask3) << 18; result.codepoint |= ((cont_byte[0] & MD_bitmask6) << 12); @@ -1861,10 +1861,10 @@ MD_CStyleHexStringFromU64(MD_Arena *arena, MD_u64 x, MD_b32 caps) //~ Enum/Flag Strings MD_FUNCTION MD_String8 -MD_StringFromNodeKind(MD_NodeKind kind) +MD_StringFromNodeKind(NodeKind kind) { - // NOTE(rjf): @maintenance Must be kept in sync with MD_NodeKind enum. - static char *cstrs[MD_NodeKind_COUNT] = + // NOTE(rjf): @maintenance Must be kept in sync with NodeKind enum. + static char *cstrs[NodeKind_COUNT] = { "Nil", @@ -1881,9 +1881,9 @@ MD_StringFromNodeKind(MD_NodeKind kind) } MD_FUNCTION MD_String8List -MD_StringListFromNodeFlags(MD_Arena *arena, MD_NodeFlags flags) +MD_StringListFromNodeFlags(MD_Arena *arena, NodeFlags flags) { - // NOTE(rjf): @maintenance Must be kept in sync with MD_NodeFlags enum. + // NOTE(rjf): @maintenance Must be kept in sync with NodeFlags enum. static char *flag_cstrs[] = { "HasParenLeft", @@ -2075,10 +2075,10 @@ MD_MapOverwrite(MD_Arena *arena, MD_Map *map, MD_MapKey key, void *val) //~ Parsing -MD_FUNCTION MD_Token +MD_FUNCTION Token MD_TokenFromString(MD_String8 string) { - MD_Token token = MD_ZERO_STRUCT; + Token token = MD_ZERO_STRUCT; MD_u8 *one_past_last = string.str + string.size; MD_u8 *first = string.str; @@ -2249,17 +2249,17 @@ MD_TokenFromString(MD_String8 string) } //- rjf: set relevant node flags on token - token.node_flags |= MD_NodeFlag_StringLiteral; + token.node_flags |= NodeFlag_StringLiteral; switch(d) { - case '\'': token.node_flags |= MD_NodeFlag_StringSingleQuote; break; - case '"': token.node_flags |= MD_NodeFlag_StringDoubleQuote; break; - case '`': token.node_flags |= MD_NodeFlag_StringTick; break; + case '\'': token.node_flags |= NodeFlag_StringSingleQuote; break; + case '"': token.node_flags |= NodeFlag_StringDoubleQuote; break; + case '`': token.node_flags |= NodeFlag_StringTick; break; default: break; } if(is_triplet) { - token.node_flags |= MD_NodeFlag_StringTriplet; + token.node_flags |= NodeFlag_StringTriplet; } }break; @@ -2269,7 +2269,7 @@ MD_TokenFromString(MD_String8 string) { if (MD_CharIsAlpha(*at) || *at == '_') { - token.node_flags |= MD_NodeFlag_Identifier; + token.node_flags |= NodeFlag_Identifier; token.kind = MD_TokenKind_Identifier; at += 1; MD_TokenizerScan(MD_CharIsAlpha(*at) || MD_CharIsDigit(*at) || *at == '_'); @@ -2277,7 +2277,7 @@ MD_TokenFromString(MD_String8 string) else if (MD_CharIsDigit(*at)) { - token.node_flags |= MD_NodeFlag_Numeric; + token.node_flags |= NodeFlag_Numeric; token.kind = MD_TokenKind_Numeric; at += 1; @@ -2309,7 +2309,7 @@ MD_TokenFromString(MD_String8 string) { symbol_lex: - token.node_flags |= MD_NodeFlag_Symbol; + token.node_flags |= NodeFlag_Symbol; token.kind = MD_TokenKind_Symbol; at += 1; MD_TokenizerScan(MD_CharIsUnreservedSymbol(*at)); @@ -2346,7 +2346,7 @@ MD_LexAdvanceFromSkips(MD_String8 string, MD_TokenKind skip_kinds) MD_u64 p = 0; for (;;) { - MD_Token token = MD_TokenFromString(MD_S8Skip(string, p)); + Token token = MD_TokenFromString(MD_S8Skip(string, p)); if ((skip_kinds & token.kind) == 0) { result = p; @@ -2357,25 +2357,25 @@ MD_LexAdvanceFromSkips(MD_String8 string, MD_TokenKind skip_kinds) return(result); } -MD_FUNCTION MD_ParseResult +MD_FUNCTION ParseResult MD_ParseResultZero(void) { - MD_ParseResult result = MD_ZERO_STRUCT; + ParseResult result = MD_ZERO_STRUCT; result.node = MD_NilNode(); return result; } -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_ParseResult result = MD_ParseResultZero(); + ParseResult result = MD_ParseResultZero(); MD_u64 off = offset; //- rjf: fill data from set opener - MD_Token initial_token = MD_TokenFromString(MD_S8Skip(string, offset)); + Token initial_token = MD_TokenFromString(MD_S8Skip(string, offset)); MD_u8 set_opener = 0; - MD_NodeFlags set_opener_flags = 0; + NodeFlags set_opener_flags = 0; MD_b32 close_with_brace = 0; MD_b32 close_with_paren = 0; MD_b32 close_with_separator = 0; @@ -2387,7 +2387,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare case MD_ParseSetRule_EndOnDelimiter: { MD_u64 opener_check_off = off; - opener_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, opener_check_off), MD_TokenGroup_Irregular); + opener_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, opener_check_off), TokenGroup_Irregular); initial_token = MD_TokenFromString(MD_S8Skip(string, opener_check_off)); if(initial_token.kind == MD_TokenKind_Reserved) { @@ -2395,7 +2395,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare if(c == '{') { set_opener = '{'; - set_opener_flags |= MD_NodeFlag_HasBraceLeft; + set_opener_flags |= NodeFlag_HasBraceLeft; opener_check_off += initial_token.raw_string.size; off = opener_check_off; close_with_brace = 1; @@ -2403,7 +2403,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare else if(c == '(') { set_opener = '('; - set_opener_flags |= MD_NodeFlag_HasParenLeft; + set_opener_flags |= NodeFlag_HasParenLeft; opener_check_off += initial_token.raw_string.size; off = opener_check_off; close_with_paren = 1; @@ -2411,7 +2411,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare else if(c == '[') { set_opener = '['; - set_opener_flags |= MD_NodeFlag_HasBracketLeft; + set_opener_flags |= NodeFlag_HasBracketLeft; opener_check_off += initial_token.raw_string.size; off = opener_check_off; close_with_paren = 1; @@ -2441,7 +2441,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare MD_u64 parsed_child_count = 0; if(set_opener != 0 || close_with_separator || parse_all) { - MD_NodeFlags next_child_flags = 0; + NodeFlags next_child_flags = 0; for(;off < string.size;) { @@ -2452,7 +2452,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare //- rjf: check newlines { - MD_Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); + Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); if(potential_closer.kind == MD_TokenKind_Newline) { closer_check_off += potential_closer.raw_string.size; @@ -2473,7 +2473,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare } // NOTE(rjf): terminate after double newline if we have 0 children - MD_Token next_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); + Token next_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); if(next_closer.kind == MD_TokenKind_Newline) { closer_check_off += next_closer.raw_string.size; @@ -2486,8 +2486,8 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare //- rjf: check separators and possible braces from higher parents { - closer_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); + closer_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); if(potential_closer.kind == MD_TokenKind_Reserved) { MD_u8 c = potential_closer.raw_string.str[0]; @@ -2510,8 +2510,8 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare if(!close_with_separator && !parse_all) { MD_u64 closer_check_off = off; - closer_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); + closer_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token potential_closer = MD_TokenFromString(MD_S8Skip(string, closer_check_off)); if(potential_closer.kind == MD_TokenKind_Reserved) { MD_u8 c = potential_closer.raw_string.str[0]; @@ -2519,7 +2519,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare { closer_check_off += potential_closer.raw_string.size; off = closer_check_off; - parent->flags |= MD_NodeFlag_HasBraceRight; + parent->flags |= NodeFlag_HasBraceRight; got_closer = 1; break; } @@ -2527,7 +2527,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare { closer_check_off += potential_closer.raw_string.size; off = closer_check_off; - parent->flags |= MD_NodeFlag_HasBracketRight; + parent->flags |= NodeFlag_HasBracketRight; got_closer = 1; break; } @@ -2535,7 +2535,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare { closer_check_off += potential_closer.raw_string.size; off = closer_check_off; - parent->flags |= MD_NodeFlag_HasParenRight; + parent->flags |= NodeFlag_HasParenRight; got_closer = 1; break; } @@ -2543,7 +2543,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare } //- rjf: parse next child - MD_ParseResult child_parse = MD_ParseOneNode(arena, string, off); + ParseResult child_parse = MD_ParseOneNode(arena, string, off); MD_MessageListConcat(&result.errors, &child_parse.errors); off += child_parse.string_advance; @@ -2553,12 +2553,12 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare // NOTE(rjf): @error No unnamed set children of implicitly-delimited sets if(close_with_separator && child_parse.node->string.size == 0 && - child_parse.node->flags & (MD_NodeFlag_HasParenLeft | - MD_NodeFlag_HasParenRight | - MD_NodeFlag_HasBracketLeft | - MD_NodeFlag_HasBracketRight | - MD_NodeFlag_HasBraceLeft | - MD_NodeFlag_HasBraceRight )) + child_parse.node->flags & (NodeFlag_HasParenLeft | + NodeFlag_HasParenRight | + NodeFlag_HasBracketLeft | + NodeFlag_HasBracketRight | + NodeFlag_HasBraceLeft | + NodeFlag_HasBraceRight )) { MD_String8 error_str = MD_S8Lit("Unnamed set children of implicitly-delimited sets are not legal."); MD_Message *error = MD_MakeNodeError(arena, child_parse.node, MD_MessageKind_Warning, @@ -2571,22 +2571,22 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare } //- rjf: check trailing separator - MD_NodeFlags trailing_separator_flags = 0; + NodeFlags trailing_separator_flags = 0; if(!close_with_separator) { - off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token trailing_separator = MD_TokenFromString(MD_S8Skip(string, off)); + off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token trailing_separator = MD_TokenFromString(MD_S8Skip(string, off)); if (trailing_separator.kind == MD_TokenKind_Reserved) { MD_u8 c = trailing_separator.string.str[0]; if(c == ',') { - trailing_separator_flags |= MD_NodeFlag_IsBeforeComma; + trailing_separator_flags |= NodeFlag_IsBeforeComma; off += trailing_separator.raw_string.size; } else if(c == ';') { - trailing_separator_flags |= MD_NodeFlag_IsBeforeSemicolon; + trailing_separator_flags |= NodeFlag_IsBeforeSemicolon; off += trailing_separator.raw_string.size; } } @@ -2596,7 +2596,7 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare child_parse.node->flags |= next_child_flags | trailing_separator_flags; //- rjf: setup next_child_flags - next_child_flags = MD_NodeFlag_AfterFromBefore(trailing_separator_flags); + next_child_flags = NodeFlag_AfterFromBefore(trailing_separator_flags); } } end_parse:; @@ -2627,19 +2627,19 @@ MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, MD_Node *pare return result; } -MD_FUNCTION MD_ParseResult +MD_FUNCTION ParseResult MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) { - MD_ParseResult result = MD_ParseResultZero(); + ParseResult result = MD_ParseResultZero(); MD_u64 off = offset; //- rjf: parse pre-comment MD_String8 prev_comment = MD_ZERO_STRUCT; { - MD_Token comment_token = MD_ZERO_STRUCT; + Token comment_token = MD_ZERO_STRUCT; for(;off < string.size;) { - MD_Token token = MD_TokenFromString(MD_S8Skip(string, off)); + Token token = MD_TokenFromString(MD_S8Skip(string, off)); if(token.kind == MD_TokenKind_Comment) { off += token.raw_string.size; @@ -2648,7 +2648,7 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) else if(token.kind == MD_TokenKind_Newline) { off += token.raw_string.size; - MD_Token next_token = MD_TokenFromString(MD_S8Skip(string, off)); + Token next_token = MD_TokenFromString(MD_S8Skip(string, off)); if(next_token.kind == MD_TokenKind_Comment) { // NOTE(mal): If more than one comment, use the last comment @@ -2659,7 +2659,7 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) MD_MemoryZeroStruct(&comment_token); } } - else if((token.kind & MD_TokenGroup_Whitespace) != 0) + else if((token.kind & TokenGroup_Whitespace) != 0) { off += token.raw_string.size; } @@ -2672,14 +2672,14 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) } //- rjf: parse tag list - MD_Node *first_tag = MD_NilNode(); - MD_Node *last_tag = MD_NilNode(); + Node *first_tag = MD_NilNode(); + Node *last_tag = MD_NilNode(); { for(;off < string.size;) { //- rjf: parse @ symbol, signifying start of tag - off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token next_token = MD_TokenFromString(MD_S8Skip(string, off)); + off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token next_token = MD_TokenFromString(MD_S8Skip(string, off)); if(next_token.kind != MD_TokenKind_Reserved || next_token.string.str[0] != '@') { @@ -2688,9 +2688,9 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) off += next_token.raw_string.size; //- rjf: parse string of tag node - MD_Token name = MD_TokenFromString(MD_S8Skip(string, off)); + Token name = MD_TokenFromString(MD_S8Skip(string, off)); MD_u64 name_off = off; - if((name.kind & MD_TokenGroup_Label) == 0) + if((name.kind & TokenGroup_Label) == 0) { // NOTE(rjf): @error Improper token for tag string MD_String8 error_str = MD_S8Fmt(arena, "\"%.*s\" is not a proper tag label", @@ -2702,11 +2702,11 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) off += name.raw_string.size; //- rjf: build tag - MD_Node *tag = MD_MakeNode(arena, MD_NodeKind_Tag, name.string, name.raw_string, name_off); + Node *tag = MD_MakeNode(arena, NodeKind_Tag, name.string, name.raw_string, name_off); //- rjf: parse tag arguments - MD_Token open_paren = MD_TokenFromString(MD_S8Skip(string, off)); - MD_ParseResult args_parse = MD_ParseResultZero(); + Token open_paren = MD_TokenFromString(MD_S8Skip(string, off)); + ParseResult args_parse = MD_ParseResultZero(); if(open_paren.kind == MD_TokenKind_Reserved && open_paren.string.str[0] == '(') { @@ -2721,19 +2721,19 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) } //- rjf: parse node - MD_Node *parsed_node = MD_NilNode(); - MD_ParseResult children_parse = MD_ParseResultZero(); + Node *parsed_node = MD_NilNode(); + ParseResult children_parse = MD_ParseResultZero(); retry:; { //- rjf: try to parse an unnamed set - off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token unnamed_set_opener = MD_TokenFromString(MD_S8Skip(string, off)); + off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token unnamed_set_opener = MD_TokenFromString(MD_S8Skip(string, off)); if(unnamed_set_opener.kind == MD_TokenKind_Reserved) { MD_u8 c = unnamed_set_opener.string.str[0]; if (c == '(' || c == '{' || c == '[') { - parsed_node = MD_MakeNode(arena, MD_NodeKind_Main, MD_S8Lit(""), MD_S8Lit(""), + parsed_node = MD_MakeNode(arena, NodeKind_Main, MD_S8Lit(""), MD_S8Lit(""), unnamed_set_opener.raw_string.str - string.str); children_parse = MD_ParseNodeSet(arena, string, off, parsed_node, MD_ParseSetRule_EndOnDelimiter); @@ -2763,19 +2763,19 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) } //- rjf: try to parse regular node, with/without children - off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), MD_TokenGroup_Irregular); - MD_Token label_name = MD_TokenFromString(MD_S8Skip(string, off)); - if((label_name.kind & MD_TokenGroup_Label) != 0) + off += MD_LexAdvanceFromSkips(MD_S8Skip(string, off), TokenGroup_Irregular); + Token label_name = MD_TokenFromString(MD_S8Skip(string, off)); + if((label_name.kind & TokenGroup_Label) != 0) { off += label_name.raw_string.size; - parsed_node = MD_MakeNode(arena, MD_NodeKind_Main, label_name.string, label_name.raw_string, + parsed_node = MD_MakeNode(arena, NodeKind_Main, label_name.string, label_name.raw_string, label_name.raw_string.str - string.str); parsed_node->flags |= label_name.node_flags; //- rjf: try to parse children for this node MD_u64 colon_check_off = off; - colon_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, colon_check_off), MD_TokenGroup_Irregular); - MD_Token colon = MD_TokenFromString(MD_S8Skip(string, colon_check_off)); + colon_check_off += MD_LexAdvanceFromSkips(MD_S8Skip(string, colon_check_off), TokenGroup_Irregular); + Token colon = MD_TokenFromString(MD_S8Skip(string, colon_check_off)); if(colon.kind == MD_TokenKind_Reserved && colon.string.str[0] == ':') { @@ -2791,8 +2791,8 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) } //- rjf: collect bad token - MD_Token bad_token = MD_TokenFromString(MD_S8Skip(string, off)); - if(bad_token.kind & MD_TokenGroup_Error) + Token bad_token = MD_TokenFromString(MD_S8Skip(string, off)); + if(bad_token.kind & TokenGroup_Error) { off += bad_token.raw_string.size; @@ -2844,10 +2844,10 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) //- rjf: parse comments after nodes. MD_String8 next_comment = MD_ZERO_STRUCT; { - MD_Token comment_token = MD_ZERO_STRUCT; + Token comment_token = MD_ZERO_STRUCT; for(;;) { - MD_Token token = MD_TokenFromString(MD_S8Skip(string, off)); + Token token = MD_TokenFromString(MD_S8Skip(string, off)); if(token.kind == MD_TokenKind_Comment) { comment_token = token; @@ -2859,7 +2859,7 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) { break; } - else if((token.kind & MD_TokenGroup_Whitespace) != 0) + else if((token.kind & TokenGroup_Whitespace) != 0) { off += token.raw_string.size; } @@ -2879,7 +2879,7 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) { result.node->first_tag = first_tag; result.node->last_tag = last_tag; - for(MD_Node *tag = first_tag; !MD_NodeIsNil(tag); tag = tag->next) + for(Node *tag = first_tag; !MD_NodeIsNil(tag); tag = tag->next) { tag->parent = result.node; } @@ -2889,11 +2889,11 @@ MD_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset) return result; } -MD_FUNCTION MD_ParseResult +MD_FUNCTION ParseResult MD_ParseWholeString(MD_Arena *arena, MD_String8 filename, MD_String8 contents) { - MD_Node *root = MD_MakeNode(arena, MD_NodeKind_File, filename, contents, 0); - MD_ParseResult result = MD_ParseNodeSet(arena, contents, 0, root, MD_ParseSetRule_Global); + Node *root = MD_MakeNode(arena, NodeKind_File, filename, contents, 0); + ParseResult result = MD_ParseNodeSet(arena, contents, 0, root, MD_ParseSetRule_Global); result.node = root; for(MD_Message *error = result.errors.first; error != 0; error = error->next) { @@ -2905,11 +2905,11 @@ MD_ParseWholeString(MD_Arena *arena, MD_String8 filename, MD_String8 contents) return result; } -MD_FUNCTION MD_ParseResult +MD_FUNCTION ParseResult MD_ParseWholeFile(MD_Arena *arena, MD_String8 filename) { MD_String8 file_contents = MD_LoadEntireFile(arena, filename); - MD_ParseResult parse = MD_ParseWholeString(arena, filename, file_contents); + ParseResult parse = MD_ParseWholeString(arena, filename, file_contents); if(file_contents.str == 0) { // NOTE(rjf): @error File failing to load @@ -2923,16 +2923,16 @@ MD_ParseWholeFile(MD_Arena *arena, MD_String8 filename) //~ Messages (Errors/Warnings) -MD_FUNCTION MD_Node* +MD_FUNCTION Node* MD_MakeErrorMarkerNode(MD_Arena *arena, MD_String8 parse_contents, MD_u64 offset) { - MD_Node *result = MD_MakeNode(arena, MD_NodeKind_ErrorMarker, MD_S8Lit(""), parse_contents, + Node *result = MD_MakeNode(arena, NodeKind_ErrorMarker, MD_S8Lit(""), parse_contents, offset); return(result); } MD_FUNCTION MD_Message* -MD_MakeNodeError(MD_Arena *arena, MD_Node *node, MD_MessageKind kind, MD_String8 str) +MD_MakeNodeError(MD_Arena *arena, Node *node, MD_MessageKind kind, MD_String8 str) { MD_Message *error = MD_PushArrayZero(arena, MD_Message, 1); error->node = node; @@ -2942,11 +2942,11 @@ MD_MakeNodeError(MD_Arena *arena, MD_Node *node, MD_MessageKind kind, MD_String8 } MD_FUNCTION MD_Message * -MD_MakeTokenError(MD_Arena *arena, MD_String8 parse_contents, MD_Token token, +MD_MakeTokenError(MD_Arena *arena, MD_String8 parse_contents, Token token, MD_MessageKind kind, MD_String8 str) { MD_u64 offset = token.raw_string.str - parse_contents.str; - MD_Node *err_node = MD_MakeErrorMarkerNode(arena, parse_contents, offset); + Node *err_node = MD_MakeErrorMarkerNode(arena, parse_contents, offset); return MD_MakeNodeError(arena, err_node, kind, str); } @@ -3013,18 +3013,18 @@ MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u64 offset) } MD_FUNCTION MD_CodeLoc -MD_CodeLocFromNode(MD_Node *node) +MD_CodeLocFromNode(Node *node) { - MD_Node *file_root = MD_NilNode(); - for(MD_Node *parent = node->parent; !MD_NodeIsNil(parent); parent = parent->parent) + Node *file_root = MD_NilNode(); + for(Node *parent = node->parent; !MD_NodeIsNil(parent); parent = parent->parent) { - if(parent->kind == MD_NodeKind_File) + if(parent->kind == NodeKind_File) { file_root = parent; break; } } - MD_Node *first_tag = file_root->first_tag; + Node *first_tag = file_root->first_tag; MD_CodeLoc loc = {0}; if(MD_NodeIsNil(first_tag)) { @@ -3040,19 +3040,19 @@ MD_CodeLocFromNode(MD_Node *node) //~ Tree/List Building MD_FUNCTION MD_b32 -MD_NodeIsNil(MD_Node *node) +MD_NodeIsNil(Node *node) { - return(node == 0 || node == &_md_nil_node || node->kind == MD_NodeKind_Nil); + return(node == 0 || node == &_md_nil_node || node->kind == NodeKind_Nil); } -MD_FUNCTION MD_Node * +MD_FUNCTION Node * MD_NilNode(void) { return &_md_nil_node; } -MD_FUNCTION MD_Node * -MD_MakeNode(MD_Arena *arena, MD_NodeKind kind, MD_String8 string, MD_String8 raw_string, +MD_FUNCTION Node * +MD_MakeNode(MD_Arena *arena, NodeKind kind, MD_String8 string, MD_String8 raw_string, MD_u64 offset) { - MD_Node *node = MD_PushArrayZero(arena, MD_Node, 1); + Node *node = MD_PushArrayZero(arena, Node, 1); node->kind = kind; node->string = string; node->raw_string = raw_string; @@ -3064,7 +3064,7 @@ MD_MakeNode(MD_Arena *arena, MD_NodeKind kind, MD_String8 string, MD_String8 raw } MD_FUNCTION void -MD_PushChild(MD_Node *parent, MD_Node *new_child) +MD_PushChild(Node *parent, Node *new_child) { if (!MD_NodeIsNil(new_child)) { @@ -3074,7 +3074,7 @@ MD_PushChild(MD_Node *parent, MD_Node *new_child) } MD_FUNCTION void -MD_PushTag(MD_Node *node, MD_Node *tag) +MD_PushTag(Node *node, Node *tag) { if (!MD_NodeIsNil(tag)) { @@ -3083,16 +3083,16 @@ MD_PushTag(MD_Node *node, MD_Node *tag) } } -MD_FUNCTION MD_Node* +MD_FUNCTION Node* MD_MakeList(MD_Arena *arena) { MD_String8 empty = {0}; - MD_Node *result = MD_MakeNode(arena, MD_NodeKind_List, empty, empty, 0); + Node *result = MD_MakeNode(arena, NodeKind_List, empty, empty, 0); return(result); } MD_FUNCTION void -MD_ListConcatInPlace(MD_Node *list, MD_Node *to_push) +MD_ListConcatInPlace(Node *list, Node *to_push) { if (!MD_NodeIsNil(to_push->first_child)) { @@ -3110,10 +3110,10 @@ MD_ListConcatInPlace(MD_Node *list, MD_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) { - MD_Node *n = MD_MakeNode(arena, MD_NodeKind_Reference, target->string, target->raw_string, + Node *n = MD_MakeNode(arena, NodeKind_Reference, target->string, target->raw_string, target->offset); n->ref_target = target; MD_PushChild(list, n); @@ -3122,11 +3122,11 @@ MD_PushNewReference(MD_Arena *arena, MD_Node *list, MD_Node *target) //~ Introspection Helpers -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_Node *result = MD_NilNode(); - for(MD_Node *node = first; !MD_NodeIsNil(node); node = node->next) + Node *result = MD_NilNode(); + for(Node *node = first; !MD_NodeIsNil(node); node = node->next) { if(MD_S8Match(string, node->string, flags)) { @@ -3137,14 +3137,14 @@ MD_FirstNodeWithString(MD_Node *first, MD_String8 string, MD_MatchFlags flags) return result; } -MD_FUNCTION MD_Node * -MD_NodeAtIndex(MD_Node *first, int n) +MD_FUNCTION Node * +MD_NodeAtIndex(Node *first, int n) { - MD_Node *result = MD_NilNode(); + Node *result = MD_NilNode(); if(n >= 0) { int idx = 0; - for(MD_Node *node = first; !MD_NodeIsNil(node); node = node->next, idx += 1) + for(Node *node = first; !MD_NodeIsNil(node); node = node->next, idx += 1) { if(idx == n) { @@ -3156,11 +3156,11 @@ MD_NodeAtIndex(MD_Node *first, int n) return result; } -MD_FUNCTION MD_Node * -MD_FirstNodeWithFlags(MD_Node *first, MD_NodeFlags flags) +MD_FUNCTION Node * +MD_FirstNodeWithFlags(Node *first, NodeFlags flags) { - MD_Node *result = MD_NilNode(); - for(MD_Node *n = first; !MD_NodeIsNil(n); n = n->next) + Node *result = MD_NilNode(); + for(Node *n = first; !MD_NodeIsNil(n); n = n->next) { if(n->flags & flags) { @@ -3172,77 +3172,77 @@ MD_FirstNodeWithFlags(MD_Node *first, MD_NodeFlags flags) } MD_FUNCTION int -MD_IndexFromNode(MD_Node *node) +MD_IndexFromNode(Node *node) { int idx = 0; - for(MD_Node *last = node->prev; !MD_NodeIsNil(last); last = last->prev, idx += 1); + for(Node *last = node->prev; !MD_NodeIsNil(last); last = last->prev, idx += 1); return idx; } -MD_FUNCTION MD_Node * -MD_RootFromNode(MD_Node *node) +MD_FUNCTION Node * +MD_RootFromNode(Node *node) { - MD_Node *parent = node; - for(MD_Node *p = parent; !MD_NodeIsNil(p); p = p->parent) + Node *parent = node; + for(Node *p = parent; !MD_NodeIsNil(p); p = p->parent) { parent = p; } return parent; } -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) { return MD_FirstNodeWithString(node->first_child, child_string, 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) { return MD_FirstNodeWithString(node->first_tag, tag_string, flags); } -MD_FUNCTION MD_Node * -MD_ChildFromIndex(MD_Node *node, int n) +MD_FUNCTION Node * +MD_ChildFromIndex(Node *node, int n) { return MD_NodeAtIndex(node->first_child, n); } -MD_FUNCTION MD_Node * -MD_TagFromIndex(MD_Node *node, int n) +MD_FUNCTION Node * +MD_TagFromIndex(Node *node, int n) { return MD_NodeAtIndex(node->first_tag, 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_Node *tag = MD_TagFromString(node, tag_string, flags); + Node *tag = MD_TagFromString(node, tag_string, flags); return MD_ChildFromIndex(tag, 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_Node *tag = MD_TagFromString(node, tag_string, tag_str_flags); - MD_Node *arg = MD_ChildFromString(tag, arg_string, arg_str_flags); + Node *tag = MD_TagFromString(node, tag_string, tag_str_flags); + Node *arg = MD_ChildFromString(tag, arg_string, arg_str_flags); return arg; } MD_FUNCTION MD_b32 -MD_NodeHasChild(MD_Node *node, MD_String8 string, MD_MatchFlags flags) +MD_NodeHasChild(Node *node, MD_String8 string, MD_MatchFlags flags) { return !MD_NodeIsNil(MD_ChildFromString(node, string, flags)); } MD_FUNCTION MD_b32 -MD_NodeHasTag(MD_Node *node, MD_String8 string, MD_MatchFlags flags) +MD_NodeHasTag(Node *node, MD_String8 string, MD_MatchFlags flags) { return !MD_NodeIsNil(MD_TagFromString(node, string, flags)); } MD_FUNCTION MD_i64 -MD_ChildCountFromNode(MD_Node *node) +MD_ChildCountFromNode(Node *node) { MD_i64 result = 0; for(MD_EachNode(child, node->first_child)) @@ -3253,7 +3253,7 @@ MD_ChildCountFromNode(MD_Node *node) } MD_FUNCTION MD_i64 -MD_TagCountFromNode(MD_Node *node) +MD_TagCountFromNode(Node *node) { MD_i64 result = 0; for(MD_EachNode(tag, node->first_tag)) @@ -3263,18 +3263,18 @@ MD_TagCountFromNode(MD_Node *node) return result; } -MD_FUNCTION MD_Node * -MD_ResolveNodeFromReference(MD_Node *node) +MD_FUNCTION Node * +MD_ResolveNodeFromReference(Node *node) { MD_u64 safety = 100; - for(; safety > 0 && node->kind == MD_NodeKind_Reference; + for(; safety > 0 && node->kind == NodeKind_Reference; safety -= 1, node = node->ref_target); - MD_Node *result = node; + Node *result = node; return(result); } -MD_FUNCTION MD_Node* -MD_NodeNextWithLimit(MD_Node *node, MD_Node *opl) +MD_FUNCTION Node* +MD_NodeNextWithLimit(Node *node, Node *opl) { node = node->next; if (node == opl) @@ -3285,13 +3285,13 @@ MD_NodeNextWithLimit(MD_Node *node, MD_Node *opl) } MD_FUNCTION MD_String8 -MD_PrevCommentFromNode(MD_Node *node) +MD_PrevCommentFromNode(Node *node) { return(node->prev_comment); } MD_FUNCTION MD_String8 -MD_NextCommentFromNode(MD_Node *node) +MD_NextCommentFromNode(Node *node) { return(node->next_comment); } @@ -3351,7 +3351,7 @@ MD_PrintMessageFmt(FILE *file, MD_CodeLoc code_loc, MD_MessageKind kind, char *f //~ Tree Comparison/Verification MD_FUNCTION MD_b32 -MD_NodeMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags) +MD_NodeMatch(Node *a, Node *b, MD_MatchFlags flags) { MD_b32 result = 0; if(a->kind == b->kind && MD_S8Match(a->string, b->string, flags)) @@ -3361,9 +3361,9 @@ MD_NodeMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags) { result = result && a->flags == b->flags; } - if(result && a->kind != MD_NodeKind_Tag && (flags & MD_NodeMatchFlag_Tags)) + if(result && a->kind != NodeKind_Tag && (flags & MD_NodeMatchFlag_Tags)) { - for(MD_Node *a_tag = a->first_tag, *b_tag = b->first_tag; + for(Node *a_tag = a->first_tag, *b_tag = b->first_tag; !MD_NodeIsNil(a_tag) || !MD_NodeIsNil(b_tag); a_tag = a_tag->next, b_tag = b_tag->next) { @@ -3371,7 +3371,7 @@ MD_NodeMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags) { if(flags & MD_NodeMatchFlag_TagArguments) { - for(MD_Node *a_tag_arg = a_tag->first_child, *b_tag_arg = b_tag->first_child; + for(Node *a_tag_arg = a_tag->first_child, *b_tag_arg = b_tag->first_child; !MD_NodeIsNil(a_tag_arg) || !MD_NodeIsNil(b_tag_arg); a_tag_arg = a_tag_arg->next, b_tag_arg = b_tag_arg->next) { @@ -3396,12 +3396,12 @@ MD_NodeMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags) } MD_FUNCTION MD_b32 -MD_NodeDeepMatch(MD_Node *a, MD_Node *b, MD_MatchFlags flags) +MD_NodeDeepMatch(Node *a, Node *b, MD_MatchFlags flags) { MD_b32 result = MD_NodeMatch(a, b, flags); if(result) { - for(MD_Node *a_child = a->first_child, *b_child = b->first_child; + for(Node *a_child = a->first_child, *b_child = b->first_child; !MD_NodeIsNil(a_child) || !MD_NodeIsNil(b_child); a_child = a_child->next, b_child = b_child->next) { @@ -3459,7 +3459,7 @@ MD_ExprBakeOprTableFromList(MD_Arena *arena, MD_ExprOprList *list) // error checking MD_String8 error_str = MD_ZERO_STRUCT; - MD_Token op_token = MD_TokenFromString(op_s); + Token op_token = MD_TokenFromString(op_s); MD_b32 is_setlike_op = (op_s.size == 2 && (MD_S8Match(op_s, MD_S8Lit("[]"), 0) || MD_S8Match(op_s, MD_S8Lit("()"), 0) || @@ -3576,7 +3576,7 @@ MD_ExprOprFromKindString(MD_ExprOprTable *table, MD_ExprOprKind kind, MD_String8 } MD_FUNCTION MD_ExprParseResult -MD_ExprParse(MD_Arena *arena, MD_ExprOprTable *op_table, MD_Node *first, MD_Node *opl) +MD_ExprParse(MD_Arena *arena, MD_ExprOprTable *op_table, Node *first, Node *opl) { // setup a context MD_ExprParseCtx ctx = MD_ExprParse_MakeContext(op_table); @@ -3592,7 +3592,7 @@ MD_ExprParse(MD_Arena *arena, MD_ExprOprTable *op_table, MD_Node *first, MD_Node } MD_FUNCTION MD_Expr* -MD_Expr_NewLeaf(MD_Arena *arena, MD_Node *node) +MD_Expr_NewLeaf(MD_Arena *arena, Node *node) { MD_Expr *result = MD_PushArrayZero(arena, MD_Expr, 1); result->md_node = node; @@ -3600,7 +3600,7 @@ MD_Expr_NewLeaf(MD_Arena *arena, MD_Node *node) } MD_FUNCTION MD_Expr* -MD_Expr_NewOpr(MD_Arena *arena, MD_ExprOpr *op, MD_Node *op_node, MD_Expr *l, MD_Expr *r) +MD_Expr_NewOpr(MD_Arena *arena, MD_ExprOpr *op, Node *op_node, MD_Expr *l, MD_Expr *r) { MD_Expr *result = MD_PushArrayZero(arena, MD_Expr, 1); result->op = op; @@ -3628,34 +3628,34 @@ MD_ExprParse_MakeContext(MD_ExprOprTable *op_table) result.op_table = op_table; result.accel.postfix_set_ops[0] = MD_ExprOprFromKindString(op_table, MD_ExprOprKind_Postfix, MD_S8Lit("()")); - result.accel.postfix_set_flags[0] = MD_NodeFlag_HasParenLeft | MD_NodeFlag_HasParenRight; + result.accel.postfix_set_flags[0] = NodeFlag_HasParenLeft | NodeFlag_HasParenRight; result.accel.postfix_set_ops[1] = MD_ExprOprFromKindString(op_table, MD_ExprOprKind_Postfix, MD_S8Lit("[]")); - result.accel.postfix_set_flags[1] = MD_NodeFlag_HasBracketLeft | MD_NodeFlag_HasBracketRight; + result.accel.postfix_set_flags[1] = NodeFlag_HasBracketLeft | NodeFlag_HasBracketRight; result.accel.postfix_set_ops[2] = MD_ExprOprFromKindString(op_table, MD_ExprOprKind_Postfix, MD_S8Lit("{}")); - result.accel.postfix_set_flags[2] = MD_NodeFlag_HasBraceLeft | MD_NodeFlag_HasBraceRight; + result.accel.postfix_set_flags[2] = NodeFlag_HasBraceLeft | NodeFlag_HasBraceRight; result.accel.postfix_set_ops[3] = MD_ExprOprFromKindString(op_table, MD_ExprOprKind_Postfix, MD_S8Lit("[)")); - result.accel.postfix_set_flags[3] = MD_NodeFlag_HasBracketLeft | MD_NodeFlag_HasParenRight; + result.accel.postfix_set_flags[3] = NodeFlag_HasBracketLeft | NodeFlag_HasParenRight; result.accel.postfix_set_ops[4] = MD_ExprOprFromKindString(op_table, MD_ExprOprKind_Postfix, MD_S8Lit("(]")); - result.accel.postfix_set_flags[4] = MD_NodeFlag_HasParenLeft | MD_NodeFlag_HasBracketRight; + result.accel.postfix_set_flags[4] = NodeFlag_HasParenLeft | NodeFlag_HasBracketRight; return(result); } MD_FUNCTION MD_Expr* -MD_ExprParse_TopLevel(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node *first, MD_Node *opl) +MD_ExprParse_TopLevel(MD_Arena *arena, MD_ExprParseCtx *ctx, Node *first, Node *opl) { // parse the node range - MD_Node *iter = first; + Node *iter = first; MD_Expr *expr = MD_ExprParse_MinPrecedence(arena, ctx, &iter, first, opl, 0); // check for failed-to-reach-end error if(ctx->errors.max_message_kind == MD_MessageKind_Null) { - MD_Node *stop_node = iter; + Node *stop_node = iter; if(!MD_NodeIsNil(stop_node)) { MD_String8 error_str = MD_S8Lit("Expected binary or unary postfix operator."); @@ -3668,11 +3668,11 @@ MD_ExprParse_TopLevel(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node *first, MD_ } MD_FUNCTION MD_b32 -MD_ExprParse_OprConsume(MD_ExprParseCtx *ctx, MD_Node **iter, MD_Node *opl, +MD_ExprParse_OprConsume(MD_ExprParseCtx *ctx, Node **iter, Node *opl, MD_ExprOprKind kind, MD_u32 min_precedence, MD_ExprOpr **op_out) { MD_b32 result = 0; - MD_Node *node = *iter; + Node *node = *iter; if(!MD_NodeIsNil(node)) { MD_ExprOpr *op = MD_ExprOprFromKindString(ctx->op_table, kind, node->string); @@ -3687,24 +3687,24 @@ MD_ExprParse_OprConsume(MD_ExprParseCtx *ctx, MD_Node **iter, MD_Node *opl, } MD_FUNCTION MD_Expr* -MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node **iter, - MD_Node *first, MD_Node *opl) +MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, Node **iter, + Node *first, Node *opl) { // TODO(allen): nil MD_Expr* result = 0; - MD_Node *node = *iter; + Node *node = *iter; MD_ExprOpr *op = 0; if(MD_NodeIsNil(node)) { - MD_Node *last = first; + Node *last = first; for (;last->next != opl; last = last->next); - MD_Node *error_node = last->next; + Node *error_node = last->next; if (MD_NodeIsNil(error_node)) { - MD_Node *root = MD_RootFromNode(node); + Node *root = MD_RootFromNode(node); MD_String8 parse_contents = root->raw_string; MD_u64 offset = last->offset + last->raw_string.size; error_node = MD_MakeErrorMarkerNode(arena, parse_contents, offset); @@ -3715,16 +3715,16 @@ MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node **iter, error_str); MD_MessageListPush(&ctx->errors, error); } - else if((node->flags & MD_NodeFlag_HasParenLeft) && - (node->flags & MD_NodeFlag_HasParenRight)) + else if((node->flags & NodeFlag_HasParenLeft) && + (node->flags & NodeFlag_HasParenRight)) { // NOTE(mal): Parens *iter = MD_NodeNextWithLimit(*iter, opl); result = MD_ExprParse_TopLevel(arena, ctx, node->first_child, MD_NilNode()); } - else if(((node->flags & MD_NodeFlag_HasBraceLeft) && (node->flags & MD_NodeFlag_HasBraceRight)) || - ((node->flags & MD_NodeFlag_HasBracketLeft) && (node->flags & MD_NodeFlag_HasBracketRight)) || - ((node->flags & MD_NodeFlag_HasBracketLeft) && (node->flags & MD_NodeFlag_HasParenRight)) || - ((node->flags & MD_NodeFlag_HasParenLeft) && (node->flags & MD_NodeFlag_HasBracketRight))) + else if(((node->flags & NodeFlag_HasBraceLeft) && (node->flags & NodeFlag_HasBraceRight)) || + ((node->flags & NodeFlag_HasBracketLeft) && (node->flags & NodeFlag_HasBracketRight)) || + ((node->flags & NodeFlag_HasBracketLeft) && (node->flags & NodeFlag_HasParenRight)) || + ((node->flags & NodeFlag_HasParenLeft) && (node->flags & NodeFlag_HasBracketRight))) { // NOTE(mal): Unparsed leaf sets ({...}, [...], [...), (...]) *iter = MD_NodeNextWithLimit(*iter, opl); result = MD_Expr_NewLeaf(arena, node); @@ -3747,8 +3747,8 @@ MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node **iter, MD_MessageListPush(&ctx->errors, error); } else if(node->flags & - (MD_NodeFlag_HasParenLeft|MD_NodeFlag_HasParenRight|MD_NodeFlag_HasBracketLeft| - MD_NodeFlag_HasBracketRight|MD_NodeFlag_HasBraceLeft|MD_NodeFlag_HasBraceRight)) + (NodeFlag_HasParenLeft|NodeFlag_HasParenRight|NodeFlag_HasBracketLeft| + NodeFlag_HasBracketRight|NodeFlag_HasBraceLeft|NodeFlag_HasBraceRight)) { MD_String8 error_str = MD_S8Fmt(arena, "Unexpected set.", MD_S8VArg(node->string)); MD_Message *error = MD_MakeNodeError(arena, node, MD_MessageKind_FatalError, error_str); @@ -3764,7 +3764,7 @@ MD_ExprParse_Atom(MD_Arena *arena, MD_ExprParseCtx *ctx, MD_Node **iter, 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) { // TODO(allen): nil @@ -3775,7 +3775,7 @@ MD_ExprParse_MinPrecedence(MD_Arena *arena, MD_ExprParseCtx *ctx, { for (;!MD_NodeIsNil(*iter);) { - MD_Node *node = *iter; + Node *node = *iter; MD_ExprOpr *op = 0; if(MD_ExprParse_OprConsume(ctx, iter, opl, MD_ExprOprKind_Binary, @@ -3840,7 +3840,7 @@ MD_ExprParse_MinPrecedence(MD_Arena *arena, MD_ExprParseCtx *ctx, //~ String Generation MD_FUNCTION void -MD_DebugDumpFromNode(MD_Arena *arena, MD_String8List *out, MD_Node *node, +MD_DebugDumpFromNode(MD_Arena *arena, MD_String8List *out, Node *node, int indent, MD_String8 indent_string, MD_GenerateFlags flags) { #define MD_PrintIndent(_indent_level) do\ @@ -3934,7 +3934,7 @@ MD_S8ListPush(arena, out, indent_string);\ if(node->string.size != 0) { MD_PrintIndent(indent); - if(node->kind == MD_NodeKind_File) + if(node->kind == NodeKind_File) { MD_S8ListPush(arena, out, MD_S8Lit("`")); MD_S8ListPush(arena, out, node->string); @@ -3981,7 +3981,7 @@ MD_S8ListPush(arena, out, indent_string);\ } MD_FUNCTION void -MD_ReconstructionFromNode(MD_Arena *arena, MD_String8List *out, MD_Node *node, +MD_ReconstructionFromNode(MD_Arena *arena, MD_String8List *out, Node *node, int indent, MD_String8 indent_string) { MD_CodeLoc code_loc = MD_CodeLocFromNode(node); @@ -4082,7 +4082,7 @@ MD_S8ListPush(arena, out, indent_string);\ { MD_S8ListPush(arena, out, MD_S8Lit(" ")); } - if(node->kind == MD_NodeKind_File) + if(node->kind == NodeKind_File) { MD_S8ListPush(arena, out, MD_S8Lit("`")); MD_S8ListPush(arena, out, node->string); @@ -4105,12 +4105,12 @@ MD_S8ListPush(arena, out, indent_string);\ // rjf: figure out opener/closer symbols MD_u8 opener_char = 0; MD_u8 closer_char = 0; - if(node->flags & MD_NodeFlag_HasParenLeft) { opener_char = '('; } - else if(node->flags & MD_NodeFlag_HasBracketLeft) { opener_char = '['; } - else if(node->flags & MD_NodeFlag_HasBraceLeft) { opener_char = '{'; } - if(node->flags & MD_NodeFlag_HasParenRight) { closer_char = ')'; } - else if(node->flags & MD_NodeFlag_HasBracketRight){ closer_char = ']'; } - else if(node->flags & MD_NodeFlag_HasBraceRight) { closer_char = '}'; } + if(node->flags & NodeFlag_HasParenLeft) { opener_char = '('; } + else if(node->flags & NodeFlag_HasBracketLeft) { opener_char = '['; } + else if(node->flags & NodeFlag_HasBraceLeft) { opener_char = '{'; } + if(node->flags & NodeFlag_HasParenRight) { closer_char = ')'; } + else if(node->flags & NodeFlag_HasBracketRight){ closer_char = ']'; } + else if(node->flags & NodeFlag_HasBraceRight) { closer_char = '}'; } MD_b32 multiline = 0; for(MD_EachNode(child, node->first_child)) @@ -4172,11 +4172,11 @@ MD_S8ListPush(arena, out, indent_string);\ } //- rjf: trailing separator symbols - if(node->flags & MD_NodeFlag_IsBeforeSemicolon) + if(node->flags & NodeFlag_IsBeforeSemicolon) { MD_S8ListPush(arena, out, MD_S8Lit(";")); } - else if(node->flags & MD_NodeFlag_IsBeforeComma) + else if(node->flags & NodeFlag_IsBeforeComma) { MD_S8ListPush(arena, out, MD_S8Lit(",")); } @@ -4213,7 +4213,7 @@ MD_S8ListPush(arena, out, indent_string);\ #if !MD_DISABLE_PRINT_HELPERS MD_FUNCTION void -MD_PrintDebugDumpFromNode(FILE *file, MD_Node *node, MD_GenerateFlags flags) +MD_PrintDebugDumpFromNode(FILE *file, Node *node, MD_GenerateFlags flags) { MD_ArenaTemp scratch = MD_GetScratch(0, 0); MD_String8List list = {0}; diff --git a/source/md.h b/source/md.h index 65a3fde..2852bcd 100644 --- a/source/md.h +++ b/source/md.h @@ -548,88 +548,88 @@ MD_IdentifierStyle; //~ 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. - MD_NodeKind_Nil, + NodeKind_Nil, // NOTE(rjf): Generated by parser - MD_NodeKind_File, - MD_NodeKind_ErrorMarker, + NodeKind_File, + NodeKind_ErrorMarker, // NOTE(rjf): Parsed from user Metadesk code - MD_NodeKind_Main, - MD_NodeKind_Tag, + NodeKind_Main, + NodeKind_Tag, // NOTE(rjf): User-created data structures - MD_NodeKind_List, - MD_NodeKind_Reference, + NodeKind_List, + NodeKind_Reference, - MD_NodeKind_COUNT, + NodeKind_COUNT, } -MD_NodeKind; +NodeKind; -typedef MD_u64 MD_NodeFlags; -#define MD_NodeFlag_AfterFromBefore(f) ((f) << 1) +typedef MD_u64 NodeFlags; +#define NodeFlag_AfterFromBefore(f) ((f) << 1) enum { // 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 // the correct order which is that the Before* flag comes first, and the // After* flag comes immediately after (After* being the more significant // bit). - MD_NodeFlag_HasParenLeft = (1<<0), - MD_NodeFlag_HasParenRight = (1<<1), - MD_NodeFlag_HasBracketLeft = (1<<2), - MD_NodeFlag_HasBracketRight = (1<<3), - MD_NodeFlag_HasBraceLeft = (1<<4), - MD_NodeFlag_HasBraceRight = (1<<5), + NodeFlag_HasParenLeft = (1<<0), + NodeFlag_HasParenRight = (1<<1), + NodeFlag_HasBracketLeft = (1<<2), + NodeFlag_HasBracketRight = (1<<3), + NodeFlag_HasBraceLeft = (1<<4), + NodeFlag_HasBraceRight = (1<<5), - MD_NodeFlag_MaskSetDelimiters = (0x3F<<0), + NodeFlag_MaskSetDelimiters = (0x3F<<0), - MD_NodeFlag_IsBeforeSemicolon = (1<<6), - MD_NodeFlag_IsAfterSemicolon = (1<<7), - MD_NodeFlag_IsBeforeComma = (1<<8), - MD_NodeFlag_IsAfterComma = (1<<9), + NodeFlag_IsBeforeSemicolon = (1<<6), + NodeFlag_IsAfterSemicolon = (1<<7), + NodeFlag_IsBeforeComma = (1<<8), + NodeFlag_IsAfterComma = (1<<9), - MD_NodeFlag_MaskSeperators = (0xF<<6), + NodeFlag_MaskSeperators = (0xF<<6), - MD_NodeFlag_StringSingleQuote = (1<<10), - MD_NodeFlag_StringDoubleQuote = (1<<11), - MD_NodeFlag_StringTick = (1<<12), - MD_NodeFlag_StringTriplet = (1<<13), + NodeFlag_StringSingleQuote = (1<<10), + NodeFlag_StringDoubleQuote = (1<<11), + NodeFlag_StringTick = (1<<12), + NodeFlag_StringTriplet = (1<<13), - MD_NodeFlag_MaskStringDelimiters = (0xF<<10), + NodeFlag_MaskStringDelimiters = (0xF<<10), - MD_NodeFlag_Numeric = (1<<14), - MD_NodeFlag_Identifier = (1<<15), - MD_NodeFlag_StringLiteral = (1<<16), - MD_NodeFlag_Symbol = (1<<17), + NodeFlag_Numeric = (1<<14), + NodeFlag_Identifier = (1<<15), + NodeFlag_StringLiteral = (1<<16), + NodeFlag_Symbol = (1<<17), - MD_NodeFlag_MaskLabelKind = (0xF<<14), + NodeFlag_MaskLabelKind = (0xF<<14), }; -typedef struct MD_Node MD_Node; -struct MD_Node +typedef struct Node Node; +struct Node { // Tree relationship data. - MD_Node *next; - MD_Node *prev; - MD_Node *parent; - MD_Node *first_child; - MD_Node *last_child; + Node *next; + Node *prev; + Node *parent; + Node *first_child; + Node *last_child; // Tag list. - MD_Node *first_tag; - MD_Node *last_tag; + Node *first_tag; + Node *last_tag; // Node info. - MD_NodeKind kind; - MD_NodeFlags flags; + NodeKind kind; + NodeFlags flags; MD_String8 string; MD_String8 raw_string; @@ -637,7 +637,7 @@ struct MD_Node MD_u64 offset; // Reference. - MD_Node *ref_target; + Node *ref_target; // Comments. // @usage prev_comment/next_comment should be considered "hidden". Rely on @@ -710,26 +710,26 @@ enum typedef MD_u32 MD_TokenGroups; enum { - MD_TokenGroup_Comment = MD_TokenKind_Comment, - MD_TokenGroup_Whitespace = (MD_TokenKind_Whitespace| + TokenGroup_Comment = MD_TokenKind_Comment, + TokenGroup_Whitespace = (MD_TokenKind_Whitespace| MD_TokenKind_Newline), - MD_TokenGroup_Irregular = (MD_TokenGroup_Comment| - MD_TokenGroup_Whitespace), - MD_TokenGroup_Regular = ~MD_TokenGroup_Irregular, - MD_TokenGroup_Label = (MD_TokenKind_Identifier| + TokenGroup_Irregular = (TokenGroup_Comment| + TokenGroup_Whitespace), + TokenGroup_Regular = ~TokenGroup_Irregular, + TokenGroup_Label = (MD_TokenKind_Identifier| MD_TokenKind_Numeric| MD_TokenKind_StringLiteral| MD_TokenKind_Symbol), - MD_TokenGroup_Error = (MD_TokenKind_BrokenComment| + TokenGroup_Error = (MD_TokenKind_BrokenComment| MD_TokenKind_BrokenStringLiteral| MD_TokenKind_BadCharacter), }; -typedef struct MD_Token MD_Token; -struct MD_Token +typedef struct Token Token; +struct Token { MD_TokenKind kind; - MD_NodeFlags node_flags; + NodeFlags node_flags; MD_String8 string; MD_String8 raw_string; }; @@ -752,7 +752,7 @@ typedef struct MD_Message MD_Message; struct MD_Message { MD_Message *next; - MD_Node *node; + Node *node; MD_MessageKind kind; MD_String8 string; void *user_ptr; @@ -774,10 +774,10 @@ typedef enum MD_ParseSetRule MD_ParseSetRule_Global, } MD_ParseSetRule; -typedef struct MD_ParseResult MD_ParseResult; -struct MD_ParseResult +typedef struct ParseResult ParseResult; +struct ParseResult { - MD_Node *node; + Node *node; MD_u64 string_advance; MD_MessageList errors; }; @@ -831,7 +831,7 @@ struct MD_Expr }; struct MD_Expr *right; MD_ExprOpr *op; - MD_Node *md_node; + Node *md_node; }; typedef struct MD_ExprParseResult MD_ExprParseResult; @@ -852,7 +852,7 @@ struct MD_ExprParseCtx struct { 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; #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 -MD_FUNCTION MD_String8 MD_StringFromNodeKind(MD_NodeKind kind); -MD_FUNCTION MD_String8List MD_StringListFromNodeFlags(MD_Arena *arena, MD_NodeFlags flags); +MD_FUNCTION MD_String8 MD_StringFromNodeKind(NodeKind kind); +MD_FUNCTION MD_String8List MD_StringListFromNodeFlags(MD_Arena *arena, NodeFlags flags); //~ Map Table Data Structure @@ -1080,25 +1080,25 @@ MD_FUNCTION MD_MapSlot* MD_MapOverwrite(MD_Arena *arena, MD_Map *map, MD_MapKey //~ 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_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_ParseResultZero(void); +MD_FUNCTION ParseResult MD_ParseNodeSet(MD_Arena *arena, MD_String8 string, MD_u64 offset, Node *parent, MD_ParseSetRule rule); -MD_FUNCTION MD_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_ParseOneNode(MD_Arena *arena, MD_String8 string, MD_u64 offset); +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) -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_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_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_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 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 -MD_FUNCTION MD_b32 MD_NodeIsNil(MD_Node *node); -MD_FUNCTION MD_Node *MD_NilNode(void); -MD_FUNCTION MD_Node *MD_MakeNode(MD_Arena *arena, MD_NodeKind kind, MD_String8 string, +MD_FUNCTION MD_b32 MD_NodeIsNil(Node *node); +MD_FUNCTION Node *MD_NilNode(void); +MD_FUNCTION Node *MD_MakeNode(MD_Arena *arena, NodeKind kind, MD_String8 string, MD_String8 raw_string, MD_u64 offset); -MD_FUNCTION void MD_PushChild(MD_Node *parent, MD_Node *new_child); -MD_FUNCTION void MD_PushTag(MD_Node *node, MD_Node *tag); +MD_FUNCTION void MD_PushChild(Node *parent, Node *new_child); +MD_FUNCTION void MD_PushTag(Node *node, Node *tag); -MD_FUNCTION MD_Node *MD_MakeList(MD_Arena *arena); -MD_FUNCTION void MD_ListConcatInPlace(MD_Node *list, MD_Node *to_push); -MD_FUNCTION MD_Node *MD_PushNewReference(MD_Arena *arena, MD_Node *list, MD_Node *target); +MD_FUNCTION Node *MD_MakeList(MD_Arena *arena); +MD_FUNCTION void MD_ListConcatInPlace(Node *list, Node *to_push); +MD_FUNCTION Node *MD_PushNewReference(MD_Arena *arena, Node *list, Node *target); //~ Introspection Helpers // These calls are for getting info from nodes, and introspecting // 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 MD_Node * MD_NodeAtIndex(MD_Node *first, int n); -MD_FUNCTION MD_Node * MD_FirstNodeWithFlags(MD_Node *first, MD_NodeFlags flags); -MD_FUNCTION int MD_IndexFromNode(MD_Node *node); -MD_FUNCTION MD_Node * MD_RootFromNode(MD_Node *node); -MD_FUNCTION MD_Node * MD_ChildFromString(MD_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 MD_Node * MD_ChildFromIndex(MD_Node *node, int n); -MD_FUNCTION MD_Node * MD_TagFromIndex(MD_Node *node, int n); -MD_FUNCTION MD_Node * MD_TagArgFromIndex(MD_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 MD_b32 MD_NodeHasChild(MD_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_i64 MD_ChildCountFromNode(MD_Node *node); -MD_FUNCTION MD_i64 MD_TagCountFromNode(MD_Node *node); -MD_FUNCTION MD_Node * MD_ResolveNodeFromReference(MD_Node *node); -MD_FUNCTION MD_Node* MD_NodeNextWithLimit(MD_Node *node, MD_Node *opl); +MD_FUNCTION Node * MD_FirstNodeWithString(Node *first, MD_String8 string, MD_MatchFlags flags); +MD_FUNCTION Node * MD_NodeAtIndex(Node *first, int n); +MD_FUNCTION Node * MD_FirstNodeWithFlags(Node *first, NodeFlags flags); +MD_FUNCTION int MD_IndexFromNode(Node *node); +MD_FUNCTION Node * MD_RootFromNode(Node *node); +MD_FUNCTION Node * MD_ChildFromString(Node *node, MD_String8 child_string, MD_MatchFlags flags); +MD_FUNCTION Node * MD_TagFromString(Node *node, MD_String8 tag_string, MD_MatchFlags flags); +MD_FUNCTION Node * MD_ChildFromIndex(Node *node, int n); +MD_FUNCTION Node * MD_TagFromIndex(Node *node, int n); +MD_FUNCTION Node * MD_TagArgFromIndex(Node *node, MD_String8 tag_string, MD_MatchFlags flags, int n); +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(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(Node *node); +MD_FUNCTION MD_i64 MD_TagCountFromNode(Node *node); +MD_FUNCTION Node * MD_ResolveNodeFromReference(Node *node); +MD_FUNCTION Node* MD_NodeNextWithLimit(Node *node, Node *opl); -MD_FUNCTION MD_String8 MD_PrevCommentFromNode(MD_Node *node); -MD_FUNCTION MD_String8 MD_NextCommentFromNode(MD_Node *node); +MD_FUNCTION MD_String8 MD_PrevCommentFromNode(Node *node); +MD_FUNCTION MD_String8 MD_NextCommentFromNode(Node *node); // 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 @@ -1173,8 +1173,8 @@ MD_FUNCTION void MD_PrintMessageFmt(FILE *file, MD_CodeLoc code_loc, MD_MessageK //~ Tree Comparison/Verification -MD_FUNCTION MD_b32 MD_NodeMatch(MD_Node *a, MD_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_NodeMatch(Node *a, Node *b, MD_MatchFlags flags); +MD_FUNCTION MD_b32 MD_NodeDeepMatch(Node *a, Node *b, MD_MatchFlags flags); //~ Expression Parsing @@ -1189,34 +1189,34 @@ MD_FUNCTION MD_ExprOpr* MD_ExprOprFromKindString(MD_ExprOprTable *table, MD_ExprOprKind kind, MD_String8 s); 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_NewOpr(MD_Arena *arena, MD_ExprOpr *op, MD_Node *op_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, Node *op_node, MD_Expr *left, MD_Expr *right); MD_FUNCTION MD_ExprParseCtx MD_ExprParse_MakeContext(MD_ExprOprTable *table); 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_Node **iter, MD_Node *opl, + Node **iter, Node *opl, MD_ExprOprKind kind, MD_u32 min_precedence, MD_ExprOpr **op_out); 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_Node **iter, MD_Node *first, MD_Node *opl, + Node **iter, Node *first, Node *opl, MD_u32 min_precedence); //~ 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, 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); //~ Command Line Argument Helper diff --git a/tests/expression_tests.c b/tests/expression_tests.c index 8e4d38f..7bfb519 100644 --- a/tests/expression_tests.c +++ b/tests/expression_tests.c @@ -86,7 +86,7 @@ typedef enum{ } Op; #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}; @@ -98,7 +98,7 @@ static MD_String8 node_raw_contents(MD_Node *node, MD_b32 exclude_outer) MD_u64 end = beg; { - MD_Node *last_descendant = node; + Node *last_descendant = node; for(;!MD_NodeIsNil(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; } - MD_Node *root = node; + Node *root = node; for(;!MD_NodeIsNil(root->parent);) { root = root->parent; @@ -185,29 +185,29 @@ static void parenthesize_exclude_outer(MD_Arena *arena, OperatorDescription *des } else { - if(node->md_node->flags & MD_NodeFlag_HasParenLeft) + if(node->md_node->flags & NodeFlag_HasParenLeft) { 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("{")); } - 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("...")); - if(node->md_node->flags & MD_NodeFlag_HasParenRight) + if(node->md_node->flags & NodeFlag_HasParenRight) { 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("}")); } - else if(node->md_node->flags & MD_NodeFlag_HasBracketRight){ + else if(node->md_node->flags & NodeFlag_HasBracketRight){ 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 minus = MD_S8Lit("-"); MD_String8 cast = MD_S8Lit("()"); - MD_Node *plus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0); - MD_Node *cast_node = MD_MakeNode(g_arena, MD_NodeKind_Main, cast, cast, 0); - MD_Node *minus_node = MD_MakeNode(g_arena, MD_NodeKind_Main, minus, minus, 0); - MD_Node *plus_node_bis = MD_MakeNode(g_arena, MD_NodeKind_Main, plus, plus, 0); + Node *plus_node = MD_MakeNode(g_arena, NodeKind_Main, plus, plus, 0); + Node *cast_node = MD_MakeNode(g_arena, NodeKind_Main, cast, cast, 0); + Node *minus_node = MD_MakeNode(g_arena, NodeKind_Main, minus, minus, 0); + Node *plus_node_bis = MD_MakeNode(g_arena, NodeKind_Main, plus, plus, 0); 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) { 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, 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 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) { MD_ExprParseResult expr_parse = MD_ExprParse(g_arena, &op_table, parse.node->first_child, MD_NilNode()); diff --git a/tests/sanity_tests.c b/tests/sanity_tests.c index bda41f9..04efa4e 100644 --- a/tests/sanity_tests.c +++ b/tests/sanity_tests.c @@ -63,21 +63,21 @@ EndTest(void) #define Test(name) for(int _i_ = (BeginTest(name), 0); !_i_; _i_ += 1, EndTest()) -static MD_Node * -MakeTestNode(MD_NodeKind kind, MD_String8 string) +static Node * +MakeTestNode(NodeKind kind, MD_String8 string) { return MD_MakeNode(arena, kind, string, string, 0); } 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); } 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; } @@ -89,10 +89,10 @@ int main(void) Test("Lexer") { MD_String8 string = MD_S8Lit("abc def 123 456 123_456 abc123 123abc +-*"); - MD_Token tokens[100]; + Token tokens[100]; - MD_Token *token = tokens; - MD_Token *token_opl = tokens + MD_ArrayCount(tokens); + Token *token = tokens; + Token *token_opl = tokens + MD_ArrayCount(tokens); MD_u64 pos = 0; for (; pos < string.size && token < token_opl; ) { @@ -120,37 +120,37 @@ int main(void) Test("Empty Sets") { - TestResult(MatchParsedWithNode(MD_S8Lit("{}"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); - TestResult(MatchParsedWithNode(MD_S8Lit("()"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); - TestResult(MatchParsedWithNode(MD_S8Lit("[]"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")))); - TestResult(MatchParsedWithNode(MD_S8Lit("[)"), MakeTestNode(MD_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(NodeKind_Main, MD_S8Lit("")))); + TestResult(MatchParsedWithNode(MD_S8Lit("[]"), MakeTestNode(NodeKind_Main, MD_S8Lit("")))); + TestResult(MatchParsedWithNode(MD_S8Lit("[)"), MakeTestNode(NodeKind_Main, MD_S8Lit("")))); + TestResult(MatchParsedWithNode(MD_S8Lit("(]"), MakeTestNode(NodeKind_Main, MD_S8Lit("")))); } Test("Simple Unnamed Sets") { { MD_String8 string = MD_S8Lit("{a, b, c}"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("")); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("b"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("c"))); TestResult(MatchParsedWithNode(string, tree)); } { MD_String8 string = MD_S8Lit("(1 2 3 4 5)"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("1"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("2"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("3"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("4"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("5"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("")); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("1"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("2"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("3"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("4"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("5"))); TestResult(MatchParsedWithNode(string, tree)); } { MD_String8 string = MD_S8Lit("{a}"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("")); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a"))); TestResult(MatchParsedWithNode(string, tree)); } } @@ -158,10 +158,10 @@ int main(void) Test("Simple Named Sets") { MD_String8 string = MD_S8Lit("simple_set: {a, b, c}"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("simple_set")); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("simple_set")); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("b"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("c"))); TestResult(MatchParsedWithNode(string, tree)); } @@ -169,128 +169,128 @@ int main(void) { { MD_String8 string = MD_S8Lit("{a b:{1 2 3} c}"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("")); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("a"))); { - MD_Node *sub = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b")); - MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("1"))); - MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("2"))); - MD_PushChild(sub, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("3"))); + Node *sub = MakeTestNode(NodeKind_Main, MD_S8Lit("b")); + MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("1"))); + MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("2"))); + MD_PushChild(sub, MakeTestNode(NodeKind_Main, MD_S8Lit("3"))); 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)); } { MD_String8 string = MD_S8Lit("foo: { (size: u64) -> *void }"); - MD_Node *tree = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("foo")); - MD_Node *params = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("")); - MD_Node *size = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("size")); - MD_PushChild(size, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("u64"))); + Node *tree = MakeTestNode(NodeKind_Main, MD_S8Lit("foo")); + Node *params = MakeTestNode(NodeKind_Main, MD_S8Lit("")); + Node *size = MakeTestNode(NodeKind_Main, MD_S8Lit("size")); + MD_PushChild(size, MakeTestNode(NodeKind_Main, MD_S8Lit("u64"))); MD_PushChild(params, size); MD_PushChild(tree, params); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("->"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("*"))); - MD_PushChild(tree, MakeTestNode(MD_NodeKind_Main, MD_S8Lit("void"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("->"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("*"))); + MD_PushChild(tree, MakeTestNode(NodeKind_Main, MD_S8Lit("void"))); TestResult(MatchParsedWithNode(string, tree)); } } Test("Non-Sets") { - TestResult(MatchParsedWithNode(MD_S8Lit("foo"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("foo")))); - TestResult(MatchParsedWithNode(MD_S8Lit("123"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("123")))); - TestResult(MatchParsedWithNode(MD_S8Lit("+"), MakeTestNode(MD_NodeKind_Main, MD_S8Lit("+")))); + TestResult(MatchParsedWithNode(MD_S8Lit("foo"), MakeTestNode(NodeKind_Main, MD_S8Lit("foo")))); + TestResult(MatchParsedWithNode(MD_S8Lit("123"), MakeTestNode(NodeKind_Main, MD_S8Lit("123")))); + TestResult(MatchParsedWithNode(MD_S8Lit("+"), MakeTestNode(NodeKind_Main, MD_S8Lit("+")))); } Test("Set Border Flags") { { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100)"), 0); - TestResult(parse.node->flags & MD_NodeFlag_HasParenLeft && - parse.node->flags & MD_NodeFlag_HasParenRight); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100)"), 0); + TestResult(parse.node->flags & NodeFlag_HasParenLeft && + parse.node->flags & NodeFlag_HasParenRight); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100]"), 0); - TestResult(parse.node->flags & MD_NodeFlag_HasParenLeft && - parse.node->flags & MD_NodeFlag_HasBracketRight); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(0, 100]"), 0); + TestResult(parse.node->flags & NodeFlag_HasParenLeft && + parse.node->flags & NodeFlag_HasBracketRight); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100)"), 0); - TestResult(parse.node->flags & MD_NodeFlag_HasBracketLeft && - parse.node->flags & MD_NodeFlag_HasParenRight); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100)"), 0); + TestResult(parse.node->flags & NodeFlag_HasBracketLeft && + parse.node->flags & NodeFlag_HasParenRight); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100]"), 0); - TestResult(parse.node->flags & MD_NodeFlag_HasBracketLeft && - parse.node->flags & MD_NodeFlag_HasBracketRight); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("[0, 100]"), 0); + TestResult(parse.node->flags & NodeFlag_HasBracketLeft && + parse.node->flags & NodeFlag_HasBracketRight); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("{0, 100}"), 0); - TestResult(parse.node->flags & MD_NodeFlag_HasBraceLeft && - parse.node->flags & MD_NodeFlag_HasBraceRight); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("{0, 100}"), 0); + TestResult(parse.node->flags & NodeFlag_HasBraceLeft && + parse.node->flags & NodeFlag_HasBraceRight); } } Test("Node Separator Flags") { { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a, b)"), 0); - TestResult(parse.node->first_child->flags & MD_NodeFlag_IsBeforeComma); - TestResult(parse.node->first_child->next->flags & MD_NodeFlag_IsAfterComma); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a, b)"), 0); + TestResult(parse.node->first_child->flags & NodeFlag_IsBeforeComma); + TestResult(parse.node->first_child->next->flags & NodeFlag_IsAfterComma); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a; b)"), 0); - TestResult(parse.node->first_child->flags & MD_NodeFlag_IsBeforeSemicolon); - TestResult(parse.node->first_child->next->flags & MD_NodeFlag_IsAfterSemicolon); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a; b)"), 0); + TestResult(parse.node->first_child->flags & NodeFlag_IsBeforeSemicolon); + TestResult(parse.node->first_child->next->flags & NodeFlag_IsAfterSemicolon); } } Test("Node Text 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 & - MD_NodeFlag_Numeric); + NodeFlag_Numeric); 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); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringDoubleQuote); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"foo\""), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringDoubleQuote); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'foo'"), 0); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringSingleQuote); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'foo'"), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringSingleQuote); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`foo`"), 0); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringTick); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("`foo`"), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringTick); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"foo\"\"\""), 0); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringDoubleQuote && - parse.node->flags & MD_NodeFlag_StringTriplet); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("\"\"\"foo\"\"\""), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringDoubleQuote && + parse.node->flags & NodeFlag_StringTriplet); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''foo'''"), 0); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringSingleQuote && - parse.node->flags & MD_NodeFlag_StringTriplet); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("'''foo'''"), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringSingleQuote && + parse.node->flags & NodeFlag_StringTriplet); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("```foo```"), 0); - TestResult(parse.node->flags & MD_NodeFlag_StringLiteral && - parse.node->flags & MD_NodeFlag_StringTick && - parse.node->flags & MD_NodeFlag_StringTriplet); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("```foo```"), 0); + TestResult(parse.node->flags & NodeFlag_StringLiteral && + parse.node->flags & NodeFlag_StringTick && + parse.node->flags & NodeFlag_StringTriplet); } } @@ -320,12 +320,12 @@ int main(void) Test("Enum Strings") { - TestResult(MD_S8Match(MD_StringFromNodeKind(MD_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)); + TestResult(MD_S8Match(MD_StringFromNodeKind(NodeKind_Main), MD_S8Lit("Main"), 0)); MD_String8List list = MD_StringListFromNodeFlags(arena, - MD_NodeFlag_StringLiteral | - MD_NodeFlag_HasParenLeft | - MD_NodeFlag_IsBeforeSemicolon); + NodeFlag_StringLiteral | + NodeFlag_HasParenLeft | + NodeFlag_IsBeforeSemicolon); MD_b32 match = 1; for(MD_String8Node *node = list.first; node; node = node->next) { @@ -346,18 +346,18 @@ int main(void) // NOTE(rjf): Pre-Comments: { { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("/*foobar*/ (a b c)"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("/*foobar*/ (a b c)"), 0); + TestResult(parse.node->kind == NodeKind_Main && MD_S8Match(parse.node->prev_comment, MD_S8Lit("foobar"), 0)); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n(a b c)"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n(a b c)"), 0); + TestResult(parse.node->kind == NodeKind_Main && 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); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("// foobar\n\n(a b c)"), 0); + TestResult(parse.node->kind == NodeKind_Main && MD_S8Match(parse.node->prev_comment, MD_S8Lit(""), 0)); } } @@ -365,23 +365,23 @@ int main(void) // NOTE(rjf): Post-Comments: { { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) /*foobar*/"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) /*foobar*/"), 0); + TestResult(parse.node->kind == NodeKind_Main && MD_S8Match(parse.node->next_comment, MD_S8Lit("foobar"), 0)); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) // foobar"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c) // foobar"), 0); + TestResult(parse.node->kind == NodeKind_Main && MD_S8Match(parse.node->next_comment, MD_S8Lit(" foobar"), 0)); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n// foobar"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n// foobar"), 0); + TestResult(parse.node->kind == NodeKind_Main && MD_S8Match(parse.node->next_comment, MD_S8Lit(""), 0)); } { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n\n// foobar"), 0); - TestResult(parse.node->kind == MD_NodeKind_Main && + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("(a b c)\n\n// foobar"), 0); + TestResult(parse.node->kind == NodeKind_Main && 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) { - 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; { @@ -428,8 +428,8 @@ int main(void) } { - MD_ParseResult parse = MD_ParseWholeFile(arena, MD_S8Lit("__does_not_exist.mdesk")); - TestResult(parse.node->kind == MD_NodeKind_File && parse.errors.first != 0); + ParseResult parse = MD_ParseWholeFile(arena, MD_S8Lit("__does_not_exist.mdesk")); + TestResult(parse.node->kind == NodeKind_File && parse.errors.first != 0); } } @@ -487,10 +487,10 @@ int main(void) 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) { - MD_ParseResult result = MD_ParseOneNode(arena, samples[i], 0); + ParseResult result = MD_ParseOneNode(arena, samples[i], 0); nodes[i] = result.node; } @@ -512,41 +512,41 @@ int main(void) 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)); } { - 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)); } { - 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)); } { - 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)); } { - 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)); } { - 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)); } { - 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)); } { - 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)); } { - 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)); } } @@ -555,10 +555,10 @@ int main(void) { { - MD_ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{x y z; a b c}"), 0); - MD_Node *node = parse.node; - MD_Node *group_first = node->first_child; - MD_Node *group_opl = MD_FirstNodeWithFlags(group_first->next, MD_NodeFlag_IsAfterSemicolon); + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{x y z; a b c}"), 0); + Node *node = parse.node; + Node *group_first = node->first_child; + 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->next->string, MD_S8Lit("y"), 0)); @@ -566,7 +566,7 @@ int main(void) TestResult(group_opl == group_first->next->next->next); 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->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); - MD_Node *node = parse.node; - MD_Node *group_first = 0; - MD_Node *group_opl = 0; + ParseResult parse = MD_ParseOneNode(arena, MD_S8Lit("foo:{a b c , d e f , g h i}"), 0); + Node *node = parse.node; + Node *group_first = 0; + Node *group_opl = 0; 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->next->string, MD_S8Lit("b"), 0)); TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("c"), 0)); TestResult(group_opl == group_first->next->next->next); 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->next->string, MD_S8Lit("e"), 0)); TestResult(MD_S8Match(group_first->next->next->string, MD_S8Lit("f"), 0)); TestResult(group_opl == group_first->next->next->next); 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->next->string, MD_S8Lit("h"), 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_Node *tree = MD_MakeNode(arena, MD_NodeKind_File, file_name, text, 0); - MD_Node *a = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("a")); - MD_Node *b = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("b")); - MD_Node *c = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("c")); - MD_Node *d = MakeTestNode(MD_NodeKind_Main, MD_S8Lit("d")); + Node *tree = MD_MakeNode(arena, NodeKind_File, file_name, text, 0); + Node *a = MakeTestNode(NodeKind_Main, MD_S8Lit("a")); + Node *b = MakeTestNode(NodeKind_Main, MD_S8Lit("b")); + Node *c = MakeTestNode(NodeKind_Main, MD_S8Lit("c")); + Node *d = MakeTestNode(NodeKind_Main, MD_S8Lit("d")); MD_PushChild(a, b); MD_PushChild(b, c); MD_PushChild(tree, a); 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(MD_NodeDeepMatch(tree, result.node, 0)); } @@ -629,7 +629,7 @@ int main(void) // finished unscoped set { 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.node->first_child == result.node->last_child); } @@ -637,31 +637,31 @@ int main(void) // unfinished unscoped set { 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); } { 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); } { 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); } // labeled scoped set in unscoped set { 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(MD_ChildCountFromNode(result.node) == 1); TestResult(MD_ChildCountFromNode(result.node->first_child) == 2); } { 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(MD_ChildCountFromNode(result.node) == 2); TestResult(MD_ChildCountFromNode(result.node->first_child) == 1); @@ -670,7 +670,7 @@ int main(void) // scoped set is not unscoped { 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.node->first_child != result.node->last_child); } @@ -681,19 +681,19 @@ int main(void) 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)); } { - 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)); } { - 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)); } { - 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)); } } @@ -704,27 +704,27 @@ int main(void) // 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); } // 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); } // 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); } { - 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); } { - 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); } } @@ -743,10 +743,10 @@ int main(void) MD_String8 *string = test_strings; 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) && (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; 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) && (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_ParseResult result = MD_ParseWholeString(arena, file_name, + ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo: '(' )")); TestResult(result.errors.first != 0); } { - MD_ParseResult result = MD_ParseWholeString(arena, file_name, + ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo ':' ( )")); TestResult(result.errors.first == 0); 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")); TestResult(result.errors.first == 0); TestResult(MD_ChildCountFromNode(result.node) == 3); } { - MD_ParseResult result = MD_ParseWholeString(arena, file_name, + ParseResult result = MD_ParseWholeString(arena, file_name, MD_S8Lit("foo: '(' ')'")); TestResult(result.errors.first == 0); 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 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_DebugDumpFromNode(arena, &actual_strings, parse.node, 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 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_DebugDumpFromNode(arena, &actual_strings, parse.node, 0, MD_S8Lit(" "), MD_GenerateFlags_Tree); @@ -831,7 +831,7 @@ int main(void) { MD_String8 code = MD_S8Lit("// foo\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_DebugDumpFromNode(arena, &actual_strings, parse.node, 0, MD_S8Lit(" "), 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_ParseResult parse1 = MD_ParseOneNode(arena, code, 0); + ParseResult parse1 = MD_ParseOneNode(arena, code, 0); MD_String8List reconstruction_strs = {0}; MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); 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)); } { 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_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); 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)); } { @@ -868,11 +868,11 @@ int main(void) " e;\n" " f,\n" "}\n"); - MD_ParseResult parse1 = MD_ParseOneNode(arena, code, 0); + ParseResult parse1 = MD_ParseOneNode(arena, code, 0); MD_String8List reconstruction_strs = {0}; MD_ReconstructionFromNode(arena, &reconstruction_strs, parse1.node, 0, MD_S8Lit(" ")); 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)); } }