mirror of
https://github.com/Ed94/metadesk.git
synced 2026-06-12 23:51:37 -07:00
more progress
This commit is contained in:
+158
-185
@@ -8,89 +8,79 @@
|
||||
////////////////////////////////
|
||||
//~ rjf: Message Type Functions
|
||||
|
||||
internal void
|
||||
md_msg_list_push(Arena *arena, MsgList *msgs, Node *node, MsgKind kind, String8 string)
|
||||
void
|
||||
msg_list_push(Arena* arena, MsgList* msgs, Node* node, MsgKind kind, String8 string)
|
||||
{
|
||||
Msg*
|
||||
msg = push_array(arena, Msg, 1);
|
||||
msg->node = node;
|
||||
msg->kind = kind;
|
||||
msg->string = string;
|
||||
Msg*
|
||||
msg = push_array(arena, Msg, 1);
|
||||
msg->node = node;
|
||||
msg->kind = kind;
|
||||
msg->string = string;
|
||||
|
||||
SLLQueuePush(msgs->first, msgs->last, msg);
|
||||
sll_queue_push(msgs->first, msgs->last, msg);
|
||||
|
||||
msgs->count += 1;
|
||||
msgs->worst_message_kind = Max(kind, msgs->worst_message_kind);
|
||||
msgs->count += 1;
|
||||
msgs->worst_message_kind = Max(kind, msgs->worst_message_kind);
|
||||
}
|
||||
|
||||
internal void
|
||||
md_msg_list_pushf(Arena *arena, MsgList *msgs, Node *node, MsgKind kind, char *fmt, ...)
|
||||
void
|
||||
msg_list_concat_in_place(MsgList* dst, MsgList* to_push)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
String8 string = push_str8fv(arena, fmt, args);
|
||||
md_msg_list_push(arena, msgs, node, kind, string);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
internal void
|
||||
md_msg_list_concat_in_place(MsgList *dst, MsgList *to_push)
|
||||
{
|
||||
if(to_push->first != 0)
|
||||
{
|
||||
if(dst->last)
|
||||
{
|
||||
dst->last->next = to_push->first;
|
||||
dst->last = to_push->last;
|
||||
dst->count += to_push->count;
|
||||
dst->worst_message_kind = Max(dst->worst_message_kind, to_push->worst_message_kind);
|
||||
}
|
||||
else
|
||||
{
|
||||
MemoryCopyStruct(dst, to_push);
|
||||
}
|
||||
}
|
||||
MemoryZeroStruct(to_push);
|
||||
if (to_push->first != 0)
|
||||
{
|
||||
if (dst->last) {
|
||||
dst->last->next = to_push->first;
|
||||
dst->last = to_push->last;
|
||||
dst->count += to_push->count;
|
||||
dst->worst_message_kind = md_max(dst->worst_message_kind, to_push->worst_message_kind);
|
||||
}
|
||||
else {
|
||||
memory_copy_struct(dst, to_push);
|
||||
}
|
||||
}
|
||||
memory_zero_struct(to_push);
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Token Type Functions
|
||||
|
||||
internal Token
|
||||
md_token_make(Rng1U64 range, TokenFlags flags)
|
||||
String8
|
||||
content_string_from_token_flags_str8(TokenFlags flags, String8 string)
|
||||
{
|
||||
Token token = {range, flags};
|
||||
return token;
|
||||
U64 num_chop = 0;
|
||||
U64 num_skip = 0;
|
||||
{
|
||||
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);
|
||||
result = str8_skip(result, num_skip);
|
||||
return result;
|
||||
}
|
||||
|
||||
internal B32
|
||||
md_token_match(Token a, Token b)
|
||||
String8List
|
||||
string_list_from_token_flags(Arena* arena, TokenFlags flags)
|
||||
{
|
||||
return (a.range.min == b.range.min &&
|
||||
a.range.max == b.range.max &&
|
||||
a.flags == b.flags);
|
||||
}
|
||||
|
||||
internal String8List
|
||||
md_string_list_from_token_flags(Arena *arena, TokenFlags flags)
|
||||
{
|
||||
String8List strs = {0};
|
||||
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;
|
||||
String8List strs = {0};
|
||||
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, TokenChunkList *list, U64 cap, Token token)
|
||||
token_chunk_list_push(Arena* arena, TokenChunkList* list, U64 cap, Token token)
|
||||
{
|
||||
TokenChunkNode *node = list->last;
|
||||
if(node == 0 || node->count >= node->cap)
|
||||
@@ -98,44 +88,27 @@ md_token_chunk_list_push(Arena *arena, TokenChunkList *list, U64 cap, Token toke
|
||||
node = push_array(arena, TokenChunkNode, 1);
|
||||
node->cap = cap;
|
||||
node->v = push_array_no_zero(arena, Token, cap);
|
||||
SLLQueuePush(list->first, list->last, node);
|
||||
sll_queue_push(list->first, list->last, node);
|
||||
list->chunk_count += 1;
|
||||
}
|
||||
MemoryCopyStruct(&node->v[node->count], &token);
|
||||
memory_copy_struct(&node->v[node->count], &token);
|
||||
node->count += 1;
|
||||
list->total_token_count += 1;
|
||||
}
|
||||
|
||||
internal TokenArray
|
||||
md_token_array_from_chunk_list(Arena *arena, TokenChunkList *chunks)
|
||||
token_array_from_chunk_list(Arena* arena, TokenChunkList* chunks)
|
||||
{
|
||||
TokenArray result = {0};
|
||||
result.count = chunks->total_token_count;
|
||||
result.v = push_array_no_zero(arena, Token, result.count);
|
||||
U64 write_idx = 0;
|
||||
for(TokenChunkNode *n = chunks->first; n != 0; n = n->next)
|
||||
{
|
||||
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(TokenFlags flags, String8 string)
|
||||
{
|
||||
U64 num_chop = 0;
|
||||
U64 num_skip = 0;
|
||||
{
|
||||
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);
|
||||
result = str8_skip(result, num_skip);
|
||||
return result;
|
||||
TokenArray result = {0};
|
||||
result.count = chunks->total_token_count;
|
||||
result.v = push_array_no_zero(arena, Token, result.count);
|
||||
U64 write_idx = 0;
|
||||
for(TokenChunkNode *n = chunks->first; n != 0; n = n->next)
|
||||
{
|
||||
memory_copy(result.v + write_idx, n->v, size_of(Token) * n->count);
|
||||
write_idx += n->count;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
@@ -144,7 +117,7 @@ md_content_string_from_token_flags_str8(TokenFlags flags, String8 string)
|
||||
//- rjf: flag conversions
|
||||
|
||||
internal NodeFlags
|
||||
md_node_flags_from_token_flags(TokenFlags flags)
|
||||
node_flags_from_token_flags(TokenFlags flags)
|
||||
{
|
||||
NodeFlags result = 0;
|
||||
result |= NodeFlag_Identifier*!!(flags&TokenFlag_Identifier);
|
||||
@@ -161,7 +134,7 @@ md_node_flags_from_token_flags(TokenFlags flags)
|
||||
//- rjf: nil
|
||||
|
||||
internal B32
|
||||
md_node_is_nil(Node *node)
|
||||
node_is_nil(Node *node)
|
||||
{
|
||||
return (node == 0 || node == nil_node() || node->kind == NodeKind_Nil);
|
||||
}
|
||||
@@ -173,14 +146,14 @@ node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off)
|
||||
{
|
||||
NodeRec rec = {0};
|
||||
rec.next = nil_node();
|
||||
if(!md_node_is_nil(*member_from_offset(Node **, node, child_off)))
|
||||
if(!node_is_nil(*member_from_offset(Node **, node, child_off)))
|
||||
{
|
||||
rec.next = *member_from_offset(Node **, node, child_off);
|
||||
rec.push_count = 1;
|
||||
}
|
||||
else for(Node *p = node; !md_node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1)
|
||||
else for(Node *p = node; !node_is_nil(p) && p != subtree_root; p = p->parent, rec.pop_count += 1)
|
||||
{
|
||||
if(!md_node_is_nil(*member_from_offset(Node **, p, sib_off)))
|
||||
if(!node_is_nil(*member_from_offset(Node **, p, sib_off)))
|
||||
{
|
||||
rec.next = *member_from_offset(Node **, p, sib_off);
|
||||
break;
|
||||
@@ -192,7 +165,7 @@ node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off)
|
||||
//- rjf: tree building
|
||||
|
||||
internal Node *
|
||||
md_push_node(Arena *arena, NodeKind kind, NodeFlags flags, String8 string, String8 raw_string, U64 src_offset)
|
||||
push_node(Arena *arena, NodeKind kind, NodeFlags flags, String8 string, String8 raw_string, U64 src_offset)
|
||||
{
|
||||
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();
|
||||
@@ -205,14 +178,14 @@ md_push_node(Arena *arena, NodeKind kind, NodeFlags flags, String8 string, Strin
|
||||
}
|
||||
|
||||
internal void
|
||||
md_node_insert_child(Node *parent, Node *prev_child, Node *node)
|
||||
node_insert_child(Node *parent, Node *prev_child, Node *node)
|
||||
{
|
||||
node->parent = parent;
|
||||
dll_insert_npz(nil_node(), parent->first, parent->last, prev_child, node, next, prev);
|
||||
}
|
||||
|
||||
internal void
|
||||
md_node_insert_tag(Node *parent, Node *prev_child, Node *node)
|
||||
node_insert_tag(Node *parent, Node *prev_child, Node *node)
|
||||
{
|
||||
node->kind = NodeKind_Tag;
|
||||
node->parent = parent;
|
||||
@@ -220,14 +193,14 @@ md_node_insert_tag(Node *parent, Node *prev_child, Node *node)
|
||||
}
|
||||
|
||||
internal void
|
||||
md_node_push_child(Node *parent, Node *node)
|
||||
node_push_child(Node *parent, Node *node)
|
||||
{
|
||||
node->parent = parent;
|
||||
dll_push_back_npz(nil_node(), parent->first, parent->last, node, next, prev);
|
||||
}
|
||||
|
||||
internal void
|
||||
md_node_push_tag(Node *parent, Node *node)
|
||||
node_push_tag(Node *parent, Node *node)
|
||||
{
|
||||
node->kind = NodeKind_Tag;
|
||||
node->parent = parent;
|
||||
@@ -235,10 +208,10 @@ md_node_push_tag(Node *parent, Node *node)
|
||||
}
|
||||
|
||||
internal void
|
||||
md_unhook(Node *node)
|
||||
unhook(Node *node)
|
||||
{
|
||||
Node *parent = node->parent;
|
||||
if(!md_node_is_nil(parent))
|
||||
if(!node_is_nil(parent))
|
||||
{
|
||||
if(node->kind == NodeKind_Tag)
|
||||
{
|
||||
@@ -255,10 +228,10 @@ md_unhook(Node *node)
|
||||
//- rjf: tree introspection
|
||||
|
||||
internal Node *
|
||||
md_node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFlags flags)
|
||||
node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFlags flags)
|
||||
{
|
||||
Node *result = nil_node();
|
||||
for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next)
|
||||
for(Node *n = first; !node_is_nil(n) && n != opl; n = n->next)
|
||||
{
|
||||
if(str8_match(n->string, string, flags))
|
||||
{
|
||||
@@ -270,11 +243,11 @@ md_node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFla
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_node_from_chain_index(Node *first, Node *opl, U64 index)
|
||||
node_from_chain_index(Node *first, Node *opl, U64 index)
|
||||
{
|
||||
Node *result = nil_node();
|
||||
S64 idx = 0;
|
||||
for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next, idx += 1)
|
||||
for(Node *n = first; !node_is_nil(n) && n != opl; n = n->next, idx += 1)
|
||||
{
|
||||
if(index == idx)
|
||||
{
|
||||
@@ -286,10 +259,10 @@ md_node_from_chain_index(Node *first, Node *opl, U64 index)
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_node_from_chain_flags(Node *first, Node *opl, NodeFlags flags)
|
||||
node_from_chain_flags(Node *first, Node *opl, NodeFlags flags)
|
||||
{
|
||||
Node *result = nil_node();
|
||||
for(Node *n = first; !md_node_is_nil(n) && n != opl; n = n->next)
|
||||
for(Node *n = first; !node_is_nil(n) && n != opl; n = n->next)
|
||||
{
|
||||
if(n->flags & flags)
|
||||
{
|
||||
@@ -301,10 +274,10 @@ md_node_from_chain_flags(Node *first, Node *opl, NodeFlags flags)
|
||||
}
|
||||
|
||||
internal U64
|
||||
md_index_from_node(Node *node)
|
||||
index_from_node(Node *node)
|
||||
{
|
||||
U64 index = 0;
|
||||
for(Node *n = node->prev; !md_node_is_nil(n); n = n->prev)
|
||||
for(Node *n = node->prev; !node_is_nil(n); n = n->prev)
|
||||
{
|
||||
index += 1;
|
||||
}
|
||||
@@ -312,10 +285,10 @@ md_index_from_node(Node *node)
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_root_from_node(Node *node)
|
||||
root_from_node(Node *node)
|
||||
{
|
||||
Node *result = node;
|
||||
for(Node *p = node->parent; (p->kind == NodeKind_Main || p->kind == NodeKind_Tag) && !md_node_is_nil(p); p = p->parent)
|
||||
for(Node *p = node->parent; (p->kind == NodeKind_Main || p->kind == NodeKind_Tag) && !node_is_nil(p); p = p->parent)
|
||||
{
|
||||
result = p;
|
||||
}
|
||||
@@ -323,61 +296,61 @@ md_root_from_node(Node *node)
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_child_from_string(Node *node, String8 child_string, StringMatchFlags flags)
|
||||
child_from_string(Node *node, String8 child_string, StringMatchFlags flags)
|
||||
{
|
||||
return md_node_from_chain_string(node->first, nil_node(), child_string, flags);
|
||||
return node_from_chain_string(node->first, nil_node(), child_string, flags);
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_tag_from_string(Node *node, String8 tag_string, StringMatchFlags flags)
|
||||
tag_from_string(Node *node, String8 tag_string, StringMatchFlags flags)
|
||||
{
|
||||
return md_node_from_chain_string(node->first_tag, nil_node(), tag_string, flags);
|
||||
return node_from_chain_string(node->first_tag, nil_node(), tag_string, flags);
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_child_from_index(Node *node, U64 index)
|
||||
child_from_index(Node *node, U64 index)
|
||||
{
|
||||
return md_node_from_chain_index(node->first, nil_node(), index);
|
||||
return node_from_chain_index(node->first, nil_node(), index);
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_tag_from_index(Node *node, U64 index)
|
||||
tag_from_index(Node *node, U64 index)
|
||||
{
|
||||
return md_node_from_chain_index(node->first_tag, nil_node(), index);
|
||||
return node_from_chain_index(node->first_tag, nil_node(), index);
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_tag_arg_from_index(Node *node, String8 tag_string, StringMatchFlags flags, U64 index)
|
||||
tag_arg_from_index(Node *node, String8 tag_string, StringMatchFlags flags, U64 index)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, tag_string, flags);
|
||||
return md_child_from_index(tag, index);
|
||||
Node *tag = tag_from_string(node, tag_string, flags);
|
||||
return child_from_index(tag, index);
|
||||
}
|
||||
|
||||
internal Node *
|
||||
md_tag_arg_from_string(Node *node, String8 tag_string, StringMatchFlags tag_str_flags, String8 arg_string, StringMatchFlags arg_str_flags)
|
||||
tag_arg_from_string(Node *node, String8 tag_string, StringMatchFlags tag_str_flags, String8 arg_string, StringMatchFlags 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);
|
||||
Node *tag = tag_from_string(node, tag_string, tag_str_flags);
|
||||
Node *arg = child_from_string(tag, arg_string, arg_str_flags);
|
||||
return arg;
|
||||
}
|
||||
|
||||
internal B32
|
||||
md_node_has_child(Node *node, String8 string, StringMatchFlags flags)
|
||||
node_has_child(Node *node, String8 string, StringMatchFlags flags)
|
||||
{
|
||||
return !md_node_is_nil(md_child_from_string(node, string, flags));
|
||||
return !node_is_nil(child_from_string(node, string, flags));
|
||||
}
|
||||
|
||||
internal B32
|
||||
md_node_has_tag(Node *node, String8 string, StringMatchFlags flags)
|
||||
node_has_tag(Node *node, String8 string, StringMatchFlags flags)
|
||||
{
|
||||
return !md_node_is_nil(md_tag_from_string(node, string, flags));
|
||||
return !node_is_nil(tag_from_string(node, string, flags));
|
||||
}
|
||||
|
||||
internal U64
|
||||
md_child_count_from_node(Node *node)
|
||||
child_count_from_node(Node *node)
|
||||
{
|
||||
U64 result = 0;
|
||||
for(Node *child = node->first; !md_node_is_nil(child); child = child->next)
|
||||
for(Node *child = node->first; !node_is_nil(child); child = child->next)
|
||||
{
|
||||
result += 1;
|
||||
}
|
||||
@@ -385,10 +358,10 @@ md_child_count_from_node(Node *node)
|
||||
}
|
||||
|
||||
internal U64
|
||||
md_tag_count_from_node(Node *node)
|
||||
tag_count_from_node(Node *node)
|
||||
{
|
||||
U64 result = 0;
|
||||
for(Node *child = node->first_tag; !md_node_is_nil(child); child = child->next)
|
||||
for(Node *child = node->first_tag; !node_is_nil(child); child = child->next)
|
||||
{
|
||||
result += 1;
|
||||
}
|
||||
@@ -396,7 +369,7 @@ md_tag_count_from_node(Node *node)
|
||||
}
|
||||
|
||||
internal String8
|
||||
md_string_from_children(Arena *arena, Node *root)
|
||||
string_from_children(Arena *arena, Node *root)
|
||||
{
|
||||
TempArena scratch = scratch_begin(&arena, 1);
|
||||
String8List strs = {0};
|
||||
@@ -416,7 +389,7 @@ md_string_from_children(Arena *arena, Node *root)
|
||||
//- rjf: tree comparison
|
||||
|
||||
internal B32
|
||||
md_node_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
node_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
{
|
||||
B32 result = 0;
|
||||
if(a->kind == b->kind && str8_match(a->string, b->string, flags))
|
||||
@@ -429,16 +402,16 @@ md_node_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
if(result && a->kind != NodeKind_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);
|
||||
!node_is_nil(a_tag) || !node_is_nil(b_tag);
|
||||
a_tag = a_tag->next, b_tag = b_tag->next)
|
||||
{
|
||||
if(md_node_match(a_tag, b_tag, flags))
|
||||
if(node_match(a_tag, b_tag, flags))
|
||||
{
|
||||
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);
|
||||
!node_is_nil(a_tag_arg) || !node_is_nil(b_tag_arg);
|
||||
a_tag_arg = a_tag_arg->next, b_tag_arg = b_tag_arg->next)
|
||||
{
|
||||
if(!md_tree_match(a_tag_arg, b_tag_arg, flags))
|
||||
if(!tree_match(a_tag_arg, b_tag_arg, flags))
|
||||
{
|
||||
result = 0;
|
||||
goto end;
|
||||
@@ -458,16 +431,16 @@ md_node_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
}
|
||||
|
||||
internal B32
|
||||
md_tree_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
tree_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
{
|
||||
B32 result = md_node_match(a, b, flags);
|
||||
B32 result = node_match(a, b, flags);
|
||||
if(result)
|
||||
{
|
||||
for(Node *a_child = a->first, *b_child = b->first;
|
||||
!md_node_is_nil(a_child) || !md_node_is_nil(b_child);
|
||||
!node_is_nil(a_child) || !node_is_nil(b_child);
|
||||
a_child = a_child->next, b_child = b_child->next)
|
||||
{
|
||||
if(!md_tree_match(a_child, b_child, flags))
|
||||
if(!tree_match(a_child, b_child, flags))
|
||||
{
|
||||
result = 0;
|
||||
goto end;
|
||||
@@ -481,13 +454,13 @@ md_tree_match(Node *a, Node *b, StringMatchFlags flags)
|
||||
//- rjf: tree duplication
|
||||
|
||||
internal Node *
|
||||
md_tree_copy(Arena *arena, Node *src_root)
|
||||
tree_copy(Arena *arena, Node *src_root)
|
||||
{
|
||||
Node *dst_root = nil_node();
|
||||
Node *dst_parent = dst_root;
|
||||
{
|
||||
NodeRec rec = {0};
|
||||
for(Node *src = src_root; !md_node_is_nil(src); src = rec.next)
|
||||
for(Node *src = src_root; !node_is_nil(src); src = rec.next)
|
||||
{
|
||||
Node *dst = push_array(arena, Node, 1);
|
||||
dst->first = dst->last = dst->parent = dst->next = dst->prev = nil_node();
|
||||
@@ -524,7 +497,7 @@ md_tree_copy(Arena *arena, Node *src_root)
|
||||
//~ rjf: Text -> Tokens Functions
|
||||
|
||||
internal TokenizeResult
|
||||
md_tokenize_from_text(Arena *arena, String8 text)
|
||||
tokenize_from_text(Arena *arena, String8 text)
|
||||
{
|
||||
TempArena scratch = scratch_begin(&arena, 1);
|
||||
TokenChunkList tokens = {0};
|
||||
@@ -788,30 +761,30 @@ md_tokenize_from_text(Arena *arena, String8 text)
|
||||
if(token_flags != 0 && token_start != 0 && token_opl > token_start)
|
||||
{
|
||||
Token token = {{(U64)(token_start - byte_first), (U64)(token_opl - byte_first)}, token_flags};
|
||||
md_token_chunk_list_push(scratch.arena, &tokens, 4096, token);
|
||||
token_chunk_list_push(scratch.arena, &tokens, 4096, token);
|
||||
}
|
||||
|
||||
//- rjf: push errors on unterminated comments
|
||||
if(token_flags & TokenFlag_BrokenComment)
|
||||
{
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first);
|
||||
Node *error = 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, MsgKind_Error, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Error, error_string);
|
||||
}
|
||||
|
||||
//- rjf: push errors on unterminated strings
|
||||
if(token_flags & TokenFlag_BrokenStringLiteral)
|
||||
{
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, str8_lit(""), str8_lit(""), token_start - byte_first);
|
||||
Node *error = 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, MsgKind_Error, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Error, error_string);
|
||||
}
|
||||
}
|
||||
|
||||
//- rjf: bake, fill & return
|
||||
TokenizeResult result = {0};
|
||||
{
|
||||
result.tokens = md_token_array_from_chunk_list(arena, &tokens);
|
||||
result.tokens = token_array_from_chunk_list(arena, &tokens);
|
||||
result.msgs = msgs;
|
||||
}
|
||||
scratch_end(scratch);
|
||||
@@ -822,13 +795,13 @@ md_tokenize_from_text(Arena *arena, String8 text)
|
||||
//~ rjf: Tokens -> Tree Functions
|
||||
|
||||
internal ParseResult
|
||||
md_parse_from_text_tokens(Arena *arena, String8 filename, String8 text, TokenArray tokens)
|
||||
parse_from_text_tokens(Arena *arena, String8 filename, String8 text, TokenArray tokens)
|
||||
{
|
||||
TempArena scratch = scratch_begin(&arena, 1);
|
||||
|
||||
//- rjf: set up outputs
|
||||
MsgList msgs = {0};
|
||||
Node *root = md_push_node(arena, NodeKind_File, 0, filename, text, 0);
|
||||
Node *root = push_node(arena, NodeKind_File, 0, filename, text, 0);
|
||||
|
||||
//- rjf: set up parse rule stack
|
||||
typedef enum MD_ParseWorkKind
|
||||
@@ -922,7 +895,7 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
str8_match(token_string, str8_lit(";"), 0)))
|
||||
{
|
||||
Node *parent = work_top->parent;
|
||||
if(!md_node_is_nil(parent->last))
|
||||
if(!node_is_nil(parent->last))
|
||||
{
|
||||
parent->last->flags |= NodeFlag_IsBeforeComma*!!str8_match(token_string, str8_lit(","), 0);
|
||||
parent->last->flags |= NodeFlag_IsBeforeSemicolon*!!str8_match(token_string, str8_lit(";"), 0);
|
||||
@@ -949,9 +922,9 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
str8_match(token_string, str8_lit("\\"), 0) ||
|
||||
str8_match(token_string, str8_lit(":"), 0)))
|
||||
{
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min);
|
||||
Node *error = 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, MsgKind_Error, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Error, error_string);
|
||||
token += 1;
|
||||
goto end_consume;
|
||||
}
|
||||
@@ -963,17 +936,17 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
if(token+1 >= tokens_opl ||
|
||||
!(token[1].flags & TokenGroup_Label))
|
||||
{
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min);
|
||||
Node *error = 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, MsgKind_Error, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Error, error_string);
|
||||
token += 1;
|
||||
goto end_consume;
|
||||
}
|
||||
else
|
||||
{
|
||||
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);
|
||||
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);
|
||||
String8 tag_name = content_string_from_token_flags_str8(token[1].flags, tag_name_raw);
|
||||
Node *node = push_node(arena, NodeKind_Tag, 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))
|
||||
{
|
||||
@@ -993,18 +966,18 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
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);
|
||||
NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags;
|
||||
String8 node_string = content_string_from_token_flags_str8(token->flags, node_string_raw);
|
||||
NodeFlags flags = node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags;
|
||||
work_top->gathered_node_flags = 0;
|
||||
Node *node = md_push_node(arena, NodeKind_Main, flags, node_string, node_string_raw, token[0].range.min);
|
||||
Node *node = 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(Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next)
|
||||
for(Node *tag = work_top->first_gathered_tag; !node_is_nil(tag); tag = tag->next)
|
||||
{
|
||||
tag->parent = node;
|
||||
}
|
||||
work_top->first_gathered_tag = work_top->last_gathered_tag = nil_node();
|
||||
md_node_push_child(work_top->parent, node);
|
||||
node_push_child(work_top->parent, node);
|
||||
MD_ParseWorkPush(MD_ParseWorkKind_NodeOptionalFollowUp, node);
|
||||
token += 1;
|
||||
goto end_consume;
|
||||
@@ -1016,20 +989,20 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
str8_match(token_string, str8_lit("["), 0) ||
|
||||
str8_match(token_string, str8_lit("("), 0)))
|
||||
{
|
||||
NodeFlags flags = md_node_flags_from_token_flags(token->flags)|work_top->gathered_node_flags;
|
||||
NodeFlags flags = 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;
|
||||
Node *node = md_push_node(arena, NodeKind_Main, flags, str8_lit(""), str8_lit(""), token[0].range.min);
|
||||
Node *node = 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(Node *tag = work_top->first_gathered_tag; !md_node_is_nil(tag); tag = tag->next)
|
||||
for(Node *tag = work_top->first_gathered_tag; !node_is_nil(tag); tag = tag->next)
|
||||
{
|
||||
tag->parent = node;
|
||||
}
|
||||
work_top->first_gathered_tag = work_top->last_gathered_tag = nil_node();
|
||||
md_node_push_child(work_top->parent, node);
|
||||
node_push_child(work_top->parent, node);
|
||||
MD_ParseWorkPush(MD_ParseWorkKind_Main, node);
|
||||
token += 1;
|
||||
goto end_consume;
|
||||
@@ -1081,9 +1054,9 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
if(work_top->counted_newlines >= 2)
|
||||
{
|
||||
Node *node = work_top->parent;
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min);
|
||||
Node *error = 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, MsgKind_Warning, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Warning, error_string);
|
||||
MD_ParseWorkPop();
|
||||
}
|
||||
else
|
||||
@@ -1122,9 +1095,9 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
|
||||
//- rjf: no consumption -> unexpected token! we don't know what to do with this.
|
||||
{
|
||||
Node *error = md_push_node(arena, NodeKind_ErrorMarker, 0, token_string, token_string, token->range.min);
|
||||
Node *error = 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, MsgKind_Error, error_string);
|
||||
msg_list_push(arena, &msgs, error, MsgKind_Error, error_string);
|
||||
token += 1;
|
||||
}
|
||||
|
||||
@@ -1143,11 +1116,11 @@ if(work_top == 0) {work_top = &broken_work;}\
|
||||
//~ rjf: Bundled Text -> Tree Functions
|
||||
|
||||
internal ParseResult
|
||||
md_parse_from_text(Arena *arena, String8 filename, String8 text)
|
||||
parse_from_text(Arena *arena, String8 filename, String8 text)
|
||||
{
|
||||
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);
|
||||
TokenizeResult tokenize = tokenize_from_text(scratch.arena, text);
|
||||
ParseResult parse = parse_from_text_tokens(arena, filename, text, tokenize.tokens);
|
||||
scratch_end(scratch);
|
||||
return parse;
|
||||
}
|
||||
@@ -1156,13 +1129,13 @@ md_parse_from_text(Arena *arena, String8 filename, String8 text)
|
||||
//~ rjf: Tree -> Text Functions
|
||||
|
||||
internal String8List
|
||||
md_debug_string_list_from_tree(Arena *arena, Node *root)
|
||||
debug_string_list_from_tree(Arena *arena, Node *root)
|
||||
{
|
||||
String8List strings = {0};
|
||||
{
|
||||
char *indentation = " ";
|
||||
S32 depth = 0;
|
||||
for(Node *node = root, *next = nil_node(); !md_node_is_nil(node); node = next)
|
||||
for(Node *node = root, *next = nil_node(); !node_is_nil(node); node = next)
|
||||
{
|
||||
// rjf: get next recursion
|
||||
NodeRec rec = node_rec_depth_first_pre(node, root);
|
||||
|
||||
+74
-43
@@ -21,7 +21,7 @@ typedef enum MsgKind
|
||||
MsgKind;
|
||||
|
||||
typedef struct Node Node;
|
||||
typedef struct Msg Msg;
|
||||
typedef struct Msg Msg;
|
||||
struct Msg
|
||||
{
|
||||
Msg* next;
|
||||
@@ -241,32 +241,59 @@ nil_node()
|
||||
////////////////////////////////
|
||||
//~ rjf: Message Type Functions
|
||||
|
||||
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, ...);
|
||||
MD_API void msg_list_push (Arena* arena, MsgList* msgs, Node* node, MsgKind kind, String8 string);
|
||||
void 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);
|
||||
MD_API void msg_list_concat_in_place(MsgList* dst, MsgList* to_push);
|
||||
|
||||
inline void
|
||||
msg_list_pushf(Arena* arena, MsgList* msgs, Node* node, MsgKind kind, char* fmt, ...) {
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
String8 string = push_str8fv(arena, fmt, args);
|
||||
msg_list_push(arena, msgs, node, kind, string);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Token Type Functions
|
||||
|
||||
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);
|
||||
Token token_make (Rng1U64 range, TokenFlags flags);
|
||||
B32 token_match(Token a, Token b);
|
||||
|
||||
MD_API String8 content_string_from_token_flags_str8(TokenFlags flags, String8 string);
|
||||
|
||||
MD_API String8List string_list_from_token_flags(Arena* arena, TokenFlags flags);
|
||||
MD_API void token_chunk_list_push (Arena* arena, TokenChunkList* list, U64 cap, Token token);
|
||||
MD_API TokenArray token_array_from_chunk_list (Arena* arena, TokenChunkList* chunks);
|
||||
|
||||
inline Token
|
||||
token_make(Rng1U64 range, TokenFlags flags) {
|
||||
Token token = { range, flags };
|
||||
return token;
|
||||
}
|
||||
|
||||
inline B32
|
||||
token_match(Token a, Token b) {
|
||||
return (a.range.min == b.range.min &&
|
||||
a.range.max == b.range.max &&
|
||||
a.flags == b.flags );
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Node Type Functions
|
||||
|
||||
//- rjf: flag conversions
|
||||
internal NodeFlags md_node_flags_from_token_flags(TokenFlags flags);
|
||||
|
||||
internal NodeFlags node_flags_from_token_flags(TokenFlags flags);
|
||||
|
||||
//- rjf: nil
|
||||
internal B32 md_node_is_nil(Node *node);
|
||||
|
||||
internal B32 node_is_nil(Node *node);
|
||||
|
||||
//- rjf: iteration
|
||||
#define MD_EachNode(it, first) (Node *it = first; !md_node_is_nil(it); it = it->next)
|
||||
|
||||
#define MD_EachNode(it, first) (Node *it = first; !node_is_nil(it); it = it->next)
|
||||
|
||||
internal NodeRec node_rec_depth_first(Node *node, Node *subtree_root, U64 child_off, U64 sib_off);
|
||||
|
||||
@@ -274,58 +301,62 @@ internal NodeRec node_rec_depth_first(Node *node, Node *subtree_root, U64 child_
|
||||
#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 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);
|
||||
|
||||
internal Node* push_node (Arena *arena, NodeKind kind, NodeFlags flags, String8 string, String8 raw_string, U64 src_offset);
|
||||
internal void node_insert_tag (Node *parent, Node *prev_child, Node *node);
|
||||
internal void node_insert_child(Node *parent, Node *prev_child, Node *node);
|
||||
internal void node_push_child (Node *parent, Node *node);
|
||||
internal void node_push_tag (Node *parent, Node *node);
|
||||
internal void unhook (Node *node);
|
||||
|
||||
//- rjf: tree introspection
|
||||
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);
|
||||
internal Node* node_from_chain_string(Node *first, Node *opl, String8 string, StringMatchFlags flags);
|
||||
internal Node* node_from_chain_index (Node *first, Node *opl, U64 index);
|
||||
internal Node* node_from_chain_flags (Node *first, Node *opl, NodeFlags flags);
|
||||
internal U64 index_from_node (Node *node);
|
||||
internal Node* root_from_node (Node *node);
|
||||
internal Node* child_from_string (Node *node, String8 child_string, StringMatchFlags flags);
|
||||
internal Node* tag_from_string (Node *node, String8 tag_string, StringMatchFlags flags);
|
||||
internal Node* child_from_index (Node *node, U64 index);
|
||||
internal Node* tag_from_index (Node *node, U64 index);
|
||||
internal Node* tag_arg_from_index (Node *node, String8 tag_string, StringMatchFlags flags, U64 index);
|
||||
internal Node* tag_arg_from_string (Node *node, String8 tag_string, StringMatchFlags tag_str_flags, String8 arg_string, StringMatchFlags arg_str_flags);
|
||||
internal B32 node_has_child (Node *node, String8 string, StringMatchFlags flags);
|
||||
internal B32 node_has_tag (Node *node, String8 string, StringMatchFlags flags);
|
||||
internal U64 child_count_from_node (Node *node);
|
||||
internal U64 tag_count_from_node (Node *node);
|
||||
|
||||
internal String8 string_from_children (Arena *arena, Node *root);
|
||||
|
||||
//- rjf: tree comparison
|
||||
internal B32 md_tree_match(Node *a, Node *b, StringMatchFlags flags);
|
||||
internal B32 md_node_match(Node *a, Node *b, StringMatchFlags flags);
|
||||
|
||||
internal B32 tree_match(Node *a, Node *b, StringMatchFlags flags);
|
||||
internal B32 node_match(Node *a, Node *b, StringMatchFlags flags);
|
||||
|
||||
//- rjf: tree duplication
|
||||
internal Node* md_tree_copy(Arena *arena, Node *src_root);
|
||||
|
||||
internal Node* 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 TokenizeResult md_tokenize_from_text(Arena *arena, String8 text);
|
||||
internal TokenizeResult tokenize_from_text(Arena *arena, String8 text);
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Tokens -> Tree Functions
|
||||
|
||||
internal ParseResult md_parse_from_text_tokens(Arena *arena, String8 filename, String8 text, TokenArray tokens);
|
||||
internal ParseResult parse_from_text_tokens(Arena *arena, String8 filename, String8 text, TokenArray tokens);
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Bundled Text -> Tree Functions
|
||||
|
||||
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)
|
||||
internal ParseResult parse_from_text(Arena *arena, String8 filename, String8 text);
|
||||
#define tree_from_string(arena, string) (parse_from_text((arena), str8_zero(), (string)).root)
|
||||
|
||||
////////////////////////////////
|
||||
//~ rjf: Tree -> Text Functions
|
||||
|
||||
internal String8List md_debug_string_list_from_tree(Arena *arena, Node *root);
|
||||
internal String8List debug_string_list_from_tree(Arena *arena, Node *root);
|
||||
|
||||
+24
-24
@@ -372,7 +372,7 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl,
|
||||
|
||||
//- rjf: consume prefix operators
|
||||
MG_StrExpr *leafmost_op = &mg_str_expr_nil;
|
||||
for(;it != opl && !md_node_is_nil(it);)
|
||||
for(;it != opl && !node_is_nil(it);)
|
||||
{
|
||||
MG_StrExprOp found_op = MG_StrExprOp_Null;
|
||||
for(MG_StrExprOp op = (MG_StrExprOp)(MG_StrExprOp_Null+1);
|
||||
@@ -408,16 +408,16 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl,
|
||||
{
|
||||
MG_StrExpr *atom = &mg_str_expr_nil;
|
||||
if(it->flags & (NodeFlag_Identifier|NodeFlag_Numeric|NodeFlag_StringLiteral) &&
|
||||
md_node_is_nil(it->first))
|
||||
node_is_nil(it->first))
|
||||
{
|
||||
atom = mg_push_str_expr(arena, MG_StrExprOp_Null, it);
|
||||
it = it->next;
|
||||
}
|
||||
else if(!md_node_is_nil(it->first))
|
||||
else if(!node_is_nil(it->first))
|
||||
{
|
||||
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);
|
||||
msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
|
||||
it = it->next;
|
||||
}
|
||||
if(leafmost_op != &mg_str_expr_nil)
|
||||
@@ -431,7 +431,7 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl,
|
||||
}
|
||||
|
||||
//- rjf: parse binary operator extensions at this precedence level
|
||||
for(;it != opl && !md_node_is_nil(it);)
|
||||
for(;it != opl && !node_is_nil(it);)
|
||||
{
|
||||
// rjf: find binary op kind of `it`
|
||||
MG_StrExprOp found_op = MG_StrExprOp_Null;
|
||||
@@ -468,10 +468,10 @@ mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, Node *first, Node *opl,
|
||||
// rjf: parse right hand side of binary operator
|
||||
MG_StrExprParseResult subparse = mg_str_expr_parse_from_first_opl__min_prec(arena, it, opl, mg_str_expr_op_precedence_table[found_op]+1);
|
||||
parse.root->right = subparse.root;
|
||||
md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
|
||||
msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
|
||||
if(subparse.root == &mg_str_expr_nil)
|
||||
{
|
||||
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]);
|
||||
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;
|
||||
}
|
||||
@@ -515,7 +515,7 @@ mg_node_array_make(Arena *arena, U64 count)
|
||||
internal MG_NodeArray
|
||||
mg_child_array_from_node(Arena *arena, Node *node)
|
||||
{
|
||||
MG_NodeArray children = mg_node_array_make(arena, md_child_count_from_node(node));
|
||||
MG_NodeArray children = mg_node_array_make(arena, child_count_from_node(node));
|
||||
U64 idx = 0;
|
||||
for MD_EachNode(child, node->first)
|
||||
{
|
||||
@@ -531,11 +531,11 @@ mg_node_grid_make_from_node(Arena *arena, Node *root)
|
||||
MG_NodeGrid grid = {0};
|
||||
|
||||
// rjf: determine dimensions
|
||||
U64 row_count = md_child_count_from_node(root);
|
||||
U64 row_count = child_count_from_node(root);
|
||||
U64 column_count = 0;
|
||||
for MD_EachNode(row, root->first)
|
||||
{
|
||||
U64 cell_count_this_row = md_child_count_from_node(row);
|
||||
U64 cell_count_this_row = child_count_from_node(row);
|
||||
column_count = Max(column_count, cell_count_this_row);
|
||||
}
|
||||
|
||||
@@ -619,20 +619,20 @@ internal MG_ColumnDescArray
|
||||
mg_column_desc_array_from_tag(Arena *arena, Node *tag)
|
||||
{
|
||||
MG_ColumnDescArray result = {0};
|
||||
result.count = md_child_count_from_node(tag);
|
||||
result.count = child_count_from_node(tag);
|
||||
result.v = push_array(arena, MG_ColumnDesc, result.count);
|
||||
U64 idx = 0;
|
||||
for MD_EachNode(hdr, tag->first)
|
||||
{
|
||||
result.v[idx].name = push_str8_copy(arena, hdr->string);
|
||||
result.v[idx].kind = MG_ColumnKind_DirectCell;
|
||||
if(md_node_has_tag(hdr, str8_lit("tag_check"), 0))
|
||||
if(node_has_tag(hdr, str8_lit("tag_check"), 0))
|
||||
{
|
||||
result.v[idx].kind = MG_ColumnKind_CheckForTag;
|
||||
}
|
||||
if(md_node_has_tag(hdr, str8_lit("tag_child"), 0))
|
||||
if(node_has_tag(hdr, str8_lit("tag_child"), 0))
|
||||
{
|
||||
String8 tag_name = md_tag_from_string(hdr, str8_lit("tag_child"), 0)->first->string;
|
||||
String8 tag_name = tag_from_string(hdr, str8_lit("tag_child"), 0)->first->string;
|
||||
result.v[idx].kind = MG_ColumnKind_TagChild;
|
||||
result.v[idx].tag_name = tag_name;
|
||||
}
|
||||
@@ -686,21 +686,21 @@ mg_string_from_row_desc_idx(Node *row_parent, MG_ColumnDescArray descs, U64 idx)
|
||||
cell_idx -= 1;
|
||||
}
|
||||
}
|
||||
Node *node = md_child_from_index(row_parent, cell_idx);
|
||||
Node *node = child_from_index(row_parent, cell_idx);
|
||||
result = node->string;
|
||||
}break;
|
||||
|
||||
case MG_ColumnKind_CheckForTag:
|
||||
{
|
||||
String8 tag_name = desc->name;
|
||||
Node *tag = md_tag_from_string(row_parent, tag_name, 0);
|
||||
result = md_node_is_nil(tag) ? str8_lit("0") : str8_lit("1");
|
||||
Node *tag = tag_from_string(row_parent, tag_name, 0);
|
||||
result = node_is_nil(tag) ? str8_lit("0") : str8_lit("1");
|
||||
}break;
|
||||
|
||||
case MG_ColumnKind_TagChild:
|
||||
{
|
||||
String8 tag_name = desc->tag_name;
|
||||
Node *tag = md_tag_from_string(row_parent, tag_name, 0);
|
||||
Node *tag = tag_from_string(row_parent, tag_name, 0);
|
||||
result = tag->first->string;
|
||||
}break;
|
||||
}
|
||||
@@ -815,7 +815,7 @@ mg_eval_table_expand_expr__string(Arena *arena, MG_StrExpr *expr, MG_TableExpand
|
||||
{
|
||||
S64 numeric_eval = mg_eval_table_expand_expr__numeric(expr, info);
|
||||
String8 numeric_eval_stringized = {0};
|
||||
if(md_node_has_tag(md_root_from_node(expr->node), str8_lit("hex"), 0))
|
||||
if(node_has_tag(root_from_node(expr->node), str8_lit("hex"), 0))
|
||||
{
|
||||
numeric_eval_stringized = push_str8f(arena, "0x%I64x", numeric_eval);
|
||||
}
|
||||
@@ -999,8 +999,8 @@ mg_loop_table_column_expansion(Arena *arena, String8 strexpr, MG_TableExpandInfo
|
||||
}
|
||||
}
|
||||
String8 expr_string = str8_substr(string, expr_range);
|
||||
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);
|
||||
TokenizeResult expr_tokenize = tokenize_from_text(scratch.arena, expr_string);
|
||||
ParseResult expr_base_parse = 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;
|
||||
@@ -1026,7 +1026,7 @@ mg_string_list_from_table_gen(Arena *arena, MG_Map grid_name_map, MG_Map grid_co
|
||||
{
|
||||
String8List result = {0};
|
||||
Temp scratch = scratch_begin(&arena, 1);
|
||||
if(md_node_is_nil(gen->first) && gen->string.size != 0)
|
||||
if(node_is_nil(gen->first) && gen->string.size != 0)
|
||||
{
|
||||
str8_list_push(arena, &result, gen->string);
|
||||
str8_list_push(arena, &result, str8_lit("\n"));
|
||||
@@ -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
|
||||
Node *table_name_node = md_child_from_index(tag, 0);
|
||||
Node *expand_label_node = md_child_from_index(tag, 1);
|
||||
Node *table_name_node = child_from_index(tag, 0);
|
||||
Node *expand_label_node = child_from_index(tag, 1);
|
||||
String8 table_name = table_name_node->string;
|
||||
String8 expand_label = expand_label_node->string;
|
||||
|
||||
|
||||
+33
-33
@@ -92,8 +92,8 @@ entry_point(CmdLine *cmdline)
|
||||
if(str8_match(file_ext, str8_lit("mdesk"), 0))
|
||||
{
|
||||
String8 data = os_data_from_file_path(mg_arena, file_path);
|
||||
TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data);
|
||||
ParseResult parse = md_parse_from_text_tokens(mg_arena, file_path, data, tokenize.tokens);
|
||||
TokenizeResult tokenize = tokenize_from_text(mg_arena, data);
|
||||
ParseResult parse = 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);
|
||||
@@ -131,8 +131,8 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *table_tag = md_tag_from_string(node, str8_lit("table"), 0);
|
||||
if(!md_node_is_nil(table_tag))
|
||||
Node *table_tag = tag_from_string(node, str8_lit("table"), 0);
|
||||
if(!node_is_nil(table_tag))
|
||||
{
|
||||
MG_NodeGrid *table = push_array(mg_arena, MG_NodeGrid, 1);
|
||||
MG_ColumnDescArray *col_descs = push_array(mg_arena, MG_ColumnDescArray, 1);
|
||||
@@ -156,26 +156,26 @@ entry_point(CmdLine *cmdline)
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
if(md_node_has_tag(node, str8_lit("option"), 0))
|
||||
if(node_has_tag(node, str8_lit("option"), 0))
|
||||
{
|
||||
if(str8_match(node->string, str8_lit("library"), 0))
|
||||
{
|
||||
layer->is_library = 1;
|
||||
}
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("gen_folder"), 0))
|
||||
if(node_has_tag(node, str8_lit("gen_folder"), 0))
|
||||
{
|
||||
layer->gen_folder_name = node->string;
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("h_name"), 0))
|
||||
if(node_has_tag(node, str8_lit("h_name"), 0))
|
||||
{
|
||||
layer->h_name_override = node->string;
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("c_name"), 0))
|
||||
if(node_has_tag(node, str8_lit("c_name"), 0))
|
||||
{
|
||||
layer->c_name_override = node->string;
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("h_header"), 0))
|
||||
if(node_has_tag(node, str8_lit("h_header"), 0))
|
||||
{
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
|
||||
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
|
||||
@@ -184,7 +184,7 @@ entry_point(CmdLine *cmdline)
|
||||
str8_list_push(mg_arena, &layer->h_header, str8_lit("\n"));
|
||||
}
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("h_footer"), 0))
|
||||
if(node_has_tag(node, str8_lit("h_footer"), 0))
|
||||
{
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
|
||||
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
|
||||
@@ -193,7 +193,7 @@ entry_point(CmdLine *cmdline)
|
||||
str8_list_push(mg_arena, &layer->h_footer, str8_lit("\n"));
|
||||
}
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("c_header"), 0))
|
||||
if(node_has_tag(node, str8_lit("c_header"), 0))
|
||||
{
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
|
||||
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
|
||||
@@ -202,7 +202,7 @@ entry_point(CmdLine *cmdline)
|
||||
str8_list_push(mg_arena, &layer->c_header, str8_lit("\n"));
|
||||
}
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("c_footer"), 0))
|
||||
if(node_has_tag(node, str8_lit("c_footer"), 0))
|
||||
{
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
|
||||
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
|
||||
@@ -222,8 +222,8 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, str8_lit("enum"), 0);
|
||||
if(!md_node_is_nil(tag))
|
||||
Node *tag = tag_from_string(node, str8_lit("enum"), 0);
|
||||
if(!node_is_nil(tag))
|
||||
{
|
||||
String8 enum_name = node->string;
|
||||
String8 enum_member_prefix = enum_name;
|
||||
@@ -269,8 +269,8 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, str8_lit("xlist"), 0);
|
||||
if(!md_node_is_nil(tag))
|
||||
Node *tag = tag_from_string(node, str8_lit("xlist"), 0);
|
||||
if(!node_is_nil(tag))
|
||||
{
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
@@ -294,7 +294,7 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
if(md_node_has_tag(node, str8_lit("struct"), 0))
|
||||
if(node_has_tag(node, str8_lit("struct"), 0))
|
||||
{
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
@@ -319,14 +319,14 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, str8_lit("data"), 0);
|
||||
if(!md_node_is_nil(tag))
|
||||
Node *tag = tag_from_string(node, str8_lit("data"), 0);
|
||||
if(!node_is_nil(tag))
|
||||
{
|
||||
String8 element_type = tag->first->string;
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
|
||||
if(!md_node_has_tag(node, str8_lit("c_file"), 0))
|
||||
if(!node_has_tag(node, str8_lit("c_file"), 0))
|
||||
{
|
||||
str8_list_pushf(mg_arena, &layer->h_tables, "extern %S %S[%I64u];\n", element_type, node->string, gen_strings.node_count);
|
||||
}
|
||||
@@ -349,8 +349,8 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, str8_lit("enum2string_switch"), 0);
|
||||
if(!md_node_is_nil(tag))
|
||||
Node *tag = tag_from_string(node, str8_lit("enum2string_switch"), 0);
|
||||
if(!node_is_nil(tag))
|
||||
{
|
||||
String8 enum_type = tag->first->string;
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
@@ -382,12 +382,12 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
Node *tag = md_tag_from_string(node, str8_lit("gen"), 0);
|
||||
if(!md_node_is_nil(tag))
|
||||
Node *tag = tag_from_string(node, str8_lit("gen"), 0);
|
||||
if(!node_is_nil(tag))
|
||||
{
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
B32 prefer_c_file = md_node_has_tag(node, str8_lit("c_file"), 0);
|
||||
B32 prefer_c_file = node_has_tag(node, str8_lit("c_file"), 0);
|
||||
String8List *out = prefer_c_file ? &layer->c_catchall : &layer->h_catchall;
|
||||
if(tag->first->string.size == 0){}
|
||||
else if(str8_match(tag->first->string, str8_lit("enums"), 0)) { out = &layer->enums; }
|
||||
@@ -414,7 +414,7 @@ entry_point(CmdLine *cmdline)
|
||||
Node *file = n->v.root;
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
if(md_node_has_tag(node, str8_lit("embed_string"), 0))
|
||||
if(node_has_tag(node, str8_lit("embed_string"), 0))
|
||||
{
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
@@ -423,7 +423,7 @@ entry_point(CmdLine *cmdline)
|
||||
str8_list_push (mg_arena, &layer->h_tables, embed_string);
|
||||
str8_list_pushf(mg_arena, &layer->h_tables, ");\n\n");
|
||||
}
|
||||
if(md_node_has_tag(node, str8_lit("embed_file"), 0))
|
||||
if(node_has_tag(node, str8_lit("embed_file"), 0))
|
||||
{
|
||||
String8 layer_key = mg_layer_key_from_path(file->string);
|
||||
MG_Layer *layer = mg_layer_from_key(layer_key);
|
||||
@@ -449,20 +449,20 @@ entry_point(CmdLine *cmdline)
|
||||
for MD_EachNode(node, file->first)
|
||||
{
|
||||
//- rjf: generate markdown page
|
||||
if(md_node_has_tag(node, str8_lit("markdown"), 0))
|
||||
if(node_has_tag(node, str8_lit("markdown"), 0))
|
||||
{
|
||||
String8List md_strs = {0};
|
||||
for(Node *piece = node->first; !md_node_is_nil(piece); piece = piece->next)
|
||||
for(Node *piece = node->first; !node_is_nil(piece); piece = piece->next)
|
||||
{
|
||||
if(md_node_has_tag(piece, str8_lit("title"), 0))
|
||||
if(node_has_tag(piece, str8_lit("title"), 0))
|
||||
{
|
||||
str8_list_pushf(mg_arena, &md_strs, "# %S\n\n", piece->string);
|
||||
}
|
||||
if(md_node_has_tag(piece, str8_lit("subtitle"), 0))
|
||||
if(node_has_tag(piece, str8_lit("subtitle"), 0))
|
||||
{
|
||||
str8_list_pushf(mg_arena, &md_strs, "## %S\n\n", piece->string);
|
||||
}
|
||||
if(md_node_has_tag(piece, str8_lit("p"), 0))
|
||||
if(node_has_tag(piece, str8_lit("p"), 0))
|
||||
{
|
||||
String8 paragraph_text = piece->string;
|
||||
String8List paragraph_lines = mg_wrapped_lines_from_string(mg_arena, paragraph_text, 80, 80, 0);
|
||||
@@ -473,7 +473,7 @@ entry_point(CmdLine *cmdline)
|
||||
}
|
||||
str8_list_push(mg_arena, &md_strs, str8_lit("\n"));
|
||||
}
|
||||
if(md_node_has_tag(piece, str8_lit("unordered_list"), 0))
|
||||
if(node_has_tag(piece, str8_lit("unordered_list"), 0))
|
||||
{
|
||||
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), piece);
|
||||
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
|
||||
|
||||
@@ -144,7 +144,7 @@ gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant)
|
||||
}
|
||||
|
||||
Node*
|
||||
gen_get_symbol_md_node_by_name(MD_String8 name)
|
||||
gen_get_symbol_node_by_name(MD_String8 name)
|
||||
{
|
||||
Node *result = MD_NilNode();
|
||||
MD_MapSlot *type_slot = MD_MapLookup(&type_map, MD_MapKeyStr(name));
|
||||
@@ -186,7 +186,7 @@ gen_duplicate_symbol_error(Node *new_node, Node *existing_node)
|
||||
void
|
||||
gen_check_and_do_duplicate_symbol_error(Node *new_node)
|
||||
{
|
||||
Node *existing = gen_get_symbol_md_node_by_name(new_node->string);
|
||||
Node *existing = gen_get_symbol_node_by_name(new_node->string);
|
||||
if (!MD_NodeIsNil(existing))
|
||||
{
|
||||
gen_duplicate_symbol_error(new_node, existing);
|
||||
|
||||
@@ -109,7 +109,7 @@ GEN_TypeEnumerant* gen_enumerant_from_name(GEN_TypeInfo *enum_type, MD_String8 n
|
||||
|
||||
GEN_MapCase* gen_map_case_from_enumerant(GEN_MapInfo *map, GEN_TypeEnumerant *enumerant);
|
||||
|
||||
Node* gen_get_symbol_md_node_by_name(MD_String8 name);
|
||||
Node* gen_get_symbol_node_by_name(MD_String8 name);
|
||||
|
||||
void gen_type_resolve_error(Node *reference);
|
||||
void gen_duplicate_symbol_error(Node *new_node, Node *existing_node);
|
||||
|
||||
Reference in New Issue
Block a user