diff --git a/samples/output_parse/examples/output/parsed_example.txt b/samples/output_parse/examples/output/parsed_example.txt index 1b911ee..723f878 100644 --- a/samples/output_parse/examples/output/parsed_example.txt +++ b/samples/output_parse/examples/output/parsed_example.txt @@ -1,32 +1,32 @@ Node { Kind: Label, - Flags: 00001100000100000000000000000000, - Flag Names: BraceLeft, BraceRight, Identifier, + Flags: 0000110000000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, String: foo, Whole String: foo, Tag: @struct Node { Kind: Label, - Flags: 11000001000100000000000000000000, - Flag Names: ParenLeft, ParenRight, BeforeComma, Identifier, + Flags: 1100000010000000000000010000000000000000000000000000000000000000, + Flag Names: ParenLeft, ParenRight, BeforeComma, String: x, Whole String: x, Node { Kind: Label, - Flags: 00110000000000000000000000000000, + Flags: 0011000000000000000000000000000000000000000000000000000000000000, Flag Names: BracketLeft, BracketRight, Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: MAX_PATH, Whole String: MAX_PATH, } } Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: char, Whole String: char, } @@ -35,36 +35,36 @@ Node { Node { Kind: Label, - Flags: 00001100000100000000000000000000, - Flag Names: BraceLeft, BraceRight, Identifier, + Flags: 0000110000000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, String: bar, Whole String: bar, Tag: @struct Tag: @test_tag Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: y, Whole String: y, Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: float, Whole String: float, } } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: z, Whole String: z, Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: i32, Whole String: i32, } diff --git a/samples/output_parse/examples/output/parsed_example2.txt b/samples/output_parse/examples/output/parsed_example2.txt index db69437..2b0e76b 100644 --- a/samples/output_parse/examples/output/parsed_example2.txt +++ b/samples/output_parse/examples/output/parsed_example2.txt @@ -1,138 +1,138 @@ Node { Kind: Label, - Flags: 00001100000100000000000000000000, - Flag Names: BraceLeft, BraceRight, Identifier, + Flags: 0000110000000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, String: a_set, Whole String: a_set, Tag: @sets Node { Kind: Label, - Flags: 00001101000100000000000000000000, - Flag Names: BraceLeft, BraceRight, BeforeComma, Identifier, + Flags: 0000110010000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, BeforeComma, String: named_set, Whole String: named_set, Node { Kind: Label, - Flags: 00000001001000000000000000000000, - Flag Names: BeforeComma, Numeric, + Flags: 0000000010000000000000100000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: 1, Whole String: 1, } Node { Kind: Label, - Flags: 00000001011000000000000000000000, - Flag Names: BeforeComma, AfterComma, Numeric, + Flags: 0000000011000000000000100000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: 3, Whole String: 3, } Node { Kind: Label, - Flags: 00000000011000000000000000000000, - Flag Names: AfterComma, Numeric, + Flags: 0000000001000000000000100000000000000000000000000000000000000000, + Flag Names: AfterComma, String: 7, Whole String: 7, } } Node { Kind: Label, - Flags: 00001101010000000000000000000000, + Flags: 0000110011000000000000000000000000000000000000000000000000000000, Flag Names: BraceLeft, BraceRight, BeforeComma, AfterComma, Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: not, Whole String: not, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: named, Whole String: named, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: set, Whole String: set, } } Node { Kind: Label, - Flags: 00001101010000000000000000000000, + Flags: 0000110011000000000000000000000000000000000000000000000000000000, Flag Names: BraceLeft, BraceRight, BeforeComma, AfterComma, Tag: @tag_with_params Tag Children{ Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: p1, Whole String: p1, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: p2, Whole String: p2, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: p3, Whole String: p3, } } Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: e1, Whole String: e1, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: e2, Whole String: e2, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: e3, Whole String: e3, } } Node { Kind: Label, - Flags: 00001101010000000000000000000000, + Flags: 0000110011000000000000000000000000000000000000000000000000000000, Flag Names: BraceLeft, BraceRight, BeforeComma, AfterComma, Tag: @tag_with_params Tag Children{ Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: p1, Whole String: p1, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: p2, Whole String: p2, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: p3, Whole String: p3, } @@ -141,44 +141,44 @@ Node { Tag Children{ Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: p, Whole String: p, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: pp, Whole String: pp, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: ppp, Whole String: ppp, } } Node { Kind: Label, - Flags: 00000001000100000000000000000000, - Flag Names: BeforeComma, Identifier, + Flags: 0000000010000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, String: e1, Whole String: e1, } Node { Kind: Label, - Flags: 00000001010100000000000000000000, - Flag Names: BeforeComma, AfterComma, Identifier, + Flags: 0000000011000000000000010000000000000000000000000000000000000000, + Flag Names: BeforeComma, AfterComma, String: e2, Whole String: e2, } Node { Kind: Label, - Flags: 00000000010100000000000000000000, - Flag Names: AfterComma, Identifier, + Flags: 0000000001000000000000010000000000000000000000000000000000000000, + Flag Names: AfterComma, String: e3, Whole String: e3, } @@ -187,8 +187,8 @@ Node { Node { Kind: Label, - Flags: 00001100000100000000000000000000, - Flag Names: BraceLeft, BraceRight, Identifier, + Flags: 0000110000000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, String: empty, Whole String: empty, Tag: @empty_set @@ -196,19 +196,19 @@ Node { Node { Kind: Label, - Flags: 00001100000000000000000000000000, + Flags: 0000110000000000000000000000000000000000000000000000000000000000, Flag Names: BraceLeft, BraceRight, Tag: @tagged_unnamed_set Node { Kind: Label, - Flags: 00001100000100000000000000000000, - Flag Names: BraceLeft, BraceRight, Identifier, + Flags: 0000110000000000000000010000000000000000000000000000000000000000, + Flag Names: BraceLeft, BraceRight, String: a_label, Whole String: a_label, Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: unnamed_set_element, Whole String: unnamed_set_element, } @@ -217,63 +217,63 @@ Node { Node { Kind: Label, - Flags: 00001100000000000000000000000000, + Flags: 0000110000000000000000000000000000000000000000000000000000000000, Flag Names: BraceLeft, BraceRight, Tag: @showcase_mixed_set_scoping Node { Kind: Label, - Flags: 10010001000000000000000000000000, + Flags: 1001000010000000000000000000000000000000000000000000000000000000, Flag Names: ParenLeft, BracketRight, BeforeComma, String: +, Whole String: +, Tag: @symbol_label Node { Kind: Label, - Flags: 00000000001000000000000000000000, - Flag Names: Numeric, + Flags: 0000000000000000000000100000000000000000000000000000000000000000, + Flag Names: , String: 1, Whole String: 1, } Node { Kind: Label, - Flags: 00000000001000000000000000000000, - Flag Names: Numeric, + Flags: 0000000000000000000000100000000000000000000000000000000000000000, + Flag Names: , String: 2, Whole String: 2, } Node { Kind: Label, - Flags: 00000000001000000000000000000000, - Flag Names: Numeric, + Flags: 0000000000000000000000100000000000000000000000000000000000000000, + Flag Names: , String: 3, Whole String: 3, } } Node { Kind: Label, - Flags: 01100001010000000000000000000000, + Flags: 0110000011000000000000000000000000000000000000000000000000000000, Flag Names: ParenRight, BracketLeft, BeforeComma, AfterComma, String: *, Whole String: *, Tag: @symbol_label Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: x, Whole String: x, } Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: y, Whole String: y, } Node { Kind: Label, - Flags: 00000000000100000000000000000000, - Flag Names: Identifier, + Flags: 0000000000000000000000010000000000000000000000000000000000000000, + Flag Names: , String: z, Whole String: z, } diff --git a/samples/output_parse/output_parse.c b/samples/output_parse/output_parse.c index 1e294a6..fc70f69 100644 --- a/samples/output_parse/output_parse.c +++ b/samples/output_parse/output_parse.c @@ -71,7 +71,7 @@ int main(int argument_count, char **arguments) for(MD_EachNode(root, first)) { - MD_String8 code_filename = MD_ChopExtension(MD_SkipFolder(root->filename)); + MD_String8 code_filename = MD_ChopExtension(MD_SkipFolder(root->string)); MD_String8 info_filename = MD_PushStringF("parsed_%.*s.txt", MD_StringExpand(code_filename)); printf("Parse Input -> Output: %.*s -> %.*s\n", MD_StringExpand(code_filename), MD_StringExpand(info_filename)); diff --git a/samples/static_site_generator/static_site_generator.c b/samples/static_site_generator/static_site_generator.c index c8de4f8..78161d1 100644 --- a/samples/static_site_generator/static_site_generator.c +++ b/samples/static_site_generator/static_site_generator.c @@ -127,7 +127,7 @@ int main(int argument_count, char **arguments) { PageInfo page_info = ParsePageInfo(root); - MD_String8 name_without_extension = MD_SkipFolder(MD_ChopExtension(root->filename)); + MD_String8 name_without_extension = MD_SkipFolder(MD_ChopExtension(root->string)); FILE *file = fopen(MD_PushStringF("%.*s.html", MD_StringExpand(name_without_extension)).str, "wb"); if(file) { @@ -379,8 +379,7 @@ GeneratePageContent(MD_Map *index_table, SiteInfo *site_info, PageInfo *page_inf //~ NOTE(rjf): Text blobs if(MD_NodeIsNil(node->first_child) && - (node->flags & MD_NodeFlag_StringLiteral || - node->flags & MD_NodeFlag_CharLiteral)) + (node->flags & MD_NodeFlag_StringLiteral)) { char *html_tag = "p"; char *style = "paragraph"; @@ -413,7 +412,8 @@ GeneratePageContent(MD_Map *index_table, SiteInfo *site_info, PageInfo *page_inf { if(strnode->string.str[i] == '@') { - MD_ParseResult parse = MD_ParseOneNode(node->filename, MD_StringSubstring(strnode->string, i, strnode->string.size)); + MD_Node *root = MD_RootFromNode(node); + MD_ParseResult parse = MD_ParseOneNode(root->string, MD_StringSubstring(strnode->string, i, strnode->string.size)); if(!MD_NodeIsNil(parse.node)) { if(MD_NodeHasTag(node, MD_S8Lit("i"))) @@ -521,9 +521,10 @@ GeneratePageContent(MD_Map *index_table, SiteInfo *site_info, PageInfo *page_inf if(slot->val) { MD_Node *node = slot->val; + MD_Node *root = MD_RootFromNode(node); PageInfo info = ParsePageInfo(node); - MD_String8 filename = node->filename; + MD_String8 filename = root->string; MD_String8 filename_no_ext = MD_ChopExtension(MD_SkipFolder(filename)); MD_String8 link = MD_PushStringF("%.*s.html", MD_StringExpand(filename_no_ext)); MD_String8 name = info.title->string; diff --git a/source/md.h b/source/md.h index ecfdef3..fc1bd6d 100644 --- a/source/md.h +++ b/source/md.h @@ -13,13 +13,6 @@ // [ ] Helpers for parsing NodeFlags, figuring out which nodes in a set are // separated by a semicolon, something like MD_SeekNodeWithFlags(node) -> node ? // [ ] Escaping characters from strings -// [x] Get rid of MD_JoinStringListWithSeparator, just have a separator argument on -// MD_JoinStringList. -// [x] MD_StringMap_Next, for iterating matching slots in an MD_Map, that all -// share the same key (important in the case of hash collisions) -// [x] Helper for making a reference for a node, e.g. MD_ReferenceFromNode -// [x] Organization decision for C generator helpers: splitting from md.h? file name? folder? -// [ ] Collapse down map types // [ ] Fill in more String -> Integer helpers // [ ] Memory Management Strategy // [ ] Gather map of current memory management situation @@ -299,6 +292,8 @@ MD_WordStyle; typedef enum MD_NodeKind { + // NOTE(rjf): Must be kept in sync with MD_StringFromNodeKind. + MD_NodeKind_Nil, MD_NodeKind_File, MD_NodeKind_List, @@ -309,34 +304,46 @@ typedef enum MD_NodeKind MD_NodeKind_Label, MD_NodeKind_Tag, MD_NodeKind_ErrorMarker, - MD_NodeKind_MAX, + MD_NodeKind_COUNT, } MD_NodeKind; -typedef MD_u32 MD_NodeFlags; +typedef MD_u64 MD_NodeFlags; +#define MD_NodeFlag_AfterFromBefore(f) ((f) << 1) enum { - MD_NodeFlag_ParenLeft = (1<<0), - MD_NodeFlag_ParenRight = (1<<1), - MD_NodeFlag_BracketLeft = (1<<2), - MD_NodeFlag_BracketRight = (1<<3), - MD_NodeFlag_BraceLeft = (1<<4), - MD_NodeFlag_BraceRight = (1<<5), + // NOTE(rjf): Must be kept in sync with MD_StringListFromNodeFlags. - MD_NodeFlag_BeforeSemicolon = (1<<6), - MD_NodeFlag_BeforeComma = (1<<7), + // NOTE(rjf): Because of MD_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_AfterSemicolon = (1<<8), - MD_NodeFlag_AfterComma = (1<<9), + MD_NodeFlag_ParenLeft = (1<<0), + MD_NodeFlag_ParenRight = (1<<1), + MD_NodeFlag_BracketLeft = (1<<2), + MD_NodeFlag_BracketRight = (1<<3), + MD_NodeFlag_BraceLeft = (1<<4), + MD_NodeFlag_BraceRight = (1<<5), - MD_NodeFlag_Numeric = (1<<10), - MD_NodeFlag_Identifier = (1<<11), - MD_NodeFlag_StringLiteral = (1<<12), - MD_NodeFlag_CharLiteral = (1<<13), + MD_NodeFlag_BeforeSemicolon = (1<<6), + MD_NodeFlag_AfterSemicolon = (1<<7), + + MD_NodeFlag_BeforeComma = (1<<8), + MD_NodeFlag_AfterComma = (1<<9), + + MD_NodeFlag_StringSingleQuote = (1<<10), + MD_NodeFlag_StringDoubleQuote = (1<<13), + MD_NodeFlag_StringTick = (1<<15), + MD_NodeFlag_StringTripletSingleQuote= (1<<16), + MD_NodeFlag_StringTripletDoubleQuote= (1<<18), + MD_NodeFlag_StringTripletTick = (1<<20), + + MD_NodeFlag_Numeric = (1<<22), + MD_NodeFlag_Identifier = (1<<23), + MD_NodeFlag_StringLiteral = (1<<24), }; -#define MD_NodeFlag_AfterFromBefore(f) ((f) << 2) - typedef struct MD_Node MD_Node; struct MD_Node { @@ -363,8 +370,6 @@ struct MD_Node MD_String8 comment_after; // Source code location information. - MD_String8 filename; - MD_u8 *file_contents; MD_u8 *at; // Reference. @@ -420,34 +425,15 @@ typedef enum MD_TokenKind MD_TokenKind_Nil, MD_TokenKind_RegularMin, - - // A group of characters that begins with an underscore or alphabetic character, - // and consists of numbers, alphabetic characters, or underscores after that. MD_TokenKind_Identifier, - - // A group of characters beginning with a numeric character or a '-', and then - // consisting of only numbers, alphabetic characters, or '.'s after that. MD_TokenKind_NumericLiteral, - - // A group of arbitrary characters, grouped together by a " character, OR by a - // """ symbol at the beginning and end of the group. String literals beginning with - // " are to only be specified on a single line, but """ strings can exist across - // many lines. - MD_TokenKind_StringLiteral, - - // A group of arbitrary characters, grouped together by a ' character at the beginning, - // and a ' character at the end. - MD_TokenKind_CharLiteral, - - // A group of symbolic characters, where symbolic characters means any of the following: - // ~!@#$%^&*()-+=[{]}:;<>,./?|\ - // - // Groups of multiple characters are only allowed in specific circumstances. Most of these - // are only 1 character long, but some groups are allowed: - // - // "<<", ">>", "<=", ">=", "+=", "-=", "*=", "/=", "::", ":=", "==", "&=", "|=", "->" + MD_TokenKind_StringLiteralSingleQuote, + MD_TokenKind_StringLiteralSingleQuoteTriplet, + MD_TokenKind_StringLiteralDoubleQuote, + MD_TokenKind_StringLiteralDoubleQuoteTriplet, + MD_TokenKind_StringLiteralTick, + MD_TokenKind_StringLiteralTickTriplet, MD_TokenKind_Symbol, - MD_TokenKind_RegularMax, MD_TokenKind_Comment, @@ -457,10 +443,10 @@ typedef enum MD_TokenKind MD_TokenKind_Newline, MD_TokenKind_WhitespaceMax, - MD_TokenKind_BadCharacter, // Character outside currently supported encodings + MD_TokenKind_BadCharacter, - MD_TokenKind_MAX, + MD_TokenKind_COUNT, } MD_TokenKind; @@ -625,6 +611,11 @@ MD_FUNCTION void MD_MemoryCopy(void *dst, void *src, MD_u64 size); MD_FUNCTION void* MD_AllocZero(MD_u64 size); #define MD_PushArray(T,c) (T*)MD_AllocZero(sizeof(T)*(c)) +// NOTE(rjf): Right now, both calls just automatically zero their memory, +// but I'm explicitly splitting this out to ensure that we don't accidentally +// assume that we have zeroed memory incorrectly in the future (when our +// allocation approach changes). +#define MD_PushArrayZero(T,c) (T*)MD_AllocZero(sizeof(T)*(c)) //~ Characters MD_FUNCTION MD_b32 MD_CharIsAlpha(MD_u8 c); @@ -710,6 +701,8 @@ MD_FUNCTION MD_MapSlot* MD_MapOverwrite(MD_Map *map, MD_MapKey key, void *val); //~ Parsing +MD_FUNCTION MD_NodeFlags MD_NodeFlagsFromTokenKind(MD_TokenKind kind); + MD_FUNCTION MD_b32 MD_TokenKindIsWhitespace(MD_TokenKind kind); MD_FUNCTION MD_b32 MD_TokenKindIsComment(MD_TokenKind kind); MD_FUNCTION MD_b32 MD_TokenKindIsRegular(MD_TokenKind kind); @@ -737,15 +730,14 @@ MD_FUNCTION MD_ParseResult MD_ParseWholeString(MD_String8 filename, MD_String8 c MD_FUNCTION MD_ParseResult MD_ParseWholeFile(MD_String8 filename); //~ Location Conversion -MD_FUNCTION MD_CodeLoc MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u8 *off); +MD_FUNCTION MD_CodeLoc MD_CodeLocFromFileBaseOff(MD_String8 filename, MD_u8 *base, MD_u8 *off); MD_FUNCTION MD_CodeLoc MD_CodeLocFromNode(MD_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_NodeKind kind, MD_String8 string, - MD_String8 whole_string, MD_String8 filename, - MD_u8 *file_contents, MD_u8 *at); + MD_String8 whole_string, MD_u8 *at); 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 MD_Node *MD_PushReference(MD_Node *list, MD_Node *target); @@ -757,6 +749,7 @@ MD_FUNCTION void MD_PushSibling(MD_Node **first, MD_Node **last, MD_Node *ne MD_FUNCTION MD_Node * MD_NodeFromString(MD_Node *first, MD_Node *last, MD_String8 string); MD_FUNCTION MD_Node * MD_NodeFromIndex(MD_Node *first, MD_Node *last, int n); MD_FUNCTION int MD_IndexFromNode(MD_Node *node); +MD_FUNCTION MD_Node * MD_RootFromNode(MD_Node *node); MD_FUNCTION MD_Node * MD_NextNodeSibling(MD_Node *last, MD_String8 string); MD_FUNCTION MD_Node * MD_ChildFromString(MD_Node *node, MD_String8 child_string); MD_FUNCTION MD_Node * MD_TagFromString(MD_Node *node, MD_String8 tag_string); diff --git a/source/md_c_helpers.c b/source/md_c_helpers.c index f7fcb29..14e0ed2 100644 --- a/source/md_c_helpers.c +++ b/source/md_c_helpers.c @@ -235,7 +235,6 @@ _MD_NodeParse_ConsumeLiteral(_MD_NodeParseCtx *ctx, MD_Node **out) { MD_b32 result = 0; if(ctx->at->flags & MD_NodeFlag_StringLiteral || - ctx->at->flags & MD_NodeFlag_CharLiteral || ctx->at->flags & MD_NodeFlag_Numeric) { result = 1; diff --git a/source/md_impl.c b/source/md_impl.c index 21ebcd3..7b16bab 100644 --- a/source/md_impl.c +++ b/source/md_impl.c @@ -4,13 +4,8 @@ #define MD_PRIVATE_FUNCTION_IMPL MD_FUNCTION_IMPL #define MD_UNTERMINATED_TOKEN_LEN_CAP 20 -//~ +//~ Nil Node Definition -// NOTE(allen): Review @rjf; Building in C++ -// While very latest version of C++ have designated initializers -// I would like to be able to build on more simple versions, so I -// ditched the designated initializers in favor of the extra work -// of maintaining order based initializers. static MD_Node _md_nil_node = { &_md_nil_node, // next @@ -27,26 +22,25 @@ static MD_Node _md_nil_node = 0xdeadffffffffffull, // string_hash MD_ZERO_STRUCT, // comment_before MD_ZERO_STRUCT, // comment_after - {(MD_u8*)"`NIL DD NODE`", 13}, // filename - 0, // file_contents 0, // at &_md_nil_node, // ref_target }; //~ Memory Operations -MD_PRIVATE_FUNCTION_IMPL void + +MD_FUNCTION_IMPL void MD_MemoryZero(void *memory, MD_u64 size) { memset(memory, 0, size); } -MD_PRIVATE_FUNCTION_IMPL void +MD_FUNCTION_IMPL void MD_MemoryCopy(void *dest, void *src, MD_u64 size) { memcpy(dest, src, size); } -MD_PRIVATE_FUNCTION_IMPL void * +MD_FUNCTION_IMPL void * MD_AllocZero(MD_u64 size) { #if !defined(MD_IMPL_Alloc) @@ -620,7 +614,7 @@ MD_FUNCTION_IMPL MD_String8 MD_StringFromNodeKind(MD_NodeKind kind) { // NOTE(rjf): Must be kept in sync with MD_NodeKind enum. - static char *cstrs[MD_NodeKind_MAX] = + static char *cstrs[MD_NodeKind_COUNT] = { "Nil", "File", @@ -647,15 +641,21 @@ MD_StringListFromNodeFlags(MD_NodeFlags flags) "BraceRight", "BeforeSemicolon", - "BeforeComma", - "AfterSemicolon", + + "BeforeComma", "AfterComma", + "StringSingleQuote", + "StringDoubleQuote", + "StringTick", + "StringTripletSingleQuote", + "StringTripletDoubleQuote", + "StringTripletTick", + "Numeric", "Identifier", "StringLiteral", - "CharLiteral", }; MD_String8List list = MD_ZERO_STRUCT; @@ -923,6 +923,7 @@ MD_FUNCTION_IMPL MD_u64 MD_HashPointer(void *p) { MD_u64 h = (MD_u64)p; + // TODO(rjf): Do we want our own equivalent of UINT64_C? h = (h ^ (h >> 30)) * UINT64_C(0xbf58476d1ce4e5b9); h = (h ^ (h >> 27)) * UINT64_C(0x94d049bb133111eb); h = h ^ (h >> 31); @@ -935,9 +936,7 @@ MD_MapMakeBucketCount(MD_u64 bucket_count){ // make most sense with a parameter MD_Map result = {0}; result.bucket_count = bucket_count; - // TODO(allen): push array zero - result.buckets = MD_PushArray(MD_MapBucket, bucket_count); - memset(result.buckets, 0, sizeof(*result.buckets)*bucket_count); + result.buckets = MD_PushArrayZero(MD_MapBucket, bucket_count); return(result); } @@ -1041,35 +1040,31 @@ MD_MapOverwrite(MD_Map *map, MD_MapKey key, void *val){ //~ Parsing -// TODO(allen): This helper only helps because `ctx` bundles two elements together -// that the "low level" MD_MakeNode treats as seperate. However they aren't very -// useful as seperate concepts. If we get the "handle of file" concept down to -// a single root node pointer, then this can be eliminated and users can get -// this effect by composing 'ctx->file_root' with 'MD_MakeNode'. -MD_PRIVATE_FUNCTION_IMPL MD_Node * -_MD_MakeNode_Ctx(MD_ParseCtx *ctx, MD_NodeKind kind, - MD_String8 string, MD_String8 outer, MD_u8 *at) -{ - return MD_MakeNode(kind, string, outer, ctx->filename, ctx->file_contents.str, at); -} - -MD_PRIVATE_FUNCTION_IMPL void _MD_ParseTagList(MD_ParseCtx *ctx, MD_Node **first_out, MD_Node **last_out); - -MD_PRIVATE_FUNCTION_IMPL MD_NodeFlags -_MD_NodeFlagsFromTokenKind(MD_TokenKind kind) +MD_FUNCTION_IMPL MD_NodeFlags +MD_NodeFlagsFromTokenKind(MD_TokenKind kind) { MD_NodeFlags result = 0; switch (kind){ - case MD_TokenKind_Identifier: result = MD_NodeFlag_Identifier; break; - case MD_TokenKind_NumericLiteral: result = MD_NodeFlag_Numeric; break; - case MD_TokenKind_StringLiteral: result = MD_NodeFlag_StringLiteral; break; - case MD_TokenKind_CharLiteral: result = MD_NodeFlag_CharLiteral; break; + case MD_TokenKind_Identifier: result = MD_NodeFlag_Identifier; break; + case MD_TokenKind_NumericLiteral: result = MD_NodeFlag_Numeric; break; + case MD_TokenKind_StringLiteralSingleQuote: result |= MD_NodeFlag_StringSingleQuote; goto string_lit; + case MD_TokenKind_StringLiteralDoubleQuote: result |= MD_NodeFlag_StringDoubleQuote; goto string_lit; + case MD_TokenKind_StringLiteralTick: result |= MD_NodeFlag_StringTick; goto string_lit; + case MD_TokenKind_StringLiteralSingleQuoteTriplet: result |= MD_NodeFlag_StringTripletSingleQuote; goto string_lit; + case MD_TokenKind_StringLiteralDoubleQuoteTriplet: result |= MD_NodeFlag_StringTripletDoubleQuote; goto string_lit; + case MD_TokenKind_StringLiteralTickTriplet: result |= MD_NodeFlag_StringTripletTick; goto string_lit; + string_lit:; + { + result |= MD_NodeFlag_StringLiteral; + }break; } return(result); } +MD_PRIVATE_FUNCTION_IMPL void _MD_ParseTagList(MD_ParseCtx *ctx, MD_Node **first_out, MD_Node **last_out); + MD_PRIVATE_FUNCTION_IMPL MD_b32 -_MD_StringLiteralIsBalanced(MD_Token token) +_MD_TokenBoundariesAreBalanced(MD_Token token) { MD_u64 front_len = token.string.str - token.outer_string.str; MD_u64 back_len = (token.outer_string.str + token.outer_string.size) - (token.string.str + token.string.size); @@ -1105,10 +1100,20 @@ _MD_ParseTagList(MD_ParseCtx *ctx, MD_Node **first_out, MD_Node **last_out) MD_Parse_Bump(ctx, next_token); MD_Token name = MD_ZERO_STRUCT; + + // TODO(rjf): Do we actually care to prohibit people from using + // something other than identifiers as their tag names? If so, + // why? If we can't come up with a good answer for it, then I + // think it makes sense to just allow anything that would've + // been a legal label string here too. + if(MD_Parse_RequireKind(ctx, MD_TokenKind_Identifier, &name)) { - MD_Node *tag = _MD_MakeNode_Ctx(ctx, MD_NodeKind_Tag, - name.string, name.outer_string, name.outer_string.str); + MD_Node *tag = MD_MakeNode(MD_NodeKind_Tag, name.string, name.outer_string, name.outer_string.str); + + // TODO(rjf): Don't we care if this is a MD_TokenKind_Symbol? + // for the sake of consistency with regular sets, I think it + // makes sense to disallow @foo"("), for example... MD_Token token = MD_Parse_PeekSkipSome(ctx, 0); if(MD_StringMatch(token.string, MD_S8Lit("("), 0)) { @@ -1139,7 +1144,7 @@ _MD_ParseTagList(MD_ParseCtx *ctx, MD_Node **first_out, MD_Node **last_out) MD_FUNCTION_IMPL MD_b32 MD_TokenKindIsWhitespace(MD_TokenKind kind) { - return kind > MD_TokenKind_WhitespaceMin && kind < MD_TokenKind_WhitespaceMax; + return MD_TokenKind_WhitespaceMin < kind && kind < MD_TokenKind_WhitespaceMax; } MD_FUNCTION_IMPL MD_b32 @@ -1151,7 +1156,7 @@ MD_TokenKindIsComment(MD_TokenKind kind) MD_FUNCTION_IMPL MD_b32 MD_TokenKindIsRegular(MD_TokenKind kind) { - return(kind > MD_TokenKind_RegularMin && kind < MD_TokenKind_RegularMax); + return(MD_TokenKind_RegularMin < kind && kind < MD_TokenKind_RegularMax); } MD_FUNCTION void @@ -1219,9 +1224,10 @@ MD_PushNodeErrorF(MD_ParseCtx *ctx, MD_Node *node, MD_MessageKind kind, char *fm MD_FUNCTION void MD_PushTokenError(MD_ParseCtx *ctx, MD_Token token, MD_MessageKind kind, MD_String8 str){ - MD_Node *stub = _MD_MakeNode_Ctx(ctx, MD_NodeKind_ErrorMarker, - token.string, token.outer_string, token.outer_string.str); + MD_Node *stub_file = MD_MakeNode(MD_NodeKind_ErrorMarker, ctx->file_contents, ctx->file_contents, ctx->file_contents.str); + MD_Node *stub = MD_MakeNode(MD_NodeKind_ErrorMarker, token.string, token.outer_string, token.outer_string.str); MD_PushNodeError(ctx, stub, kind, str); + MD_PushChild(stub_file, stub); } MD_FUNCTION void @@ -1358,11 +1364,6 @@ MD_Parse_LexNext(MD_ParseCtx *ctx) // NOTE(allen): Strings case '"': case '\'': - - // NOTE(rjf): "Bundle-of-tokens" strings (`stuff` or ```stuff```) - // In practice no different than a regular string, but provides an - // alternate syntax which will allow tools like 4coder to treat the - // contents as regular tokens. case '`': { // TODO(allen): proposal: @@ -1448,13 +1449,27 @@ MD_Parse_LexNext(MD_ParseCtx *ctx) } // set token kind - token.kind = MD_TokenKind_StringLiteral; - // TODO(allen): I don't see any place where this actually proves useful. - // I think it'd tidy things up to drop it. we already use this as a string - // in a lot of usages of metadesk. - if (d == '\'' && !is_triplet){ - token.kind = MD_TokenKind_CharLiteral; + if(is_triplet) + { + switch(d) + { + case '\'': token.kind = MD_TokenKind_StringLiteralSingleQuoteTriplet; break; + case '"': token.kind = MD_TokenKind_StringLiteralDoubleQuoteTriplet; break; + case '`': token.kind = MD_TokenKind_StringLiteralTickTriplet; break; + default: break; + } } + else + { + switch(d) + { + case '\'': token.kind = MD_TokenKind_StringLiteralSingleQuote; break; + case '"': token.kind = MD_TokenKind_StringLiteralDoubleQuote; break; + case '`': token.kind = MD_TokenKind_StringLiteralTick; break; + default: break; + } + } + }break; // NOTE(allen): Identifiers, Numbers, Operators @@ -1818,9 +1833,7 @@ MD_ParseOneNodeFromCtx(MD_ParseCtx *ctx) MD_StringMatch(next_token.string, MD_S8Lit("{"), 0) || MD_StringMatch(next_token.string, MD_S8Lit("["), 0))) { - result.node = _MD_MakeNode_Ctx(ctx, MD_NodeKind_Label, - MD_S8Lit(""), MD_S8Lit(""), - next_token.outer_string.str); + result.node = MD_MakeNode(MD_NodeKind_Label, MD_S8Lit(""), MD_S8Lit(""), next_token.outer_string.str); MD_Parse_Set(ctx, result.node, MD_ParseSetFlag_Paren | @@ -1830,35 +1843,57 @@ MD_ParseOneNodeFromCtx(MD_ParseCtx *ctx) } // NOTE(rjf): Labels - else if(MD_Parse_RequireKind(ctx, MD_TokenKind_Identifier, &token) || - MD_Parse_RequireKind(ctx, MD_TokenKind_NumericLiteral, &token) || - MD_Parse_RequireKind(ctx, MD_TokenKind_StringLiteral, &token) || - MD_Parse_RequireKind(ctx, MD_TokenKind_CharLiteral, &token) || - MD_Parse_RequireKind(ctx, MD_TokenKind_Symbol, &token)) + else if(next_token.kind == MD_TokenKind_Identifier || + next_token.kind == MD_TokenKind_NumericLiteral || + next_token.kind == MD_TokenKind_StringLiteralTick || + next_token.kind == MD_TokenKind_StringLiteralSingleQuote || + next_token.kind == MD_TokenKind_StringLiteralDoubleQuote || + next_token.kind == MD_TokenKind_StringLiteralTickTriplet || + next_token.kind == MD_TokenKind_StringLiteralSingleQuoteTriplet || + next_token.kind == MD_TokenKind_StringLiteralDoubleQuoteTriplet || + next_token.kind == MD_TokenKind_Symbol ) { - result.node = _MD_MakeNode_Ctx(ctx, MD_NodeKind_Label, - token.string, token.outer_string, token.outer_string.str); - result.node->flags |= _MD_NodeFlagsFromTokenKind(token.kind); + MD_Parse_Bump(ctx, next_token); + result.node = MD_MakeNode(MD_NodeKind_Label, next_token.string, next_token.outer_string, next_token.outer_string.str); + result.node->flags |= MD_NodeFlagsFromTokenKind(next_token.kind); - if(token.kind == MD_TokenKind_CharLiteral || token.kind == MD_TokenKind_StringLiteral) + // TODO(rjf): Before we were just able to check one kind. I think preserving + // which kind of string literal was used is very important, for the same reason + // that preserving which symbols were used to delimit a set is important. + // But, having to manage this "group of kinds" is a little bit annoying. + // Maybe we should define the set of legal kinds for certain syntactic + // contexts somewhere unified, so that the parser is never duplicating this? + // + // It's also possible that it never matters and we only ever use this group + // in one place, but I just got that "we're duplicating stuff" allergy that + // I usually get. + // + // If that turned out to be a good idea, maybe we could do something like + // MD_TokenKindIsLegalLabelHead, MD_TokenKindNeedsBalancing?? I don't know. + if(next_token.kind == MD_TokenKind_StringLiteralTick || + next_token.kind == MD_TokenKind_StringLiteralSingleQuote || + next_token.kind == MD_TokenKind_StringLiteralDoubleQuote || + next_token.kind == MD_TokenKind_StringLiteralTickTriplet || + next_token.kind == MD_TokenKind_StringLiteralSingleQuoteTriplet || + next_token.kind == MD_TokenKind_StringLiteralDoubleQuoteTriplet) { - if(!_MD_StringLiteralIsBalanced(token)) + if(!_MD_TokenBoundariesAreBalanced(next_token)) { - MD_String8 capped = MD_StringPrefix(token.outer_string, MD_UNTERMINATED_TOKEN_LEN_CAP); + MD_String8 capped = MD_StringPrefix(next_token.outer_string, MD_UNTERMINATED_TOKEN_LEN_CAP); MD_PushNodeErrorF(ctx, result.node, MD_MessageKind_CatastrophicError, "Unterminated text literal \"%.*s\"", MD_StringExpand(capped)); } } - else if(token.kind == MD_TokenKind_Symbol && token.string.size == 1 && MD_CharIsReservedSymbol(token.string.str[0])) + else if(next_token.kind == MD_TokenKind_Symbol && next_token.string.size == 1 && MD_CharIsReservedSymbol(next_token.string.str[0])) { - MD_u8 c = token.string.str[0]; + MD_u8 c = next_token.string.str[0]; if(c == '}' || c == ']' || c == ')') { - MD_PushTokenErrorF(ctx, token, MD_MessageKind_CatastrophicError, "Unbalanced \"%c\"", c); + MD_PushTokenErrorF(ctx, next_token, MD_MessageKind_CatastrophicError, "Unbalanced \"%c\"", c); } else { - MD_PushTokenErrorF(ctx, token, MD_MessageKind_Error, "Unexpected reserved symbol \"%c\"", + MD_PushTokenErrorF(ctx, next_token, MD_MessageKind_Error, "Unexpected reserved symbol \"%c\"", c); } } @@ -1979,11 +2014,8 @@ MD_FUNCTION_IMPL MD_ParseResult MD_ParseWholeString(MD_String8 filename, MD_String8 contents) { MD_ParseResult result = MD_ZERO_STRUCT; - // TODO(allen): we want to make the string for this actually just - // be the filename in the root/file idea. - MD_String8 root_string = MD_PushStringF("`DD Parsed From \"%.*s\"`", MD_StringExpand(filename)); - MD_Node *root = MD_MakeNode(MD_NodeKind_File, root_string, root_string, - filename, contents.str, contents.str); + MD_String8 root_string = filename; + MD_Node *root = MD_MakeNode(MD_NodeKind_File, root_string, root_string, contents.str); if(contents.size > 0) { // NOTE(allen): setup parse context @@ -2045,23 +2077,26 @@ MD_ParseWholeFile(MD_String8 filename) //~ Location Conversions -MD_PRIVATE_FUNCTION_IMPL MD_CodeLoc -MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u8 *at) +MD_FUNCTION_IMPL MD_CodeLoc +MD_CodeLocFromFileBaseOff(MD_String8 filename, MD_u8 *base, MD_u8 *at) { MD_CodeLoc loc; loc.filename = filename; loc.line = 1; loc.column = 1; - for(MD_u64 i = 0; base+i < at && base[i]; i += 1) + if(base != 0) { - if(base[i] == '\n') + for(MD_u64 i = 0; base+i < at && base[i]; i += 1) { - loc.line += 1; - loc.column = 1; - } - else - { - loc.column += 1; + if(base[i] == '\n') + { + loc.line += 1; + loc.column = 1; + } + else + { + loc.column += 1; + } } } return loc; @@ -2070,7 +2105,8 @@ MD_CodeLocFromFileOffset(MD_String8 filename, MD_u8 *base, MD_u8 *at) MD_FUNCTION_IMPL MD_CodeLoc MD_CodeLocFromNode(MD_Node *node) { - MD_CodeLoc loc = MD_CodeLocFromFileOffset(node->filename, node->file_contents, node->at); + MD_Node *root = MD_RootFromNode(node); + MD_CodeLoc loc = MD_CodeLocFromFileBaseOff(root->string, root->at, node->at); return loc; } @@ -2087,8 +2123,7 @@ MD_NilNode(void) { return &_md_nil_node; } MD_FUNCTION_IMPL MD_Node * MD_MakeNode(MD_NodeKind kind, MD_String8 string, - MD_String8 whole_string, MD_String8 filename, - MD_u8 *file_contents, MD_u8 *at) + MD_String8 whole_string, MD_u8 *at) { MD_Node *node = MD_PushArray(MD_Node, 1); node->kind = kind; @@ -2097,8 +2132,6 @@ MD_MakeNode(MD_NodeKind kind, MD_String8 string, node->next = node->prev = node->parent = node->first_child = node->last_child = node->first_tag = node->last_tag = node->ref_target = MD_NilNode(); - node->filename = filename; - node->file_contents = file_contents; node->at = at; return node; } @@ -2136,8 +2169,7 @@ MD_PushTag(MD_Node *node, MD_Node *tag) MD_FUNCTION_IMPL MD_Node* MD_PushReference(MD_Node *list, MD_Node *target) { - MD_Node *n = MD_MakeNode(MD_NodeKind_Reference, target->string, target->whole_string, - target->filename, target->file_contents, target->at); + MD_Node *n = MD_MakeNode(MD_NodeKind_Reference, target->string, target->whole_string, target->at); n->ref_target = target; MD_PushChild(list, n); return(n); @@ -2190,6 +2222,17 @@ MD_IndexFromNode(MD_Node *node) return idx; } +MD_FUNCTION MD_Node * +MD_RootFromNode(MD_Node *node) +{ + MD_Node *parent = node; + for(MD_Node *p = parent; !MD_NodeIsNil(p); p = p->parent) + { + parent = p; + } + return parent; +} + MD_FUNCTION_IMPL MD_Node * MD_NextNodeSibling(MD_Node *last, MD_String8 string) { diff --git a/tests/grammar.c b/tests/grammar.c index de5a5ba..d9da4ea 100644 --- a/tests/grammar.c +++ b/tests/grammar.c @@ -66,7 +66,7 @@ static MD_Node * NewChildLabel(MD_Node *parent, MD_String8 label) { MD_Node *result = 0; - result = MD_MakeNode(MD_NodeKind_Label, label, label, MD_S8Lit(""), 0, 0); + result = MD_MakeNode(MD_NodeKind_Label, label, label, 0); if(parent) { MD_PushChild(parent, result); @@ -86,7 +86,7 @@ static MD_Node * NewChild(MD_Node *parent) #define SET_DEPTH(depth_map, node, depth) MD_MapOverwrite(depth_map, MD_MapKeyPtr(node), (void *)(depth)) static void PrintRule(MD_Map *depth_map, MD_Node *rule) { - MD_b32 is_literal_char = rule->flags & MD_NodeFlag_CharLiteral; + MD_b32 is_literal_char = rule->flags & MD_NodeFlag_StringLiteral; MD_b32 optional = MD_NodeHasTag(rule, MD_S8Lit(OPTIONAL_TAG)); @@ -221,7 +221,7 @@ static void ExpandRule(MD_Node *rule, MD_String8List *out_strings, MD_Node *cur_ } else { - if(rule_element->flags & MD_NodeFlag_CharLiteral) // NOTE(mal): Terminal production + if(rule_element->flags & MD_NodeFlag_StringLiteral) // NOTE(mal): Terminal production { char c = 0; if(rule_element->string.size == 2 && rule_element->string.str[0] == '\\') @@ -308,7 +308,7 @@ static MD_Node * FindNonTerminalProduction(MD_Node *node, MD_Map *visited) { if(MD_NodeIsNil(node->first_child)) { - if(node->flags & MD_NodeFlag_CharLiteral) + if(node->flags & MD_NodeFlag_StringLiteral) { } else @@ -425,7 +425,7 @@ static void ComputeElementDepth(MD_Map *depth_map, MD_Node *re) } else { - if(re->flags & MD_NodeFlag_CharLiteral) // NOTE(mal): Terminal production + if(re->flags & MD_NodeFlag_StringLiteral) // NOTE(mal): Terminal production { result = 1; } @@ -561,7 +561,7 @@ int main(int argument_count, char **arguments) else { if(MD_StringMatch(rule_element->string, MD_S8Lit("|"), 0) && - !(rule_element->flags & MD_NodeFlag_CharLiteral)) + !(rule_element->flags & MD_NodeFlag_StringLiteral)) { rule = NewChild(production); } @@ -658,7 +658,7 @@ int main(int argument_count, char **arguments) { MD_u64 depth = 0; MD_Assert(MD_NodeIsNil(rule_element->first_child)); - if(!(rule_element->flags & MD_NodeFlag_CharLiteral)) + if(!(rule_element->flags & MD_NodeFlag_StringLiteral)) { MD_Node * production = MD_MapLookup(globals.production_table, MD_MapKeyStr(rule_element->string))->val; depth = GET_DEPTH(depth_map, production); diff --git a/tests/sanity_tests.c b/tests/sanity_tests.c index 1a3e0b2..ee8c178 100644 --- a/tests/sanity_tests.c +++ b/tests/sanity_tests.c @@ -31,6 +31,13 @@ TestResult(MD_b32 result) test_ctx.number_of_tests += 1; test_ctx.number_passed += !!result; printf(result ? "." : "X"); + +#if 0 + if(result == 0) + { + __debugbreak(); + } +#endif } static void @@ -58,7 +65,7 @@ EndTest(void) static MD_Node * MakeTestNode(MD_NodeKind kind, MD_String8 string) { - return MD_MakeNode(kind, string, string, MD_S8Lit("`TEST_NODE`"), 0, 0); + return MD_MakeNode(kind, string, string, 0); } static MD_C_Expr * @@ -280,7 +287,7 @@ int main(void) TestResult(MD_ParseOneNode(MD_S8Lit(""), MD_S8Lit("\"foo\"")).node->flags & MD_NodeFlag_StringLiteral); TestResult(MD_ParseOneNode(MD_S8Lit(""), MD_S8Lit("'foo'")).node->flags & - MD_NodeFlag_CharLiteral); + MD_NodeFlag_StringLiteral); } Test("Expression Evaluation") @@ -388,11 +395,11 @@ int main(void) { TestResult(MD_StringMatch(MD_StringFromNodeKind(MD_NodeKind_Label), MD_S8Lit("Label"), 0)); TestResult(MD_StringMatch(MD_StringFromNodeKind(MD_NodeKind_Label), MD_S8Lit("Label"), 0)); - MD_String8List list = MD_StringListFromNodeFlags(MD_NodeFlag_CharLiteral | MD_NodeFlag_ParenLeft | MD_NodeFlag_BeforeSemicolon); + MD_String8List list = MD_StringListFromNodeFlags(MD_NodeFlag_StringLiteral | MD_NodeFlag_ParenLeft | MD_NodeFlag_BeforeSemicolon); MD_b32 match = 1; for(MD_String8Node *node = list.first; node; node = node->next) { - if(!MD_StringMatch(node->string, MD_S8Lit("CharLiteral"), 0) && + if(!MD_StringMatch(node->string, MD_S8Lit("StringLiteral"), 0) && !MD_StringMatch(node->string, MD_S8Lit("ParenLeft"), 0) && !MD_StringMatch(node->string, MD_S8Lit("BeforeSemicolon"), 0)) {