\page standard-parser ARC_Parser

# Basic Overview

The ::ARC_Parser type is a generic parsing type. To create the type it is recommeded you use ARC_Parser_CreateFromString(

# Basic Example

```c
const char *languageCString =
    "<variable>     -> ALPHA_UPPER_CHAR <variableName> | ALPHA_LOWER_CHAR <variableName> | UNDERSCORE <variableName>\n"
    "<variableName> -> <variableChar> <variableName> | LAMBDA\n"
    "<variableChar> -> ALPHA_UPPER_CHAR | ALPHA_LOWER_CHAR | UNDERSCORE | NUMBER\n";

#define ARC_DOC_UNDERSCORE       1
#define ARC_DOC_NUMBER           2
#define ARC_DOC_ALPHA_UPPER_CHAR 3
#define ARC_DOC_ALPHA_LOWER_CHAR 4
#define ARC_DOC_VARIABLE         5
#define ARC_DOC_VARIABLE_NAME    6
#define ARC_DOC_VARIABLE_CHAR    7

void ARC_TEST_InitLexerRulesFn(ARC_Lexer *lexer){
    ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(ARC_TEST_TAG_UNDERSCORE, '_' ));

    ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(ARC_TEST_TAG_NUMBER          , '0', '9'));
    ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(ARC_TEST_TAG_ALPHA_LOWER_CHAR, 'a', 'z'));
    ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(ARC_TEST_TAG_ALPHA_UPPER_CHAR, 'A', 'Z'));
}

uint32_t ARC_TEST_GetStringIdFn(ARC_String *string){
    if(ARC_String_EqualsCStringWithStrlen(string, "LAMBDA")){
        return ARC_PARSER_TAG_LAMBDA;
    }

    if(ARC_String_EqualsCStringWithStrlen(string, "UNDERSCORE")){
        return ARC_TEST_TAG_UNDERSCORE;
    }

    if(ARC_String_EqualsCStringWithStrlen(string, "NUMBER")){
        return ARC_TEST_TAG_NUMBER;
    }
    if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){
        return ARC_TEST_TAG_ALPHA_UPPER_CHAR;
    }
    if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){
        return ARC_TEST_TAG_ALPHA_LOWER_CHAR;
    }

    if(ARC_String_EqualsCStringWithStrlen(string, "<variable>")){
        return ARC_TEST_TAG_VARIABLE;
    }
    if(ARC_String_EqualsCStringWithStrlen(string, "<variableName>")){
        return ARC_TEST_TAG_VARIABLE_NAME;
    }
    if(ARC_String_EqualsCStringWithStrlen(string, "<variableChar>")){
        return ARC_TEST_TAG_VARIABLE_CHAR;
    }

    return ~(uint32_t)0;
}

void ARC_TESTData_CreateFn(void **data, ARC_ParserTagToken *parsedData, void *userData){
}

void ARC_TESTData_DestroyFn(void *data, ARC_Bool clear, void *userData){
}

int main(){
    ARC_String *languageString;
    ARC_String_CreateWithStrlen(&languageString, (char *)languageCString);

    ARC_Parser *parser;
    ARC_ParserData_CreateFn  createCharFn  = ARC_TESTData_CreateFn;
    ARC_ParserData_DestroyFn destroyCharFn = ARC_TESTData_DestroyFn;
    ARC_Parser_CreateFromString(&parser, languageString, ARC_TEST_InitLexerRulesFn, ARC_TEST_GetStringIdFn, &createCharFn, &destroyCharFn, NULL);
    ARC_String_Destroy(languageString);

    //this destroys string, so no need for cleanup
    ARC_String *tempString;
    ARC_String_CreateWithStrlen(&tempString, "variable123");
    ARC_Parser_Parse(parser, &tempString);

    // cleanup
    ARC_Parser_Destroy(parser);
}
```