herbglitch/archeus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

bout halfway complete with parserlang, also added userdata to parser

Browse source
This commit is contained in:
herbglitch 2024-12-02 02:34:01 -07:00
parent 7cfea02681
commit 16821e8411
6 changed files with 190 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/arc/std/parser.h
View file

@ -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

4
include/arc/std/parser/parserlang.h
View file

@ -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

5
src/input/input.c
View file

@ -1,5 +1,7 @@
#include "arc/input/input.h"
#include "arc/std/bool.h"
#include <stdio.h>
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){

22
src/std/parser.c
View file

@ -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

186
src/std/parser/parserlang.c
View file

@ -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 <stddef.h>
#include <stdlib.h>
/*
<line> -> <body> NEWLINE <line> | <body> | NEWLINE <line> | LAMBDA
<body> -> <tag> WHITESPACE ARROW WHITESPACE <arguments>
<arguments> -> <argument> WHITESPACE OR WHITESPACE <arguments> | <tagOrConstant>
<argument> -> <tagOrConstant> WHITESPACE <argument> | <tagOrConstant>
<tagOrConstant> -> <tag> | <constant>
<constant> -> ALPHA_UPPER_CHAR <constantBody>
<constantBody> -> <constantChar> <constantBody> | LAMBDA
<constantChar> -> ALPHA_UPPER_CHAR | UNDERSCORE
<tag> -> LESS_THAN <variable> GREATER_THAN
<variable> -> <alphaChar> <variableBody> | UNDERSCORE <variableBody>
<variableBody> -> <variableChar> <variableBody> | LAMBDA
<variableChar> -> <alphaChar> | NUMBER | UNDERSCORE
<alphaChar> -> 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);
}
/*
<line> -> <body> NEWLINE <line> | <body> | NEWLINE <line> | LAMBDA
<body> -> <tag> WHITESPACE ARROW WHITESPACE <arguments>
<arguments> -> <argument> WHITESPACE OR WHITESPACE <arguments> | <tagOrConstant>
<argument> -> <tagOrConstant> WHITESPACE <argument> | <tagOrConstant>
<tagOrConstant> -> <tag> | <constant>
<constant> -> ALPHA_UPPER_CHAR <constantBody>
<constantBody> -> <constantChar> <constantBody> | LAMBDA
<constantChar> -> ALPHA_UPPER_CHAR | UNDERSCORE
<tag> -> LESS_THAN <variable> GREATER_THAN
<variable> -> <alphaChar> <variableBody> | UNDERSCORE <variableBody>
<variableBody> -> <variableChar> <variableBody> | LAMBDA
<variableChar> -> <alphaChar> | NUMBER | UNDERSCORE
<alphaChar> -> 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){
//<line> -> <body> NEWLINE <line> | <body> | NEWLINE <line> | 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);
}

11
tests/std/parser.c
View file

@ -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, "<test> -> <testingStuffs>\n");