diff --git a/include/arc/std/parser.h b/include/arc/std/parser.h index 837e983..5eedb17 100644 --- a/include/arc/std/parser.h +++ b/include/arc/std/parser.h @@ -46,6 +46,11 @@ typedef struct ARC_ParserTagToken { */ typedef void (* ARC_Parser_InitLexerRulesFn)(ARC_Lexer *lexer); +/** + * @brief TODO: write this +*/ +typedef uint32_t (* ARC_Parser_GetStringIdFn)(ARC_String *string); + /** * @brief TODO: write this */ @@ -100,7 +105,7 @@ void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_ * @param[in] language an arry of ARC_ParserLanguageTags defining a langauge * @param[in] initLexerRulesFn a callback used to initalize the token rules the lexer within the parser will use */ -void ARC_Parser_CreateFromString(ARC_Parser **parser, ARC_String *languageString, ARC_Parser_InitLexerRulesFn initLexerRulesFn); +void ARC_Parser_CreateFromString(ARC_Parser **parser, ARC_String *languageString, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_Parser_GetStringIdFn getStringIdFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData); /** * @brief destroys an ARC_Parser type diff --git a/include/arc/std/parser/csv.h b/include/arc/std/parser/csv.h new file mode 100644 index 0000000..3a5f136 --- /dev/null +++ b/include/arc/std/parser/csv.h @@ -0,0 +1,78 @@ +#ifndef ARC_STD_PARSER_PARSERLANG_H_ +#define ARC_STD_PARSER_PARSERLANG_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "arc/std/parser.h" + +/* + -> NEWLINE | | NEWLINE | LAMBDA + -> WHITESPACE ARROW WHITESPACE + + -> WHITESPACE OR WHITESPACE | + -> WHITESPACE | + -> | + + -> ALPHA_UPPER_CHAR + -> | LAMBDA + -> ALPHA_UPPER_CHAR | UNDERSCORE + + -> LESS_THAN GREATER_THAN + -> | UNDERSCORE + -> | LAMBDA + -> | NUMBER | UNDERSCORE + -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR +*/ + +/* + * @brief creates a parser for the Parser Lang + * + * @note the rules will be inited for the parser lang + * @note the parsed data will be saved as a vector of ARC_ParserLanguageTag + * + * @param[out] parser the parser to create +*/ +void ARC_ParserCSV_CreateAsParser(ARC_Parser **parser, ARC_Parser_GetStringIdFn getStringIdFn); + +#define ARC_PARSERLANG_TOKEN_NULL 0 +#define ARC_PARSERLANG_TOKEN_NUMBER 1 +#define ARC_PARSERLANG_TOKEN_ALPHA_LOWER_CHAR 2 +#define ARC_PARSERLANG_TOKEN_ALPHA_UPPER_CHAR 3 +#define ARC_PARSERLANG_TOKEN_WHITESPACE 4 + +#define ARC_PARSERLANG_TOKEN_NEWLINE_ID 5 +#define ARC_PARSERLANG_TOKEN_NEWLINE_CHAR '\n' +#define ARC_PARSERLANG_TOKEN_LESS_THAN_ID 6 +#define ARC_PARSERLANG_TOKEN_LESS_THAN_CHAR '<' +#define ARC_PARSERLANG_TOKEN_GREATER_THAN_ID 7 +#define ARC_PARSERLANG_TOKEN_GREATER_THAN_CHAR '>' +#define ARC_PARSERLANG_TOKEN_OR_ID 8 +#define ARC_PARSERLANG_TOKEN_OR_CHAR '|' +#define ARC_PARSERLANG_TOKEN_UNDERSCORE_ID 9 +#define ARC_PARSERLANG_TOKEN_UNDERSCORE_CHAR '_' + +#define ARC_PARSERLANG_TOKEN_ARROW_ID 10 +#define ARC_PARSERLANG_TOKEN_ARROW_CSTRING "->" + +#define ARC_PARSERLANG_LAMBDA ARC_PARSER_TAG_LAMBDA +#define ARC_PARSERLANG_LINE 11 +#define ARC_PARSERLANG_BODY 12 +#define ARC_PARSERLANG_ARGUMENTS 13 +#define ARC_PARSERLANG_ARGUMENT 14 +#define ARC_PARSERLANG_TAG_OR_CONSTANT 15 +#define ARC_PARSERLANG_CONSTANT 16 +#define ARC_PARSERLANG_CONSTANT_BODY 17 +#define ARC_PARSERLANG_CONSTANT_CHAR 18 +#define ARC_PARSERLANG_TAG 19 +#define ARC_PARSERLANG_VARIABLE 20 +#define ARC_PARSERLANG_VARIABLE_BODY 21 +#define ARC_PARSERLANG_VARIABLE_CHAR 22 +#define ARC_PARSERLANG_ALPHA_CHAR 23 + +#ifdef __cplusplus +} +#endif + +#endif //ARC_STD_PARSER_PARSERLANG_H_ diff --git a/include/arc/std/parser/helpers.h b/include/arc/std/parser/helpers.h new file mode 100644 index 0000000..e69de29 diff --git a/include/arc/std/parser/parserlang.h b/include/arc/std/parser/parserlang.h index bc28d00..ee884e7 100644 --- a/include/arc/std/parser/parserlang.h +++ b/include/arc/std/parser/parserlang.h @@ -26,11 +26,6 @@ extern "C" { -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR */ -/* - * @brief -*/ -typedef uint32_t (* ARC_ParserLang_GetIdFn)(ARC_String *constant); - /* * @brief creates a parser for the Parser Lang * @@ -39,7 +34,7 @@ typedef uint32_t (* ARC_ParserLang_GetIdFn)(ARC_String *constant); * * @param[out] parser the parser to create */ -void ARC_Parser_CreateAsParserLang(ARC_Parser **parser, ARC_ParserLang_GetIdFn getIdFn); +void ARC_ParserLang_CreateAsParser(ARC_Parser **parser, ARC_Parser_GetStringIdFn getStringIdFn); #define ARC_PARSERLANG_TOKEN_NULL 0 #define ARC_PARSERLANG_TOKEN_NUMBER 1 diff --git a/src/std/lexer.c b/src/std/lexer.c index c4f2033..ce90395 100644 --- a/src/std/lexer.c +++ b/src/std/lexer.c @@ -486,8 +486,6 @@ void ARC_Lexer_InitBasicTokenRules(ARC_Lexer *lexer){ ARC_String_CreateWithStrlen(&whitespaceString, " \t"); ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharInStringRule(ARC_LEXER_TOKEN_WHITESPACE, whitespaceString)); ARC_String_Destroy(whitespaceString); - //TEMP FIX: - //ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(ARC_LEXER_TOKEN_WHITESPACE, ' ')); //single char tokens ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(ARC_LEXER_TOKEN_NEWLINE_ID , ARC_LEXER_TOKEN_NEWLINE_CHAR )); diff --git a/src/std/parser.c b/src/std/parser.c index c04e9d2..8846e37 100644 --- a/src/std/parser.c +++ b/src/std/parser.c @@ -1,3 +1,4 @@ +#include "arc/std/parser/parserlang.h" #include "arc/std/parser.h" #include "arc/std/bool.h" #include "arc/std/errno.h" @@ -100,7 +101,26 @@ void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_ ARC_Parser_Create(parser, &languageAsArray, initLexerRulesFn, createDataFn, destroyDataFn, userData); } -void ARC_Parser_CreateFromString(ARC_Parser **parser, ARC_String *languageString, ARC_Parser_InitLexerRulesFn initLexerRulesFn){ +void ARC_Parser_CreateFromString(ARC_Parser **parser, ARC_String *languageString, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_Parser_GetStringIdFn getStringIdFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData){ + //create the language from the string + ARC_Parser *parserlangParser; + ARC_ParserLang_CreateAsParser(&parserlangParser, getStringIdFn); + if(arc_errno){ + ARC_DEBUG_LOG_ERROR_WITH_VARIABLES("ARC_Parser_CreateFromString(parser, languageString, initLexerRulesFn, getStringIdFn, createDataFn, destroyDataFn, userData), failed to create language from: %s", languageString->data); + return; + } + + //copy the string because parse will destroy the string that is passed in + ARC_String *parserLangString; + ARC_String_Copy(&parserLangString, languageString); + ARC_Parser_Parse(parserlangParser, &parserLangString); + + //create the parser from the parsed language + ARC_Vector *language = (ARC_Vector *)ARC_Parser_GetData(parserlangParser); + ARC_Parser_CreateFromVector(parser, language, initLexerRulesFn, createDataFn, destroyDataFn, userData); + + //cleanup + ARC_Parser_Destroy(parserlangParser); } void ARC_Parser_Destroy(ARC_Parser *parser){ @@ -122,7 +142,7 @@ void ARC_Parser_Destroy(ARC_Parser *parser){ free(parser->createDataFn); } - //free the data and the deletion function callback + //do the same thing as clear but this time pass in the userData as well to clean that up if(parser->destroyDataFn != NULL){ (*(parser->destroyDataFn))(parser->data, parser->userData); free(parser->destroyDataFn); @@ -326,7 +346,7 @@ void ARC_Parser_ParseFile(ARC_Parser *parser, ARC_String *path){ void ARC_Parser_ClearData(ARC_Parser *parser){ //check if that data exists and the destructor exists to make sure they can be run if(parser->data != NULL && parser->destroyDataFn != NULL){ - (*(parser->destroyDataFn))(parser->data, parser->userData); + (*(parser->destroyDataFn))(parser->data, NULL); } //TODO: might want to error here diff --git a/src/std/parser/csv.c b/src/std/parser/csv.c new file mode 100644 index 0000000..e69de29 diff --git a/src/std/parser/helpers.c b/src/std/parser/helpers.c new file mode 100644 index 0000000..e69de29 diff --git a/src/std/parser/parserlang.c b/src/std/parser/parserlang.c index 9ca24a2..41c4a7b 100644 --- a/src/std/parser/parserlang.c +++ b/src/std/parser/parserlang.c @@ -113,7 +113,7 @@ void ARC_ParserLangParsedData_CreateTagString(ARC_String **tagString, ARC_Parser /* -> WHITESPACE | */ -void ARC_ParserLangParsedData_GetArgumentTag(ARC_Vector *orTokensOrTags, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ +void ARC_ParserLangParsedData_GetArgumentTag(ARC_Vector *orTokensOrTags, ARC_ParserTagToken *tagToken, ARC_Parser_GetStringIdFn *getStringIdFn){ for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ ARC_ParserTagToken *childTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index); @@ -124,7 +124,7 @@ void ARC_ParserLangParsedData_GetArgumentTag(ARC_Vector *orTokensOrTags, ARC_Par switch(childTagToken->id){ case ARC_PARSERLANG_ARGUMENT: //recurse to check all the arguments - ARC_ParserLangParsedData_GetArgumentTag(orTokensOrTags, childTagToken, getIdFn); + ARC_ParserLangParsedData_GetArgumentTag(orTokensOrTags, childTagToken, getStringIdFn); continue; case ARC_PARSERLANG_TAG_OR_CONSTANT: @@ -134,7 +134,7 @@ void ARC_ParserLangParsedData_GetArgumentTag(ARC_Vector *orTokensOrTags, ARC_Par //get the id of the tag/constant ARC_ParserLangParsedData_RecurseStringAdd(&tagOrConstantString, childTagToken); id = (uint32_t *)malloc(sizeof(uint32_t)); - *id = (*getIdFn)(tagOrConstantString); + *id = (*getStringIdFn)(tagOrConstantString); //add the id to the matching or vector ARC_Vector_Add(orTokensOrTags, (void *)id); @@ -153,7 +153,7 @@ void ARC_ParserLangParsedData_GetArgumentTag(ARC_Vector *orTokensOrTags, ARC_Par /* -> WHITESPACE OR WHITESPACE | */ -void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ +void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_ParserTagToken *tagToken, ARC_Parser_GetStringIdFn *getStringIdFn){ for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ ARC_ParserTagToken *childTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index); @@ -169,7 +169,7 @@ void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_Pars tokensOrTagsIndex = ARC_Vector_GetSize(tokensOrTags); orTokensOrTags = (ARC_Vector *)ARC_Vector_Get(tokensOrTags, tokensOrTagsIndex - 1); - ARC_ParserLangParsedData_GetArgumentTag(orTokensOrTags, childTagToken, getIdFn); + ARC_ParserLangParsedData_GetArgumentTag(orTokensOrTags, childTagToken, getStringIdFn); continue; case ARC_PARSERLANG_TOKEN_OR_ID: @@ -182,7 +182,7 @@ void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_Pars case ARC_PARSERLANG_ARGUMENTS: //recurse to check all the arguments - ARC_ParserLangParsedData_GetArgumentsTag(tokensOrTags, childTagToken, getIdFn); + ARC_ParserLangParsedData_GetArgumentsTag(tokensOrTags, childTagToken, getStringIdFn); continue; default: @@ -192,7 +192,7 @@ void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_Pars } } -void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ +void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagToken *tagToken, ARC_Parser_GetStringIdFn *getStringIdFn){ //create the tag to store the body in ARC_ParserTag *bodyTag = (ARC_ParserTag *)malloc(sizeof(ARC_ParserTag)); @@ -205,7 +205,7 @@ void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagTo ARC_ParserLangParsedData_CreateTagString(&tagIdString, tagIdToken); //get the tag id as a uint32_t - bodyTag->tagId = (*getIdFn)(tagIdString); + bodyTag->tagId = (*getStringIdFn)(tagIdString); //cleanup the tagIdString ARC_String_Destroy(tagIdString); @@ -226,7 +226,7 @@ void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagTo //skipping whitespace and arrow tokens, the arguments index starts at 4 ARC_ParserTagToken *argumentsToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, 4); - ARC_ParserLangParsedData_GetArgumentsTag(tokensOrTags, argumentsToken, getIdFn); + ARC_ParserLangParsedData_GetArgumentsTag(tokensOrTags, argumentsToken, getStringIdFn); //initialize the tokens or tags array to the needed size bodyTag->tokensOrTagsSize = ARC_Vector_GetSize(tokensOrTags); @@ -255,7 +255,7 @@ void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagTo ARC_Vector_Destroy(tokensOrTags); } -void ARC_ParserLangParsedData_RunLineTag(ARC_Vector *tags, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ +void ARC_ParserLangParsedData_RunLineTag(ARC_Vector *tags, ARC_ParserTagToken *tagToken, ARC_Parser_GetStringIdFn *getStringIdFn){ //loop through the tags either going to the next line or the next body for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ ARC_ParserTagToken *childTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index); @@ -266,12 +266,12 @@ void ARC_ParserLangParsedData_RunLineTag(ARC_Vector *tags, ARC_ParserTagToken *t switch(childTagToken->id){ //recuse to run the next line case ARC_PARSERLANG_LINE: - ARC_ParserLangParsedData_RunLineTag(tags, childTagToken, getIdFn); + ARC_ParserLangParsedData_RunLineTag(tags, childTagToken, getStringIdFn); continue; //get a tag case ARC_PARSERLANG_BODY: - ARC_ParserLangParsedData_CreateBodyTag(&tag, childTagToken, getIdFn); + ARC_ParserLangParsedData_CreateBodyTag(&tag, childTagToken, getStringIdFn); ARC_Vector_Add(tags, (void *)tag); continue; @@ -283,7 +283,7 @@ void ARC_ParserLangParsedData_RunLineTag(ARC_Vector *tags, ARC_ParserTagToken *t //private function to create the saved data for the language void ARC_ParserLang_CreateDataFn(void **data, ARC_ParserTagToken *parsedData, void *userData){ - ARC_ParserLang_GetIdFn *getIdFn = (ARC_ParserLang_GetIdFn *)userData; + ARC_Parser_GetStringIdFn *getStringIdFn = (ARC_Parser_GetStringIdFn *)userData; //make sure there is parsed data to use if(parsedData == NULL){ @@ -304,13 +304,15 @@ void ARC_ParserLang_CreateDataFn(void **data, ARC_ParserTagToken *parsedData, vo } //load the language into a vector recursivly - ARC_ParserLangParsedData_RunLineTag(*((ARC_Vector **)data), parsedData, getIdFn); + ARC_ParserLangParsedData_RunLineTag(*((ARC_Vector **)data), parsedData, getStringIdFn); } //private function to destroy the saved data for the language void ARC_ParserLang_DestroyDataFn(void *data, void *userData){ - ARC_ParserLang_GetIdFn *getIdFn = (ARC_ParserLang_GetIdFn *)userData; - free(getIdFn); + if(userData != NULL){ + ARC_Parser_GetStringIdFn *getStringIdFn = (ARC_Parser_GetStringIdFn *)userData; + free(getStringIdFn); + } //check if there is data to free if((ARC_Vector *)data != NULL){ @@ -318,7 +320,7 @@ void ARC_ParserLang_DestroyDataFn(void *data, void *userData){ } } -void ARC_Parser_CreateAsParserLang(ARC_Parser **parser, ARC_ParserLang_GetIdFn getIdFn){ +void ARC_ParserLang_CreateAsParser(ARC_Parser **parser, ARC_Parser_GetStringIdFn getStringIdFn){ // -> NEWLINE | | NEWLINE | LAMBDA uint32_t *line[] = { (uint32_t[]){ 3, ARC_PARSERLANG_BODY, ARC_PARSERLANG_TOKEN_NEWLINE_ID, ARC_PARSERLANG_LINE }, (uint32_t[]){ 1, ARC_PARSERLANG_BODY }, (uint32_t[]){ 2, ARC_PARSERLANG_TOKEN_NEWLINE_ID, ARC_PARSERLANG_LINE }, (uint32_t[]){ 1, ARC_PARSERLANG_LAMBDA } }; @@ -383,9 +385,9 @@ void ARC_Parser_CreateAsParserLang(ARC_Parser **parser, ARC_ParserLang_GetIdFn g ARC_ParserData_DestroyFn destroyDataFn = ARC_ParserLang_DestroyDataFn; //this will be cleaned up by the destroyDataFn - ARC_ParserLang_GetIdFn *newGetIdFn = (ARC_ParserLang_GetIdFn *)malloc(sizeof(ARC_ParserLang_GetIdFn)); - *newGetIdFn = getIdFn; + ARC_Parser_GetStringIdFn *newGetStringIdFn = (ARC_Parser_GetStringIdFn *)malloc(sizeof(ARC_Parser_GetStringIdFn)); + *newGetStringIdFn = getStringIdFn; //create the parserlang - ARC_Parser_Create(parser, &parserLanguageArray, ARC_ParserLang_InitLexerRulesFn, &createDataFn, &destroyDataFn, newGetIdFn); + ARC_Parser_Create(parser, &parserLanguageArray, ARC_ParserLang_InitLexerRulesFn, &createDataFn, &destroyDataFn, (void *)newGetStringIdFn); } diff --git a/tests/std/parser.c b/tests/std/parser.c index 78a976f..70c1d44 100644 --- a/tests/std/parser.c +++ b/tests/std/parser.c @@ -3,8 +3,8 @@ #include "arc/std/parser.h" #include "arc/std/lexer.h" #include "arc/std/vector.h" -#include "arc/std/parser/parserlang.h" #include +#include #define LAMBDA ARC_PARSER_TAG_LAMBDA #define CHAR ARC_LEXER_TOKEN_ALPHALOWERCHAR @@ -13,7 +13,7 @@ #define VARIABLE_NAME 24 #define VARIABLE 25 -const uint32_t TEST_ALPHA_LAMBDA = 0; +const uint32_t TEST_LAMBDA = 0; const uint32_t TEST_ALPHA_LOWER_CHAR = 1; const uint32_t TEST_ALPHA_UPPER_CHAR = 2; const uint32_t TEST_ALPHA_CHAR = 3; @@ -41,6 +41,10 @@ void TEST_ParserData_CreateStringFn(void **data, ARC_ParserTagToken *parsedData, } void TEST_ParserData_DestroyStringFn(void *data, void *userData){ + if(data == NULL){ + return; + } + ARC_String_Destroy((ARC_String *)data); } @@ -135,7 +139,7 @@ void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){ // /* ~ cleanup ~ */ // ARC_Parser_Destroy(parser); //} -// + //ARC_TEST(Parser_Basic_ParseError){ // ARC_Parser *parser; // ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL); @@ -180,7 +184,7 @@ void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){ // //reset for next test // arc_errno = 0; //} -// + //ARC_TEST(Parser_Basic_GetParsedValue){ // ARC_Parser *parser; // ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, &destroyStringFn, NULL); @@ -203,51 +207,7 @@ void TEST_Parser_InitLexerRulesFn(ARC_Lexer *lexer){ // /* ~ cleanup ~ */ // ARC_Parser_Destroy(parser); //} - -/* ~ parserlang tests ~ */ -uint32_t TEST_ParserLang_GetIdFn(ARC_String *string){ - if(ARC_String_EqualsCStringWithStrlen(string, "")){ - return TEST_ALPHA_CHAR; - } - - if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){ - return TEST_ALPHA_LOWER_CHAR; - } - - if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){ - return TEST_ALPHA_UPPER_CHAR; - } - - printf("tag: %s\n", string->data); - return 0; -} - -ARC_TEST(Parser_ParserLang_BasicTest){ - ARC_Parser *parser; - ARC_Parser_CreateAsParserLang(&parser, TEST_ParserLang_GetIdFn); - - ARC_String *tempString; - ARC_String_CreateWithStrlen(&tempString, " -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR\n"); - - //this destroys string, so no need for cleanup - ARC_Parser_Parse(parser, &tempString); - ARC_CHECK(arc_errno == 0); - - void *data = ARC_Parser_GetData(parser); - ARC_ParserTag *tag = ARC_Vector_Get((ARC_Vector *)data, 0); - - ARC_CHECK(tag->tagId == TEST_ALPHA_CHAR); - - ARC_CHECK(tag->tokensOrTagsSize == 2); - ARC_CHECK(tag->tokensOrTags[0][0] == 1); - ARC_CHECK(tag->tokensOrTags[0][1] == TEST_ALPHA_LOWER_CHAR); - ARC_CHECK(tag->tokensOrTags[1][0] == 1); - ARC_CHECK(tag->tokensOrTags[1][1] == TEST_ALPHA_UPPER_CHAR); - - ARC_Parser_Destroy(parser); - -} - +// //ARC_TEST(Parser_ParserLang_BasicVector){ // ARC_Vector *testLanguage; // ARC_Vector_Create(&testLanguage, NULL, NULL); @@ -257,7 +217,7 @@ ARC_TEST(Parser_ParserLang_BasicTest){ // ARC_Vector_Add(testLanguage, testTags + 2); // // ARC_Parser *parser; -// ARC_Parser_CreateFromVector(&parser, testLanguage, TEST_Parser_InitLexerRulesFn, NULL, NULL); +// ARC_Parser_CreateFromVector(&parser, testLanguage, TEST_Parser_InitLexerRulesFn, NULL, NULL, NULL); // // ARC_String *tempString; // ARC_String_CreateWithStrlen(&tempString, "variablename"); @@ -271,3 +231,109 @@ ARC_TEST(Parser_ParserLang_BasicTest){ // // ARC_CHECK(arc_errno == 0); //} + +/* ~ parser tests ~ */ +void TEST_Parser_InitBasicLexerTokenRules(ARC_Lexer *lexer){ + //null + ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharRule(TEST_LAMBDA, 0)); + + //alpha char + ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_ALPHA_LOWER_CHAR, 'a', 'z')); + ARC_Lexer_RegisterTokenRule(lexer, ARC_LexerTokenRule_CreateAndReturnMatchCharOrBetween(TEST_ALPHA_UPPER_CHAR, 'A', 'Z')); +} + +uint32_t TEST_Parser_GetStringIdFn(ARC_String *string){ + if(ARC_String_EqualsCStringWithStrlen(string, "")){ + return TEST_ALPHA_CHAR; + } + + if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){ + return TEST_ALPHA_LOWER_CHAR; + } + + if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){ + return TEST_ALPHA_UPPER_CHAR; + } + + return ~(uint32_t)0; +} + +void TEST_ParserData_CreateCharFn(void **data, ARC_ParserTagToken *parsedData, void *userData){ + if(parsedData == NULL){ + *data = NULL; + return; + } + + char *alphaChar = (char *)malloc(sizeof(char)); + + ARC_ParserTagToken *tagToken = (ARC_ParserTagToken *)ARC_Vector_Get(parsedData->tagTokens, 0); + *alphaChar = tagToken->token->data->data[0]; + + *data = (void *)alphaChar; +} + +void TEST_ParserData_DestroyCharFn(void *data, void *userData){ + if(data == NULL){ + return; + } + + free((char *)data); +} + +ARC_TEST(Parser_Parser_BasicCreateWithStringTest){ + ARC_Parser *parser; + + /* ~ create the language ~ */ + ARC_String *languageString; + ARC_String_CreateWithStrlen(&languageString, " -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR\n"); + + ARC_ParserData_CreateFn createCharFn = TEST_ParserData_CreateCharFn; + ARC_ParserData_DestroyFn destroyCharFn = TEST_ParserData_DestroyCharFn; + ARC_Parser_CreateFromString(&parser, languageString, TEST_Parser_InitBasicLexerTokenRules, TEST_Parser_GetStringIdFn, &createCharFn, &destroyCharFn, NULL); + + ARC_String_Destroy(languageString); + + ARC_CHECK(arc_errno == 0); + + + /* ~ check if a can be parsed ~ */ + ARC_String *tempString; + ARC_String_CreateWithStrlen(&tempString, "a"); + + ARC_Parser_Parse(parser, &tempString); + + char *data = (char *)ARC_Parser_GetData(parser); + + ARC_CHECK(*data == 'a'); + + ARC_Parser_ClearData(parser); + + + /* ~ check if Z can be parsed ~ */ + ARC_String_CreateWithStrlen(&tempString, "Z"); + + ARC_Parser_Parse(parser, &tempString); + + data = (char *)ARC_Parser_GetData(parser); + + ARC_CHECK(*data == 'Z'); + + ARC_Parser_ClearData(parser); + + + /* ~ check if 8 errors ~ */ + ARC_String_CreateWithStrlen(&tempString, "8"); + + ARC_Parser_Parse(parser, &tempString); + + data = (char *)ARC_Parser_GetData(parser); + + ARC_CHECK(arc_errno == ARC_ERRNO_DATA); + arc_errno = 0; + + ARC_Parser_ClearData(parser); + + + //cleanup + ARC_Parser_Destroy(parser); +} diff --git a/tests/std/parser/csv.c b/tests/std/parser/csv.c new file mode 100644 index 0000000..e69de29 diff --git a/tests/std/parser/parserlang.c b/tests/std/parser/parserlang.c new file mode 100644 index 0000000..a814cb2 --- /dev/null +++ b/tests/std/parser/parserlang.c @@ -0,0 +1,52 @@ +#include "../../test.h" +#include "arc/std/errno.h" +#include "arc/std/parser.h" +#include "arc/std/string.h" +#include "arc/std/parser/parserlang.h" + +const uint32_t TEST_LAMBDA = 0; +const uint32_t TEST_ALPHA_LOWER_CHAR = 1; +const uint32_t TEST_ALPHA_UPPER_CHAR = 2; +const uint32_t TEST_ALPHA_CHAR = 3; + +/* ~ parserlang tests ~ */ +uint32_t TEST_ParserLang_GetIdFn(ARC_String *string){ + if(ARC_String_EqualsCStringWithStrlen(string, "")){ + return TEST_ALPHA_CHAR; + } + + if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_LOWER_CHAR")){ + return TEST_ALPHA_LOWER_CHAR; + } + + if(ARC_String_EqualsCStringWithStrlen(string, "ALPHA_UPPER_CHAR")){ + return TEST_ALPHA_UPPER_CHAR; + } + + return ~(uint32_t)0; +} + +ARC_TEST(Parser_ParserLang_BasicTest){ + ARC_Parser *parser; + ARC_ParserLang_CreateAsParser(&parser, TEST_ParserLang_GetIdFn); + + ARC_String *tempString; + ARC_String_CreateWithStrlen(&tempString, " -> ALPHA_LOWER_CHAR | ALPHA_UPPER_CHAR\n"); + + //this destroys string, so no need for cleanup + ARC_Parser_Parse(parser, &tempString); + ARC_CHECK(arc_errno == 0); + + void *data = ARC_Parser_GetData(parser); + ARC_ParserTag *tag = ARC_Vector_Get((ARC_Vector *)data, 0); + + ARC_CHECK(tag->tagId == TEST_ALPHA_CHAR); + + ARC_CHECK(tag->tokensOrTagsSize == 2); + ARC_CHECK(tag->tokensOrTags[0][0] == 1); + ARC_CHECK(tag->tokensOrTags[0][1] == TEST_ALPHA_LOWER_CHAR); + ARC_CHECK(tag->tokensOrTags[1][0] == 1); + ARC_CHECK(tag->tokensOrTags[1][1] == TEST_ALPHA_UPPER_CHAR); + + ARC_Parser_Destroy(parser); +}