~groovestomp/c-parser

60559b3b42d53f1ae92c7a9be826a5e7f44b4654 — Aaron Oman 2 years ago 805d5ea
Normalize primitive typenames
4 files changed, 209 insertions(+), 196 deletions(-)

M src/gs.h
M src/lexer.c
M src/parser.c
M src/tree.c
M src/gs.h => src/gs.h +55 -40
@@ 3,7 3,7 @@
 * Created: 2016-07-14
 * Last Updated: 2016-08-22
 * Creator: Aaron Oman (a.k.a GrooveStomp)
 * Notice: (C) Copyright 2016 by Aaron Oman
 * Notice: (C) Copyright 2016-2020 by Aaron Oman
 *-----------------------------------------------------------------------------
 *
 * Standard library for personal use. Heavily influenced by Sean Barrett's stb.


@@ 11,7 11,7 @@
 ******************************************************************************/
#ifndef GS_H
#define GS_H
#define GS_VERSION 0.2.0
#define GS_VERSION 0.2.0-dev

#include <stdio.h>
#include <stdlib.h>


@@ 70,39 70,54 @@
#define GSBytesToMegabytes(X) GSBytesToKilobytes((X)) * GS1024Inverse
#define GSBytesToGigabytes(X) GSBytesToMegabytes((X)) * GS1024Inverse

#define GSNullChar '\0'
#define GSNullPtr NULL

/******************************************************************************
 * Boolean Definitions
 * Primitive Type Definitions
 * TODO: Conditionally do typedefs?
 ******************************************************************************/
#define GSNullChar '\0'
#define GSNullPtr NULL

typedef int gs_bool;
typedef int bool;
#ifndef false
#define false 0
#define true !false
#endif

typedef char i8;
typedef unsigned char u8;
typedef short i16;
typedef unsigned short u16;
typedef int i32;
typedef unsigned int u32;
typedef long i64;
typedef unsigned long u64;
typedef long long i128;
typedef unsigned long long u128;

typedef float f32;
typedef double f64;
typedef long double f128;

/******************************************************************************
 * Character Definitions
 *-----------------------------------------------------------------------------
 * Functions to interact with C's basic ASCII char type.
 ******************************************************************************/

gs_bool
bool
GSCharIsEndOfStream(char C)
{
	return(C == '\0');
}

gs_bool
bool
GSCharIsEndOfLine(char C)
{
	return((C == '\n') ||
	       (C == '\r'));
}

gs_bool
bool
GSCharIsWhitespace(char C)
{
	return((C == ' ') ||


@@ 112,47 127,47 @@ GSCharIsWhitespace(char C)
	       GSCharIsEndOfLine(C));
}

gs_bool
bool
GSCharIsOctal(char C)
{
	gs_bool Result = (C >= '0' && C <= '7');
	bool Result = (C >= '0' && C <= '7');
	return(Result);
}

gs_bool
bool
GSCharIsDecimal(char C)
{
	gs_bool Result = (C >= '0' && C <= '9');
	bool Result = (C >= '0' && C <= '9');
	return(Result);
}

gs_bool
bool
GSCharIsHexadecimal(char C)
{
	gs_bool Result = ((C >= '0' && C <= '9') ||
	bool Result = ((C >= '0' && C <= '9') ||
		       (C >= 'a' && C <= 'f') ||
		       (C >= 'A' && C <= 'F'));
	return(Result);
}

gs_bool
bool
GSCharIsAlphabetical(char C)
{
	gs_bool Result = ((C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z'));
	bool Result = ((C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z'));
	return(Result);
}

gs_bool
bool
GSCharIsAlphanumeric(char C)
{
        gs_bool Result = GSCharIsAlphabetical(C) || GSCharIsDecimal(C);
        bool Result = GSCharIsAlphabetical(C) || GSCharIsDecimal(C);
        return(Result);
}

gs_bool
bool
GSCharIsUpcase(char C)
{
        gs_bool Result =
        bool Result =
                GSCharIsAlphabetical(C) &&
                (C >= 'A') &&
                (C <= 'Z');


@@ 174,10 189,10 @@ GSCharUpcase(char C)
        return(Result);
}

gs_bool
bool
GSCharIsDowncase(char C)
{
        gs_bool Result =
        bool Result =
                GSCharIsAlphabetical(C) &&
                (C >= 'a') &&
                (C <= 'z');


@@ 205,7 220,7 @@ GSCharDowncase(char C)
 * C string type. That is, ASCII characters with terminating NULL.
 ******************************************************************************/

gs_bool
bool
GSStringIsEqual(char *LeftString, char *RightString, int MaxNumToMatch)
{
	int NumMatched = 0;


@@ 242,7 257,7 @@ GSStringLength(char *String)
	return(P - String);
}

gs_bool
bool
GSStringCopy(char *Source, char *Dest, int Max)
{
        if(Source == NULL || Dest == NULL)


@@ 260,7 275,7 @@ GSStringCopy(char *Source, char *Dest, int Max)
        return(true);
}

gs_bool
bool
GSStringCopyNoNull(char *Source, char *Dest, int Max)
{
        if(Source == NULL || Dest == NULL)


@@ 422,7 437,7 @@ GSStringCapitalize(char *Source, unsigned int Length)
        return(Source);
}

typedef gs_bool (*GSStringFilterFn)(char C);
typedef bool (*GSStringFilterFn)(char C);

int /* Returns length of new string */
GSStringKeep(char *Source, char *Dest, unsigned int MaxLength, GSStringFilterFn FilterFn)


@@ 542,7 557,7 @@ GSHashMapInit(void *Memory, unsigned int MaxKeyLength, unsigned int NumEntries)
        return(Self);
}

gs_bool
bool
__GSHashMapUpdate(gs_hash_map *Self, char *Key, void *Value)
{
        unsigned int KeyLength = GSStringLength(Key);


@@ 567,7 582,7 @@ __GSHashMapUpdate(gs_hash_map *Self, char *Key, void *Value)
        return(false);
}

gs_bool /* Wanted must be a NULL terminated string */
bool /* Wanted must be a NULL terminated string */
GSHashMapHasKey(gs_hash_map *Self, char *Wanted)
{
        unsigned int HashIndex = __GSHashMapComputeHash(Self, Wanted);


@@ 602,7 617,7 @@ GSHashMapHasKey(gs_hash_map *Self, char *Wanted)
             See: https://en.wikipedia.org/wiki/Open_addressing
  Key must be a NULL terminated string.
 */
gs_bool
bool
GSHashMapSet(gs_hash_map *Self, char *Key, void *Value)
{
        unsigned int KeyLength = GSStringLength(Key);


@@ 647,7 662,7 @@ GSHashMapSet(gs_hash_map *Self, char *Key, void *Value)
        return(false);
}

gs_bool /* Memory must be large enough for the resized Hash. Memory _cannot_ overlap! */
bool /* Memory must be large enough for the resized Hash. Memory _cannot_ overlap! */
GSHashMapGrow(gs_hash_map **Self, unsigned int NumEntries, void *New)
{
        gs_hash_map *Old = *Self;


@@ 663,7 678,7 @@ GSHashMapGrow(gs_hash_map **Self, unsigned int NumEntries, void *New)
                char *Value = (char *)(Old->Values[I]);
                if(Key != NULL)
                {
                        gs_bool Success = GSHashMapSet(*Self, Key, Value);
                        bool Success = GSHashMapSet(*Self, Key, Value);
                        if(!Success)
                                GSAbortWithMessage("This should have worked!\n");
                }


@@ 763,7 778,7 @@ GSArgsProgramName(gs_args *Self)
        return(Result);
}

gs_bool
bool
GSArgsIsPresent(gs_args *Args, char *Wanted)
{
        int StringLength = GSStringLength(Wanted);


@@ 811,7 826,7 @@ GSArgsAfter(gs_args *Args, char *Marker)
        return(Arg);
}

gs_bool
bool
GSArgsHelpWanted(gs_args *Args)
{
        if(GSArgsIsPresent(Args, "-h") ||


@@ 845,11 860,11 @@ GSBufferInit(gs_buffer *Buffer, char *Start, size_t Size)
        return(Buffer);
}

gs_bool
bool
GSBufferIsEOF(gs_buffer *Buffer)
{
        int Size = Buffer->Cursor - Buffer->Start;
        gs_bool Result = Size >= Buffer->Length;
        bool Result = Size >= Buffer->Length;
        return(Result);
}



@@ 868,14 883,14 @@ GSBufferNextLine(gs_buffer *Buffer)
        Buffer->Cursor++;
}

gs_bool
bool
GSBufferSaveCursor(gs_buffer *Buffer)
{
        Buffer->SavedCursor = Buffer->Cursor;
        return(true);
}

gs_bool
bool
GSBufferRestoreCursor(gs_buffer *Buffer)
{
        if(Buffer->SavedCursor == NULL) return(false);


@@ 899,7 914,7 @@ GSFileSize(char *FileName)
        return(FileSize);
}

gs_bool
bool
GSFileCopyToBuffer(char *FileName, gs_buffer *Buffer)
{
        FILE *File = fopen(FileName, "r");

M src/lexer.c => src/lexer.c +26 -26
@@ 148,15 148,15 @@ typedef struct token {
        char *Text;
        size_t TextLength;
        enum token_type Type;
        unsigned int Line;
        unsigned int Column;
        u32 Line;
        u32 Column;
} token;

typedef struct tokenizer {
        char *Beginning;
        char *At;
        unsigned int Line;
        unsigned int Column;
        u32 Line;
        u32 Column;
} tokenizer;

void TokenizerInit(struct tokenizer *Self, char *Memory) {


@@ 190,7 190,7 @@ void AdvanceTokenizerToChar(struct tokenizer *Tokenizer, char Char) {
        }
}

gs_bool CopyToTokenAndAdvance(struct tokenizer *Tokenizer, struct token *Token, int Length, enum token_type Type) {
bool CopyToTokenAndAdvance(struct tokenizer *Tokenizer, struct token *Token, int Length, enum token_type Type) {
        Token->Text = Tokenizer->At;
        Token->TextLength = Length;
        Token->Type = Type;


@@ 204,20 204,20 @@ void EatAllWhitespace(struct tokenizer *Tokenizer) {
        for (; GSCharIsWhitespace(Tokenizer->At[0]); AdvanceTokenizer(Tokenizer));
}

gs_bool IsIdentifierCharacter(char C) {
	gs_bool Result = (GSCharIsAlphabetical(C) || GSCharIsDecimal(C) || C == '_');
bool IsIdentifierCharacter(char C) {
	bool Result = (GSCharIsAlphabetical(C) || GSCharIsDecimal(C) || C == '_');
	return Result;
}

gs_bool IsIntegerSuffix(char C) {
	gs_bool Result = (C == 'u' ||
bool IsIntegerSuffix(char C) {
	bool Result = (C == 'u' ||
                          C == 'U' ||
                          C == 'l' ||
                          C == 'L');
	return Result;
}

gs_bool GetCharacter(struct tokenizer *Tokenizer, struct token *Token) {
bool GetCharacter(struct tokenizer *Tokenizer, struct token *Token) {
        char *Cursor = Tokenizer->At;

        /* First character must be a single quote. */


@@ 241,7 241,7 @@ gs_bool GetCharacter(struct tokenizer *Tokenizer, struct token *Token) {
        return true;
}

gs_bool GetString(struct tokenizer *Tokenizer, struct token *Token) {
bool GetString(struct tokenizer *Tokenizer, struct token *Token) {
        char *Cursor = Tokenizer->At;
        if (*Cursor != '"') return false;



@@ 257,7 257,7 @@ gs_bool GetString(struct tokenizer *Tokenizer, struct token *Token) {
        return true;
}

gs_bool IsOctalString(char *Text, int Length) {
bool IsOctalString(char *Text, int Length) {
        if (Length < 2) return false;

        char Last = Text[Length-1];


@@ 275,7 275,7 @@ gs_bool IsOctalString(char *Text, int Length) {
        return true;
}

gs_bool IsHexadecimalString(char *Text, int Length) {
bool IsHexadecimalString(char *Text, int Length) {
        if (Length < 3) return false;

        char Last = Text[Length-1];


@@ 293,7 293,7 @@ gs_bool IsHexadecimalString(char *Text, int Length) {
        return true;
}

gs_bool GetPrecisionNumber(struct tokenizer *Tokenizer, struct token *Token) {
bool GetPrecisionNumber(struct tokenizer *Tokenizer, struct token *Token) {
        /*
          A floating constant consists of an integer part, a decimal point, a
          fraction part, an e or E, an optionally signed integer exponent and an


@@ 308,10 308,10 @@ gs_bool GetPrecisionNumber(struct tokenizer *Tokenizer, struct token *Token) {

        char *Cursor = Tokenizer->At;

        gs_bool HasIntegerPart = false;
        gs_bool HasDecimalPoint = false;
        gs_bool HasFractionalPart = false;
        gs_bool HasExponentPart = false;
        bool HasIntegerPart = false;
        bool HasDecimalPoint = false;
        bool HasFractionalPart = false;
        bool HasExponentPart = false;

        if (GSCharIsDecimal(*Cursor)) {
                for (; GSCharIsDecimal(*Cursor); ++Cursor);


@@ 360,7 360,7 @@ gs_bool GetPrecisionNumber(struct tokenizer *Tokenizer, struct token *Token) {
        return false;
}

gs_bool GetInteger(struct tokenizer *Tokenizer, struct token *Token) {
bool GetInteger(struct tokenizer *Tokenizer, struct token *Token) {
        char *LastChar = Tokenizer->At;
        for (; *LastChar && (GSCharIsDecimal(*LastChar) || GSCharIsAlphabetical(*LastChar)); ++LastChar);



@@ 400,7 400,7 @@ gs_bool GetInteger(struct tokenizer *Tokenizer, struct token *Token) {
        return false;
}

gs_bool GetIdentifier(struct tokenizer *Tokenizer, struct token *Token) {
bool GetIdentifier(struct tokenizer *Tokenizer, struct token *Token) {
        if (!GSCharIsAlphabetical(Tokenizer->At[0]) &&
           '_' != Tokenizer->At[0]) {
                return false;


@@ 414,7 414,7 @@ gs_bool GetIdentifier(struct tokenizer *Tokenizer, struct token *Token) {
        return true;
}

gs_bool GetComment(struct tokenizer *Tokenizer, struct token *Token) {
bool GetComment(struct tokenizer *Tokenizer, struct token *Token) {
        if (Tokenizer->At[0] != '/' || Tokenizer->At[1] != '*') return false;

        char *Cursor = Tokenizer->At;


@@ 437,7 437,7 @@ gs_bool GetComment(struct tokenizer *Tokenizer, struct token *Token) {
        return true;
}

gs_bool GetKeyword(struct tokenizer *Tokenizer, struct token *Token) {
bool GetKeyword(struct tokenizer *Tokenizer, struct token *Token) {
        static char *Keywords[] = {
                "auto", "break", "case", "char", "const", "continue", "default",
                "double", "do", "else", "enum", "extern", "float", "for",


@@ 457,7 457,7 @@ gs_bool GetKeyword(struct tokenizer *Tokenizer, struct token *Token) {
        return false;
}

gs_bool GetPreprocessorCommand(struct tokenizer *Tokenizer, struct token *Token) {
bool GetPreprocessorCommand(struct tokenizer *Tokenizer, struct token *Token) {
        if (Tokenizer->At[0] != '#') return false;

        char *Cursor = Tokenizer->At;


@@ 481,7 481,7 @@ gs_bool GetPreprocessorCommand(struct tokenizer *Tokenizer, struct token *Token)
        return true;
}

gs_bool GetSymbol(struct tokenizer *Tokenizer, struct token *Token, char *Symbol, enum token_type Type) {
bool GetSymbol(struct tokenizer *Tokenizer, struct token *Token, char *Symbol, enum token_type Type) {
        int Length = GSStringLength(Symbol);
        if (!GSStringIsEqual(Tokenizer->At, Symbol, Length)) return false;



@@ 581,11 581,11 @@ struct token GetToken(struct tokenizer *Tokenizer) {
        return Token;
}

gs_bool Lex(gs_buffer *FileContents) {
bool Lex(gs_buffer *FileContents) {
        struct tokenizer Tokenizer;
        TokenizerInit(&Tokenizer, FileContents->Start);

        gs_bool Parsing = true;
        bool Parsing = true;
        while (Parsing) {
                struct token Token = GetToken(&Tokenizer);
                switch(Token.Type) {

M src/parser.c => src/parser.c +115 -115
@@ 6,7 6,7 @@
#include "lexer.c"
#include "tree.c"

void __Parser_ParseTreeUpdate(parse_tree_node *ParseTree, char *Name, unsigned int NumChildren) {
void __Parser_ParseTreeUpdate(parse_tree_node *ParseTree, char *Name, u32 NumChildren) {
        ParseTreeSetName(ParseTree, Name);
        if (NumChildren > 0) {
                ParseTreeNewChildren(ParseTree, NumChildren);


@@ 19,23 19,23 @@ void __Parser_ParseTreeClearChildren(parse_tree_node *ParseTree) {
        }
}

gs_bool ParseAssignmentExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseTypeName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseCastExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseConditionalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseParameterTypeList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParsePointer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseSpecifierQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseInitializer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseDeclarationSpecifiers(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseTypeQualifier(struct tokenizer *Tokneizer, parse_tree_node *ParseTree);
gs_bool ParseTypeSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
gs_bool ParseDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseAssignmentExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseTypeName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseCastExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseConditionalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseParameterTypeList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParsePointer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseSpecifierQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseInitializer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseDeclarationSpecifiers(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseTypeQualifier(struct tokenizer *Tokneizer, parse_tree_node *ParseTree);
bool ParseTypeSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);
bool ParseDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree);

struct typedef_names {
        char *Name;


@@ 62,7 62,7 @@ TypedefInit() {
        TypedefNames.NumNames = 0;
}

gs_bool TypedefIsName(struct token Token) {
bool TypedefIsName(struct token Token) {
        for(int i = 0; i < TypedefNames.NumNames; i++)
        {
                if(GSStringIsEqual(Token.Text, &TypedefNames.Name[TypedefNames.NameIndex[i]], Token.TextLength))


@@ 73,7 73,7 @@ gs_bool TypedefIsName(struct token Token) {
        return(false);
}

gs_bool TypedefAddName(char *Name) {
bool TypedefAddName(char *Name) {
        if(TypedefNames.NumNames == 0)
        {
                GSStringCopy(Name, TypedefNames.Name, GSStringLength(Name));


@@ 105,7 105,7 @@ gs_bool TypedefAddName(char *Name) {
          floating-constant
          enumeration-constant
*/
gs_bool ParseConstant(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseConstant(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);



@@ 127,7 127,7 @@ gs_bool ParseConstant(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        }
}

gs_bool ParseArgumentExpressionListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseArgumentExpressionListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 150,7 150,7 @@ gs_bool ParseArgumentExpressionListI(struct tokenizer *Tokenizer, parse_tree_nod
          assignment-expression
          argument-expression-list , assignment-expression
*/
gs_bool ParseArgumentExpressionList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseArgumentExpressionList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Argument Expresion List", 2);


@@ 172,7 172,7 @@ gs_bool ParseArgumentExpressionList(struct tokenizer *Tokenizer, parse_tree_node
          string
          ( expression )
*/
gs_bool ParsePrimaryExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParsePrimaryExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];



@@ 208,7 208,7 @@ gs_bool ParsePrimaryExpression(struct tokenizer *Tokenizer, parse_tree_node *Par
        return(false);
}

gs_bool ParsePostfixExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParsePostfixExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];



@@ 299,7 299,7 @@ gs_bool ParsePostfixExpressionI(struct tokenizer *Tokenizer, parse_tree_node *Pa
          postfix-expression ++
          postfix-expression --
*/
gs_bool ParsePostfixExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParsePostfixExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Postfix Expression", 2);


@@ 314,7 314,7 @@ gs_bool ParsePostfixExpression(struct tokenizer *Tokenizer, parse_tree_node *Par
        return(false);
}

gs_bool ParseUnaryOperator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseUnaryOperator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);
        switch(Token.Type)


@@ 346,7 346,7 @@ gs_bool ParseUnaryOperator(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
          sizeof unary-expression
          sizeof ( type-name )
*/
gs_bool ParseUnaryExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseUnaryExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];



@@ 421,7 421,7 @@ gs_bool ParseUnaryExpression(struct tokenizer *Tokenizer, parse_tree_node *Parse
          unary-expression
          ( type-name ) cast-expression
*/
gs_bool ParseCastExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseCastExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];



@@ 447,7 447,7 @@ gs_bool ParseCastExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseT
        return(false);
}

gs_bool ParseMultiplicativeExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseMultiplicativeExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 490,7 490,7 @@ gs_bool ParseMultiplicativeExpressionI(struct tokenizer *Tokenizer, parse_tree_n
          multiplicative-expression / cast-expression
          multiplicative-expression % cast-expression
*/
gs_bool ParseMultiplicativeExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseMultiplicativeExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Multiplicative Expression", 2);


@@ 505,7 505,7 @@ gs_bool ParseMultiplicativeExpression(struct tokenizer *Tokenizer, parse_tree_no
        return(false);
}

gs_bool ParseAdditiveExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAdditiveExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 538,7 538,7 @@ gs_bool ParseAdditiveExpressionI(struct tokenizer *Tokenizer, parse_tree_node *P
          additive-expression + multiplicative-expression
          additive-expression - multiplicative-expression
*/
gs_bool ParseAdditiveExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAdditiveExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Additive Expression", 2);


@@ 553,7 553,7 @@ gs_bool ParseAdditiveExpression(struct tokenizer *Tokenizer, parse_tree_node *Pa
        return(false);
}

gs_bool ParseShiftExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseShiftExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 586,7 586,7 @@ gs_bool ParseShiftExpressionI(struct tokenizer *Tokenizer, parse_tree_node *Pars
          shift-expression << additive-expression
          shift-expression >> additive-expression
*/
gs_bool ParseShiftExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseShiftExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Shift Expression", 2);


@@ 601,7 601,7 @@ gs_bool ParseShiftExpression(struct tokenizer *Tokenizer, parse_tree_node *Parse
        return(false);
}

gs_bool ParseRelationalExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseRelationalExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 654,7 654,7 @@ gs_bool ParseRelationalExpressionI(struct tokenizer *Tokenizer, parse_tree_node 
          relational-expression <= shift-exression
          relational-expression >= shift-expression
*/
gs_bool ParseRelationalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseRelationalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Relational Expressoin", 2);


@@ 669,7 669,7 @@ gs_bool ParseRelationalExpression(struct tokenizer *Tokenizer, parse_tree_node *
        return(false);
}

gs_bool ParseEqualityExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEqualityExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 702,7 702,7 @@ gs_bool ParseEqualityExpressionI(struct tokenizer *Tokenizer, parse_tree_node *P
          equality-expression == relational-expression
          equality-expression != relational-expression
*/
gs_bool ParseEqualityExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEqualityExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Equality Expression", 2);


@@ 717,7 717,7 @@ gs_bool ParseEqualityExpression(struct tokenizer *Tokenizer, parse_tree_node *Pa
        return(false);
}

gs_bool ParseAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 740,7 740,7 @@ gs_bool ParseAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseT
          equality-expression
          AND-expression & equality-expression
*/
gs_bool ParseAndExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAndExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "And Expression", 2);


@@ 755,7 755,7 @@ gs_bool ParseAndExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
        return(false);
}

gs_bool ParseExclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 778,7 778,7 @@ gs_bool ParseExclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node
          AND-expression
          exclusive-OR-expression ^ AND-expression
 */
gs_bool ParseExclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Exclusive Or Expression", 2);


@@ 793,7 793,7 @@ gs_bool ParseExclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node 
        return(false);
}

gs_bool ParseInclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 816,7 816,7 @@ gs_bool ParseInclusiveOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node
          exclusive-OR-expression
          inclusive-OR-expression | exclusive-OR-expression
*/
gs_bool ParseInclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Inclusive Or Expression", 2);


@@ 831,7 831,7 @@ gs_bool ParseInclusiveOrExpression(struct tokenizer *Tokenizer, parse_tree_node 
        return(false);
}

gs_bool ParseLogicalAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseLogicalAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 854,7 854,7 @@ gs_bool ParseLogicalAndExpressionI(struct tokenizer *Tokenizer, parse_tree_node 
          inclusive-OR-expression
          logical-AND-expression && inclusive-OR-expression
*/
gs_bool ParseLogicalAndExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseLogicalAndExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Logical And Expression", 2);


@@ 869,7 869,7 @@ gs_bool ParseLogicalAndExpression(struct tokenizer *Tokenizer, parse_tree_node *
        return(false);
}

gs_bool ParseLogicalOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseLogicalOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 892,7 892,7 @@ gs_bool ParseLogicalOrExpressionI(struct tokenizer *Tokenizer, parse_tree_node *
          logical-AND-expression
          logical-OR-expression || logical-AND-expression
*/
gs_bool ParseLogicalOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseLogicalOrExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Logical Or Expression", 2);


@@ 911,7 911,7 @@ gs_bool ParseLogicalOrExpression(struct tokenizer *Tokenizer, parse_tree_node *P
  constant-expression:
          conditional-expression
*/
gs_bool ParseConstantExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseConstantExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Constant Expression", 1);


@@ 930,7 930,7 @@ gs_bool ParseConstantExpression(struct tokenizer *Tokenizer, parse_tree_node *Pa
          logical-OR-expression
          logical-OR-expression ? expression : conditional-expression
*/
gs_bool ParseConditionalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseConditionalExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];



@@ 963,7 963,7 @@ gs_bool ParseConditionalExpression(struct tokenizer *Tokenizer, parse_tree_node 
  assignment-operator:
  one of: = *= /= %= += -= <<= >>= &= ^= |=
*/
gs_bool ParseAssignmentOperator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAssignmentOperator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);



@@ 995,7 995,7 @@ gs_bool ParseAssignmentOperator(struct tokenizer *Tokenizer, parse_tree_node *Pa
          conditional-expression
          unary-expression assignment-operator assignment-expression
*/
gs_bool ParseAssignmentExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAssignmentExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Assignment Expression", 3);


@@ 1019,7 1019,7 @@ gs_bool ParseAssignmentExpression(struct tokenizer *Tokenizer, parse_tree_node *
        return(false);
}

gs_bool ParseExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 1042,7 1042,7 @@ gs_bool ParseExpressionI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree
          assignment-expression
          expression , assignment-expression
*/
gs_bool ParseExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Expression", 2);


@@ 1057,7 1057,7 @@ gs_bool ParseExpression(struct tokenizer *Tokenizer, parse_tree_node *ParseTree)
        return(false);
}

gs_bool ParseIdentifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseIdentifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 1078,7 1078,7 @@ gs_bool ParseIdentifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree)
          break ;
          return expression(opt) ;
*/
gs_bool ParseJumpStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseJumpStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[2];
        Tokens[0] = GetToken(Tokenizer);


@@ 1153,7 1153,7 @@ gs_bool ParseJumpStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
          do statement while ( expression) ;
          for ( expression(opt) ; expression(opt) ; expression(opt) ) statement
*/
gs_bool ParseIterationStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseIterationStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[5];
        Tokens[0] = GetToken(Tokenizer);


@@ 1269,7 1269,7 @@ gs_bool ParseIterationStatement(struct tokenizer *Tokenizer, parse_tree_node *Pa
          if ( expression ) statement else statement
          switch ( expression ) statement
*/
gs_bool ParseSelectionStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseSelectionStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Tokens[3];
        Tokens[0] = GetToken(Tokenizer);


@@ 1323,7 1323,7 @@ gs_bool ParseSelectionStatement(struct tokenizer *Tokenizer, parse_tree_node *Pa
        return(false);
}

gs_bool ParseStatementListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStatementListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Statement List'", 2);


@@ 1343,7 1343,7 @@ gs_bool ParseStatementListI(struct tokenizer *Tokenizer, parse_tree_node *ParseT
          statement
          statement-list statement
*/
gs_bool ParseStatementList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStatementList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Statement List", 2);


@@ 1362,7 1362,7 @@ gs_bool ParseStatementList(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
  compound-statement:
          { declaration-list(opt) statement-list(opt) }
*/
gs_bool ParseCompoundStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseCompoundStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 1402,7 1402,7 @@ gs_bool ParseCompoundStatement(struct tokenizer *Tokenizer, parse_tree_node *Par
  expression-statement:
          expression(opt) ;
*/
gs_bool ParseExpressionStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExpressionStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 1434,7 1434,7 @@ gs_bool ParseExpressionStatement(struct tokenizer *Tokenizer, parse_tree_node *P
          case constant-expression : statement
          default : statement
*/
gs_bool ParseLabeledStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseLabeledStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 1489,7 1489,7 @@ gs_bool ParseLabeledStatement(struct tokenizer *Tokenizer, parse_tree_node *Pars
          iteration-statement
          jump-statement
*/
gs_bool ParseStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Statement", 1);


@@ 1520,7 1520,7 @@ gs_bool ParseStatement(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) 
  typedef-name:
          identifier
*/
gs_bool ParseTypedefName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypedefName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);
        *Tokenizer = Start;


@@ 1543,7 1543,7 @@ gs_bool ParseTypedefName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree
          direct-abstract-declarator(opt) [ constant-expression(opt) ]
          direct-abstract-declarator(opt) ( parameter-type-list(opt) )
*/
gs_bool ParseDirectAbstractDeclaratorI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDirectAbstractDeclaratorI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 1604,7 1604,7 @@ gs_bool ParseDirectAbstractDeclaratorI(struct tokenizer *Tokenizer, parse_tree_n
          direct-abstract-declarator(opt) [ constant-expression(opt) ]
          direct-abstract-declarator(opt) ( parameter-type-list(opt) )
*/
gs_bool ParseDirectAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDirectAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 1673,7 1673,7 @@ gs_bool ParseDirectAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_no
          pointer
          pointer(opt) direct-abstract-declarator
*/
gs_bool ParseAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Abstract Declarator", 2);


@@ 1706,7 1706,7 @@ gs_bool ParseAbstractDeclarator(struct tokenizer *Tokenizer, parse_tree_node *Pa
  type-name:
          specifier-qualifier-list abstract-declarator(opt)
*/
gs_bool ParseTypeName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypeName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Type Name", 2);


@@ 1729,7 1729,7 @@ gs_bool ParseTypeName(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        return(false);
}

gs_bool ParseInitializerListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitializerListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 1752,7 1752,7 @@ gs_bool ParseInitializerListI(struct tokenizer *Tokenizer, parse_tree_node *Pars
          initializer
          initializer-list , initializer
*/
gs_bool ParseInitializerList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitializerList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Initializer List", 2);


@@ 1773,7 1773,7 @@ gs_bool ParseInitializerList(struct tokenizer *Tokenizer, parse_tree_node *Parse
          { initializer-list }
          { initializer-list , }
*/
gs_bool ParseInitializer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitializer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[3];



@@ 1810,7 1810,7 @@ gs_bool ParseInitializer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree
        return(false);
}

gs_bool ParseIdentifierListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseIdentifierListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 1833,7 1833,7 @@ gs_bool ParseIdentifierListI(struct tokenizer *Tokenizer, parse_tree_node *Parse
          identifier
          identifier-list , identifier
*/
gs_bool ParseIdentifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseIdentifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Identifier List", 2);


@@ 1853,7 1853,7 @@ gs_bool ParseIdentifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseT
          declaration-specifiers declarator
          declaration-specifiers abstract-declarator(opt)
*/
gs_bool ParseParameterDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseParameterDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Parameter Declaration", 2);


@@ 1883,7 1883,7 @@ gs_bool ParseParameterDeclaration(struct tokenizer *Tokenizer, parse_tree_node *
        return(false);
}

gs_bool ParseParameterListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseParameterListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 1906,7 1906,7 @@ gs_bool ParseParameterListI(struct tokenizer *Tokenizer, parse_tree_node *ParseT
          parameter-declaration
          parameter-list , parameter-declaration
*/
gs_bool ParseParameterList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseParameterList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Parameter List", 2);


@@ 1926,7 1926,7 @@ gs_bool ParseParameterList(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
          parameter-list
          parameter-list , ...
*/
gs_bool ParseParameterTypeList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseParameterTypeList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 1951,7 1951,7 @@ gs_bool ParseParameterTypeList(struct tokenizer *Tokenizer, parse_tree_node *Par
        return(false);
}

gs_bool ParseTypeQualifierListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypeQualifierListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Type Qualifier List'", 2);


@@ 1971,7 1971,7 @@ gs_bool ParseTypeQualifierListI(struct tokenizer *Tokenizer, parse_tree_node *Pa
          type-qualifier
          type-qualifier-list type-qualifier
*/
gs_bool ParseTypeQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypeQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Type Qualifier List", 2);


@@ 1991,7 1991,7 @@ gs_bool ParseTypeQualifierList(struct tokenizer *Tokenizer, parse_tree_node *Par
          * type-qualifier-list(opt)
          * type-qualifier-list(opt) pointer
  */
gs_bool ParsePointer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParsePointer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);
        struct tokenizer AtToken = *Tokenizer;


@@ 2038,7 2038,7 @@ gs_bool ParsePointer(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
          direct-declarator ( parameter-type-list )
          direct-declarator ( identifier-list(opt) )
*/
gs_bool ParseDirectDeclaratorI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDirectDeclaratorI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 2112,7 2112,7 @@ gs_bool ParseDirectDeclaratorI(struct tokenizer *Tokenizer, parse_tree_node *Par
          direct-declarator ( parameter-type-list )
          direct-declarator ( identifier-list(opt) )
*/
gs_bool ParseDirectDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDirectDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Tokens[2];



@@ 2143,7 2143,7 @@ gs_bool ParseDirectDeclarator(struct tokenizer *Tokenizer, parse_tree_node *Pars
  declarator:
          pointer(opt) direct-declarator
*/
gs_bool ParseDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Declarator", 2);


@@ 2171,7 2171,7 @@ gs_bool ParseDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree)
          identifier
          identifier = constant-expression
*/
gs_bool ParseEnumerator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEnumerator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2197,7 2197,7 @@ gs_bool ParseEnumerator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree)
        return(false);
}

gs_bool ParseEnumeratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEnumeratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2220,7 2220,7 @@ gs_bool ParseEnumeratorListI(struct tokenizer *Tokenizer, parse_tree_node *Parse
          enumerator
          enumerator-list , enumerator
*/
gs_bool ParseEnumeratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEnumeratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Enumerator List", 2);


@@ 2240,7 2240,7 @@ gs_bool ParseEnumeratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseT
          enum identifier(opt) { enumerator-list }
          enum identifier
*/
gs_bool ParseEnumSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseEnumSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);
        struct tokenizer AtToken = *Tokenizer;


@@ 2297,7 2297,7 @@ gs_bool ParseEnumSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
          declarator
          declarator(opt) : constant-expression
*/
gs_bool ParseStructDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2333,7 2333,7 @@ gs_bool ParseStructDeclarator(struct tokenizer *Tokenizer, parse_tree_node *Pars
        return(false);
}

gs_bool ParseStructDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2356,7 2356,7 @@ gs_bool ParseStructDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node 
          struct-declarator
          struct-declarator-list , struct-declarator
*/
gs_bool ParseStructDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Struct Declarator List", 2);


@@ 2376,7 2376,7 @@ gs_bool ParseStructDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *
          type-specifier specifier-qualifier-list(opt)
          type-qualifier specifier-qualifier-list(opt)
*/
gs_bool ParseSpecifierQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseSpecifierQualifierList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Specifier Qualifier List", 2);


@@ 2418,7 2418,7 @@ gs_bool ParseSpecifierQualifierList(struct tokenizer *Tokenizer, parse_tree_node
  struct-declaration:
          specifier-qualifier-list struct-declarator-list ;
*/
gs_bool ParseStructDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2441,7 2441,7 @@ gs_bool ParseStructDeclaration(struct tokenizer *Tokenizer, parse_tree_node *Par
          declarator
          declarator = initializer
*/
gs_bool ParseInitDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2467,7 2467,7 @@ gs_bool ParseInitDeclarator(struct tokenizer *Tokenizer, parse_tree_node *ParseT
        return(false);
}

gs_bool ParseInitDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        token Token;



@@ 2489,7 2489,7 @@ gs_bool ParseInitDeclaratorListI(struct tokenizer *Tokenizer, parse_tree_node *P
          init-declarator
          init-declarator-list , init-declarator
*/
gs_bool ParseInitDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseInitDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Init Declaration List", 2);


@@ 2504,7 2504,7 @@ gs_bool ParseInitDeclaratorList(struct tokenizer *Tokenizer, parse_tree_node *Pa
        return(false);
}

gs_bool ParseStructDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Struct Declaration List'", 2);


@@ 2524,7 2524,7 @@ gs_bool ParseStructDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node
          struct-declaration
          struct-declaration-list struct-declaration
*/
gs_bool ParseStructDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Struct Declaration List", 2);


@@ 2543,7 2543,7 @@ gs_bool ParseStructDeclarationList(struct tokenizer *Tokenizer, parse_tree_node 
  struct-or-union:
  One of: struct union
*/
gs_bool ParseStructOrUnion(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructOrUnion(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);



@@ 2566,7 2566,7 @@ gs_bool ParseStructOrUnion(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
          struct-or-union identifier(opt) { struct-declaration-list }
          struct-or-union identifier
*/
gs_bool ParseStructOrUnionSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStructOrUnionSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Struct or Union Specifier", 5);


@@ 2614,7 2614,7 @@ gs_bool ParseStructOrUnionSpecifier(struct tokenizer *Tokenizer, parse_tree_node
  type-qualifier:
  One of: const volatile
*/
gs_bool ParseTypeQualifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypeQualifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token = GetToken(Tokenizer);



@@ 2637,7 2637,7 @@ gs_bool ParseTypeQualifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
  One of: void char short int long float double signed unsigned
  struct-or-union-specifier enum-specifier typedef-name
*/
gs_bool ParseTypeSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTypeSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        char *Keywords[] = { "void", "char", "short", "int", "long", "float",
                             "double", "signed", "unsigned" };


@@ 2683,7 2683,7 @@ gs_bool ParseTypeSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTr
  storage-class-specifier:
  One of: auto register static extern typedef
*/
gs_bool ParseStorageClassSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseStorageClassSpecifier(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        char *Keywords[] = { "auto", "register", "static", "extern", "typedef" };



@@ 2711,7 2711,7 @@ gs_bool ParseStorageClassSpecifier(struct tokenizer *Tokenizer, parse_tree_node 
          type-specifier declaration-specifiers(opt)
          type-qualifier declaration-specifiers(opt)
*/
gs_bool ParseDeclarationSpecifiers(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDeclarationSpecifiers(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Declaration Specifiers", 2);


@@ 2760,7 2760,7 @@ gs_bool ParseDeclarationSpecifiers(struct tokenizer *Tokenizer, parse_tree_node 
        return(false);
}

gs_bool ParseDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Declaration List'", 2);


@@ 2780,7 2780,7 @@ gs_bool ParseDeclarationListI(struct tokenizer *Tokenizer, parse_tree_node *Pars
          declaration
          declaration-list declaration
*/
gs_bool ParseDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Declaration List", 2);


@@ 2799,7 2799,7 @@ gs_bool ParseDeclarationList(struct tokenizer *Tokenizer, parse_tree_node *Parse
  declaration:
          declaration-specifiers init-declarator-list(opt) ;
*/
gs_bool ParseDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;
        struct token Token;



@@ 2829,7 2829,7 @@ gs_bool ParseDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree
  function-definition:
          declaration-specifiers(opt) declarator declaration-list(opt) compound-statement
*/
gs_bool ParseFunctionDefinition(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseFunctionDefinition(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Function Definition", 4);


@@ 2878,7 2878,7 @@ gs_bool ParseFunctionDefinition(struct tokenizer *Tokenizer, parse_tree_node *Pa
          function-definition
          declaration
*/
gs_bool ParseExternalDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseExternalDeclaration(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "External Declaration", 1);


@@ 2892,7 2892,7 @@ gs_bool ParseExternalDeclaration(struct tokenizer *Tokenizer, parse_tree_node *P
        return(false);
}

gs_bool ParseTranslationUnitI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTranslationUnitI(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Translation Unit'", 2);


@@ 2912,7 2912,7 @@ gs_bool ParseTranslationUnitI(struct tokenizer *Tokenizer, parse_tree_node *Pars
          external-declaration
          translation-unit external-declaration
*/
gs_bool ParseTranslationUnit(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
bool ParseTranslationUnit(struct tokenizer *Tokenizer, parse_tree_node *ParseTree) {
        struct tokenizer Start = *Tokenizer;

        __Parser_ParseTreeUpdate(ParseTree, "Translation Unit", 2);


@@ 2927,7 2927,7 @@ gs_bool ParseTranslationUnit(struct tokenizer *Tokenizer, parse_tree_node *Parse
        return(false);
}

void Parse(gs_buffer *FileContents, gs_bool ShowParseTree) {
void Parse(gs_buffer *FileContents, bool ShowParseTree) {
        parse_tree_allocator Allocator;
        Allocator.Alloc = malloc;
        Allocator.Free = free;


@@ 2940,7 2940,7 @@ void Parse(gs_buffer *FileContents, gs_bool ShowParseTree) {

        TypedefInit(TypedefNames);

        gs_bool Parsing = true;
        bool Parsing = true;
        while(Parsing)
        {
                struct tokenizer Start = Tokenizer;


@@ 2967,7 2967,7 @@ void Parse(gs_buffer *FileContents, gs_bool ShowParseTree) {
                        /* Okay, let's parse! */
                        default:
                        {
                                gs_bool Result = ParseTranslationUnit(&Tokenizer, ParseTree);
                                bool Result = ParseTranslationUnit(&Tokenizer, ParseTree);

                                if(Result && Tokenizer.At == FileEnd)
                                {

M src/tree.c => src/tree.c +13 -15
@@ 1,11 1,9 @@
#ifndef TREE2
#define TREE2
#ifndef TREE
#define TREE

#include <stdint.h>
#include <stddef.h>
#include <errno.h>
#include "gs.h"
#include "lexer.c"

#define DEFAULT_ALLOC_COUNT 2



@@ 21,9 19,9 @@ typedef struct parse_tree_allocator {

typedef struct parse_tree_node {
        parse_tree_allocator Allocator;
        uint32_t NameLength;
        uint32_t Capacity;
        uint32_t NumChildren;
        u32 NameLength;
        u32 Capacity;
        u32 NumChildren;
        token Token;
        char *Name;
        struct parse_tree_node *Children;


@@ 35,8 33,8 @@ void ParseTreeDeinit(parse_tree_node *Node);
void ParseTreeSetName(parse_tree_node *Node, char *Name);
void ParseTreeSetToken(parse_tree_node *Node, token Token);
void ParseTreeSet(parse_tree_node *Self, char *Name, token Token);
void ParseTreeNewChildren(parse_tree_node *Self, uint32_t Count);
void ParseTreePrint(parse_tree_node *Self, uint32_t IndentLevel, uint32_t IndentIncrement);
void ParseTreeNewChildren(parse_tree_node *Self, u32 Count);
void ParseTreePrint(parse_tree_node *Self, u32 IndentLevel, u32 IndentIncrement);

parse_tree_node *__tree_Alloc(parse_tree_allocator Allocator) {
        parse_tree_node *Node = (parse_tree_node *)Allocator.Alloc(sizeof(*Node));


@@ 69,7 67,7 @@ parse_tree_node *ParseTreeInit(parse_tree_allocator Allocator) {

/* Name must be a NULL-terminated string! */
void ParseTreeSetName(parse_tree_node *Node, char *Name) {
        unsigned int NameLength = GSStringLength(Name);
        u32 NameLength = GSStringLength(Name);
        if (Node->Name != NULL) {
                Node->Allocator.Free(Node->Name);
        }


@@ 94,8 92,8 @@ void ParseTreeSet(parse_tree_node *Self, char *Name, token Token) {
}

void __tree_AddChild(parse_tree_node *Self, char *Name) {
        unsigned int NameLength = GSStringLength(Name);
        unsigned int AllocCount = DEFAULT_ALLOC_COUNT;
        u32 NameLength = GSStringLength(Name);
        u32 AllocCount = DEFAULT_ALLOC_COUNT;

        if (Self->Children == NULL) {
                Self->Children = (parse_tree_node *)malloc(sizeof(parse_tree_node) * AllocCount);


@@ 134,7 132,7 @@ void __tree_AddChild(parse_tree_node *Self, char *Name) {
        Self->NumChildren++;
}

void ParseTreeNewChildren(parse_tree_node *Self, unsigned int Count) {
void ParseTreeNewChildren(parse_tree_node *Self, u32 Count) {
        for (int i=0; i<Count; i++) {
                __tree_AddChild(Self, "Empty");
        }


@@ 161,7 159,7 @@ void ParseTreeDeinit(parse_tree_node *Self) {
        Self->Allocator.Free(Self);
}

void ParseTreePrint(parse_tree_node *Self, uint32_t IndentLevel, uint32_t IndentIncrement) {
void ParseTreePrint(parse_tree_node *Self, u32 IndentLevel, u32 IndentIncrement) {
        int MinCompareLength = GSMin(Self->NameLength, 5);
        if (GSStringIsEqual("Empty", Self->Name, MinCompareLength)) return;



@@ 188,4 186,4 @@ void ParseTreePrint(parse_tree_node *Self, uint32_t IndentLevel, uint32_t Indent
        }
}

#endif // TREE2
#endif // TREE