parser clears lexer when done parsing

include/arc/std/lexer.h

@@ -74,6 +74,13 @@ void ARC_Lexer_Destroy(ARC_Lexer *lexer);
 */
 void ARC_Lexer_RegisterTokenRule(ARC_Lexer *lexer, ARC_LexerTokenRule tokenRule);
 
+/**
+ * @brief clears all tokens from a lexer (will not clear token rules)
+ *
+ * @param lexer the lexer to clear tokens from
+*/
+void ARC_Lexer_Clear(ARC_Lexer *lexer);
+
 /**
  * @brief creates tokens using a given string with ARC_LexerToken rules
  *

src/std/lexer.c

@@ -151,6 +151,11 @@ void ARC_Lexer_RegisterTokenRule(ARC_Lexer *lexer, ARC_LexerTokenRule tokenRule)
     }
 }
 
+void ARC_Lexer_Clear(ARC_Lexer *lexer){
+    //clear the tokens vector
+    ARC_Vector_Clear(lexer->tokens);
+}
+
 void ARC_Lexer_LexString(ARC_Lexer *lexer, ARC_String **data){
     //check if there are any token rules to use
     if(ARC_Vector_GetSize(lexer->tokenRules) == 0){

src/std/parser.c

@@ -73,8 +73,9 @@ void ARC_Parser_ParseTag(ARC_Parser *parser, uint32_t *lexerIndex, uint32_t tagI
         for(uint32_t tokenOrTagIndex = 1; tokenOrTagIndex < tag->tokensOrTags[orIndex][0] + 1; tokenOrTagIndex++){
             //if the value isn't a token it is a tag, so recurs if it isn't a token
             ARC_Bool isToken = ARC_Lexer_IsTokenId(parser->lexer, tag->tokensOrTags[orIndex][tokenOrTagIndex]);
+            uint32_t nextTagId = tag->tokensOrTags[orIndex][tokenOrTagIndex];
             if(isToken == ARC_False){
-                ARC_Parser_ParseTag(parser, lexerIndex, tag->tokensOrTags[orIndex][tokenOrTagIndex]);
+                ARC_Parser_ParseTag(parser, lexerIndex, nextTagId);
                 return;
             }
 
@@ -113,6 +114,7 @@ void ARC_Parser_Parse(ARC_Parser *parser, ARC_String **data){
     ARC_Lexer_LexString(parser->lexer, data);
     if(arc_errno){
         ARC_DEBUG_LOG_ERROR("ARC_Parser_Parse(parser, data), could not lex the given data");
+        ARC_Lexer_Clear(parser->lexer);
         return;
     }
 
@@ -122,6 +124,7 @@ void ARC_Parser_Parse(ARC_Parser *parser, ARC_String **data){
 
     //recursivly parse from the inital start tag
     ARC_Parser_ParseTag(parser, &lexerIndex, startTag->tagId);
+    ARC_Lexer_Clear(parser->lexer);
     if(arc_errno){
         ARC_DEBUG_LOG_ERROR("ARC_Parser_Parse(parser, data), could not parse the given data");
         return;

tests/std/parser.c

@@ -128,4 +128,22 @@ ARC_TEST(Parser_Basic_ParseError){
     ARC_Parser_Parse(parser, &tempString);
 
     ARC_CHECK(arc_errno == ARC_ERRNO_DATA);
+
+    //check again with moved character
+    arc_errno = 0;
+    ARC_String_CreateWithStrlen(&tempString, "my!Var1");
+
+    //this destroys string, so no need for cleanup
+    ARC_Parser_Parse(parser, &tempString);
+
+    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);
+
+    //check again with moved character
+    arc_errno = 0;
+    ARC_String_CreateWithStrlen(&tempString, "myVar1!");
+
+    //this destroys string, so no need for cleanup
+    ARC_Parser_Parse(parser, &tempString);
+
+    ARC_CHECK(arc_errno == ARC_ERRNO_DATA);
 }