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

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);
}