From 16821e8411745a77c4b191379114c0657eb76549 Mon Sep 17 00:00:00 2001 From: herbglitch Date: Mon, 2 Dec 2024 02:34:01 -0700 Subject: [PATCH] bout halfway complete with parserlang, also added userdata to parser --- include/arc/std/parser.h | 6 +- include/arc/std/parser/parserlang.h | 4 +- src/input/input.c | 5 +- src/std/parser.c | 22 ++-- src/std/parser/parserlang.c | 186 ++++++++++++++++++++++++---- tests/std/parser.c | 11 +- 6 files changed, 190 insertions(+), 44 deletions(-) diff --git a/include/arc/std/parser.h b/include/arc/std/parser.h index 98cd618..837e983 100644 --- a/include/arc/std/parser.h +++ b/include/arc/std/parser.h @@ -54,7 +54,7 @@ typedef void (* ARC_ParserData_CreateFn)(void **data, ARC_ParserTagToken *parsed /** * @brief TODO: write this */ -typedef void (* ARC_ParserData_DestroyFn)(void *data); +typedef void (* ARC_ParserData_DestroyFn)(void *data, void *userData); /** * @brief creates an ARC_Parser type @@ -76,7 +76,7 @@ typedef void (* ARC_ParserData_DestroyFn)(void *data); * @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_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, void *createUserData, ARC_ParserData_DestroyFn *destroyDataFn); +void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData); /** * @brief creates an ARC_Parser type from an arc vector @@ -85,7 +85,7 @@ void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_Init * @param[in] language an vector 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_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, void *createUserData, ARC_ParserData_DestroyFn *destroyDataFn); +void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData); /** * @brief creates an ARC_Parser type from a string diff --git a/include/arc/std/parser/parserlang.h b/include/arc/std/parser/parserlang.h index b063d06..61cee9c 100644 --- a/include/arc/std/parser/parserlang.h +++ b/include/arc/std/parser/parserlang.h @@ -29,7 +29,7 @@ extern "C" { /* * @brief */ -typedef uint32_t (* ARC_ParserLang_GetConstId)(ARC_String *constant); +typedef uint32_t (* ARC_ParserLang_GetIdFn)(ARC_String *constant); /* * @brief creates a parser for the Parser Lang @@ -39,7 +39,7 @@ typedef uint32_t (* ARC_ParserLang_GetConstId)(ARC_String *constant); * * @param[out] parser the parser to create */ -void ARC_Parser_CreateAsParserLang(ARC_Parser **parser); +void ARC_Parser_CreateAsParserLang(ARC_Parser **parser, ARC_ParserLang_GetIdFn getIdFn); #define ARC_PARSERLANG_TOKEN_NULL 0 #define ARC_PARSERLANG_TOKEN_NUMBER 1 diff --git a/src/input/input.c b/src/input/input.c index dcea03a..636edf8 100644 --- a/src/input/input.c +++ b/src/input/input.c @@ -1,5 +1,7 @@ #include "arc/input/input.h" +#include "arc/std/bool.h" + #include void ARC_Input_CreateWithEngineData(ARC_Input **input, ARC_EngineData *data){ @@ -10,8 +12,9 @@ void ARC_Input_Destroy(ARC_Input *input){ printf("No Input Backend Selected\n"); } -void ARC_Input_Update(ARC_Input *input){ +ARC_Bool ARC_Input_Update(ARC_Input *input){ printf("No Input Backend Selected\n"); + return ARC_True; } ARC_Keyboard *ARC_Input_GetKeyboard(ARC_Input *input){ diff --git a/src/std/parser.c b/src/std/parser.c index d9b4d6c..54b65b9 100644 --- a/src/std/parser.c +++ b/src/std/parser.c @@ -13,13 +13,13 @@ struct ARC_Parser { ARC_Lexer *lexer; void *data; - void *createUserData; + void *userData; ARC_ParserData_CreateFn *createDataFn; ARC_ParserData_DestroyFn *destroyDataFn; }; -void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, void *createUserData, ARC_ParserData_DestroyFn *destroyDataFn){ +void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData){ *parser = (ARC_Parser *)malloc(sizeof(ARC_Parser)); //set the language size to 0 and data to NULL in case the language is NULL @@ -59,14 +59,20 @@ void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_Init //register instructions to the lexer initLexerRulesFn(((*parser)->lexer)); - //create the data and copy the creation function if the creation function exists + //set the data to null (the parse function is what creates it) (*parser)->data = NULL; + + //set the userData for the create callback function + (*parser)->userData = userData; + + //init the create function callback with null, then copy the callback if it exists (*parser)->createDataFn = NULL; if(createDataFn != NULL){ (*parser)->createDataFn = (ARC_ParserData_CreateFn *)malloc(sizeof(ARC_ParserData_CreateFn)); *((*parser)->createDataFn) = *createDataFn; } + //init the destroy function callback with null, then copy the callback if it exists (*parser)->destroyDataFn = NULL; if(createDataFn != NULL){ (*parser)->destroyDataFn = (ARC_ParserData_DestroyFn *)malloc(sizeof(ARC_ParserData_DestroyFn)); @@ -74,7 +80,7 @@ void ARC_Parser_Create(ARC_Parser **parser, ARC_Array *language, ARC_Parser_Init } } -void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, void *createUserData, ARC_ParserData_DestroyFn *destroyDataFn){ +void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_Parser_InitLexerRulesFn initLexerRulesFn, ARC_ParserData_CreateFn *createDataFn, ARC_ParserData_DestroyFn *destroyDataFn, void *userData){ //creates the variables to copy the vector into const uint32_t languageSize = ARC_Vector_GetSize(language); ARC_ParserTag languageArray[languageSize]; @@ -91,7 +97,7 @@ void ARC_Parser_CreateFromVector(ARC_Parser **parser, ARC_Vector *language, ARC_ }; //create the parser - ARC_Parser_Create(parser, &languageAsArray, initLexerRulesFn, createDataFn, createUserData, destroyDataFn); + ARC_Parser_Create(parser, &languageAsArray, initLexerRulesFn, createDataFn, destroyDataFn, userData); } void ARC_Parser_CreateFromString(ARC_Parser **parser, ARC_String *languageString, ARC_Parser_InitLexerRulesFn initLexerRulesFn){ @@ -118,7 +124,7 @@ void ARC_Parser_Destroy(ARC_Parser *parser){ //free the data and the deletion function callback if(parser->destroyDataFn != NULL){ - (*(parser->destroyDataFn))(parser->data); + (*(parser->destroyDataFn))(parser->data, parser->userData); free(parser->destroyDataFn); } @@ -296,7 +302,7 @@ void ARC_Parser_Parse(ARC_Parser *parser, ARC_String **data){ //create the data if the creation callback exists if(parser->createDataFn != NULL){ - (*(parser->createDataFn))(&(parser->data), tagToken, parser->createUserData); + (*(parser->createDataFn))(&(parser->data), tagToken, parser->userData); } //cleanup @@ -318,7 +324,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->destroyDataFn))(parser->data, parser->userData); } //TODO: might want to error here diff --git a/src/std/parser/parserlang.c b/src/std/parser/parserlang.c index da08956..0d0a6c2 100644 --- a/src/std/parser/parserlang.c +++ b/src/std/parser/parserlang.c @@ -1,4 +1,5 @@ #include "arc/std/parser/parserlang.h" +#include "arc/std/errno.h" #include "arc/std/lexer.h" #include "arc/std/parser.h" #include "arc/std/string.h" @@ -6,29 +7,6 @@ #include #include -/* - -> 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 -*/ - //private function to initalize the lexer rules for the language void ARC_ParserLang_InitLexerRulesFn(ARC_Lexer *lexer){ //null @@ -61,6 +39,25 @@ void ARC_ParserLang_InitLexerRulesFn(ARC_Lexer *lexer){ ARC_String_Destroy(arrowString); } +/* + -> 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 +*/ + void ARC_ParserLang_VectorDestroyParserTagFn(void *data){ ARC_ParserTag *currentTag = (ARC_ParserTag *)data; @@ -76,21 +73,152 @@ void ARC_ParserLang_VectorDestroyParserTagFn(void *data){ free(currentTag); } +void ARC_ParserLangParsedData_RecurseStringAdd(ARC_String **data, ARC_ParserTagToken *tagToken){ + if(tagToken->token != NULL){ + //less than rule does not have a string so add it manually and return + if(tagToken->token->rule == ARC_PARSERLANG_TOKEN_LESS_THAN_ID){ + char tokenChar = ARC_PARSERLANG_TOKEN_LESS_THAN_CHAR; + ARC_String_AppendCString(data, &tokenChar, 1); + return; + } + + //greater than rule does not have a string so add it manually and return + if(tagToken->token->rule == ARC_PARSERLANG_TOKEN_GREATER_THAN_ID){ + char tokenChar = ARC_PARSERLANG_TOKEN_GREATER_THAN_CHAR; + ARC_String_AppendCString(data, &tokenChar, 1); + return; + } + + ARC_String_Append(data, tagToken->token->data); + return; + } + + //TODO: probs don't need this + if(tagToken->tagTokens == NULL){ + return; + } + + for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ + ARC_ParserLangParsedData_RecurseStringAdd(data, (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index)); + } +} + +void ARC_ParserLangParsedData_CreateTagString(ARC_String **tagString, ARC_ParserTagToken *tagToken){ + ARC_String_Create(tagString, NULL, 0); + + for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ + ARC_ParserTagToken *childTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index); + + ARC_ParserLangParsedData_RecurseStringAdd(tagString, childTagToken); + } +} + +void ARC_ParserLangParsedData_GetArgumentsTag(ARC_Vector *tokensOrTags, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ + for(uint32_t index = 0; index < ARC_Vector_GetSize(tagToken->tagTokens); index++){ + //TODO: write this + //ARC_ParserTagToken *childTagToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, index); + + } +} + +void ARC_ParserLangParsedData_CreateBodyTag(ARC_ParserTag **tag, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ + //create the tag to store the body in + ARC_ParserTag *bodyTag = (ARC_ParserTag *)malloc(sizeof(ARC_ParserTag)); + + /* ~ Tag Id ~ */ + //the first tag will always be the tagId, and as the rule is validated there is no need to check for NULL + ARC_ParserTagToken *tagIdToken = (ARC_ParserTagToken *)ARC_Vector_Get(tagToken->tagTokens, 0); + + //get the tagId as a string + ARC_String *tagIdString; + ARC_ParserLangParsedData_CreateTagString(&tagIdString, tagIdToken); + + //get the tag id as a uint32_t + bodyTag->tagId = (*getIdFn)(tagIdString); + + //cleanup the tagIdString + ARC_String_Destroy(tagIdString); + + /* ~ Tokens Or Tags Array ~ */ + //create a vector to store the tokens and tags in, we will not add a destroy as we will move those values to an array (instead of copying them) + ARC_Vector *tokensOrTags; + ARC_Vector_Create(&tokensOrTags, NULL, NULL); + + //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); + + //move the data from the vector to an array + bodyTag->tokensOrTagsSize = ARC_Vector_GetSize(tokensOrTags); + bodyTag->tokensOrTags = (uint32_t **)malloc(sizeof(uint32_t *) * bodyTag->tokensOrTagsSize); + for(uint32_t index = 0; index < bodyTag->tokensOrTagsSize; index++){ + bodyTag->tokensOrTags[index] = (uint32_t *)ARC_Vector_Get(tokensOrTags, index); + } + + //cleanup + ARC_Vector_Destroy(tokensOrTags); +} + +void ARC_ParserLangParsedData_RunLineTag(ARC_Vector *tags, ARC_ParserTagToken *tagToken, ARC_ParserLang_GetIdFn *getIdFn){ + //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); + + //for some reason can't create this in the switch, so placed here + ARC_ParserTag *tag; + + switch(childTagToken->id){ + //recuse to run the next line + case ARC_PARSERLANG_LINE: + ARC_ParserLangParsedData_RunLineTag(tags, childTagToken, getIdFn); + continue; + + //get a tag + case ARC_PARSERLANG_BODY: + ARC_ParserLangParsedData_CreateBodyTag(&tag, childTagToken, getIdFn); + continue; + + default: + continue; + } + } +} + //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; + + //make sure there is parsed data to use + if(parsedData == NULL){ + arc_errno = ARC_ERRNO_NULL; + ARC_DEBUG_LOG_ERROR("ARC_ParserLang_CreateDataFn(void **data, ARC_ParserTagToken *parsedData, void *userData), parsedData was NULL when passed in"); + return; + } + //function callback to cleanup added tags ARC_Vector_DestroyDataFn destroyParserTagFn = ARC_ParserLang_VectorDestroyParserTagFn; //I don't see a reason to have a comparison function right now. this might change in the future ARC_Vector_Create((ARC_Vector **)data, NULL, &destroyParserTagFn); + + //check if there are any tags (thes could be empty if a file is blank) + if(parsedData->tagTokens == NULL){ + return; + } + + //load the language into a vector recursivly + ARC_ParserLangParsedData_RunLineTag((ARC_Vector *)data, parsedData, getIdFn); } //private function to destroy the saved data for the language -void ARC_ParserLang_DestroyDataFn(void *data){ - ARC_Vector_Destroy(data); +void ARC_ParserLang_DestroyDataFn(void *data, void *userData){ + ARC_ParserLang_GetIdFn *getIdFn = (ARC_ParserLang_GetIdFn *)userData; + free(getIdFn); + + ARC_Vector_Destroy((ARC_Vector *)data); } -void ARC_Parser_CreateAsParserLang(ARC_Parser **parser){ +void ARC_Parser_CreateAsParserLang(ARC_Parser **parser, ARC_ParserLang_GetIdFn getIdFn){ // -> 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 } }; @@ -154,6 +282,10 @@ void ARC_Parser_CreateAsParserLang(ARC_Parser **parser){ ARC_ParserData_CreateFn createDataFn = ARC_ParserLang_CreateDataFn; 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; + //TODO: add the create, destroy, and add callbacks - ARC_Parser_Create(parser, &parserLanguageArray, ARC_ParserLang_InitLexerRulesFn, &createDataFn, NULL, &destroyDataFn); + ARC_Parser_Create(parser, &parserLanguageArray, ARC_ParserLang_InitLexerRulesFn, &createDataFn, &destroyDataFn, newGetIdFn); } diff --git a/tests/std/parser.c b/tests/std/parser.c index 5f603d0..357a8bd 100644 --- a/tests/std/parser.c +++ b/tests/std/parser.c @@ -35,7 +35,7 @@ void TEST_ParserData_CreateStringFn(void **data, ARC_ParserTagToken *parsedData, TEST_ParserData_RecurseStringAdd((ARC_String **)data, parsedData); } -void TEST_ParserData_DestroyStringFn(void *data){ +void TEST_ParserData_DestroyStringFn(void *data, void *userData){ ARC_String_Destroy((ARC_String *)data); } @@ -178,7 +178,7 @@ ARC_TEST(Parser_Basic_ParseError){ ARC_TEST(Parser_Basic_GetParsedValue){ ARC_Parser *parser; - ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, NULL, &destroyStringFn); + ARC_Parser_Create(&parser, &languageArray, TEST_Parser_InitLexerRulesFn, &createStringFn, &destroyStringFn, NULL); ARC_String *tempString; @@ -199,9 +199,14 @@ ARC_TEST(Parser_Basic_GetParsedValue){ ARC_Parser_Destroy(parser); } +/* ~ parserlang tests ~ */ +uint32_t TEST_ParserLang_GetIdFn(ARC_String *constant){ + return 0; +} + ARC_TEST(Parser_ParserLang_BasicTest){ ARC_Parser *parser; - ARC_Parser_CreateAsParserLang(&parser); + ARC_Parser_CreateAsParserLang(&parser, TEST_ParserLang_GetIdFn); ARC_String *tempString; ARC_String_CreateWithStrlen(&tempString, " -> \n");