scirpt: add group, array, object

2023-04-19 00:03:40 +02:00 · 2023-04-19 00:03:40 +02:00 · 29abedb032
commit 29abedb032
parent d768346178
7 changed files with 640 additions and 414 deletions
--- a/include/common/string.h
+++ b/include/common/string.h
@ -39,6 +39,11 @@ static inline void heapstring_destroy(HeapString* string)
 		free(string->data);
 }

+static inline HeapString heapstring_clone(const HeapString* source)
+{
+	return heapstring_from(source->data, source->length);
+}
+
 GENERIC_ARRAY(char, StringBuilder, stringbuilder)
 HeapString stringbuilder_build(StringBuilder* builder);

--- a/include/scirpt/ast.h
+++ b/include/scirpt/ast.h
@ -9,152 +9,169 @@
 #include <stdint.h>

 typedef enum {
-	ScirptAstExprTypeEof,
-	ScirptAstExprTypeError,
-	ScirptAstExprTypeId,
-	ScirptAstExprTypeInt,
-	ScirptAstExprTypeFloat,
-	ScirptAstExprTypeString,
-	ScirptAstExprTypeNull,
-	ScirptAstExprTypeBool,
-	ScirptAstExprTypeBlock,
-	ScirptAstExprTypeIf,
-	ScirptAstExprTypeLoop,
-	ScirptAstExprTypeWhile,
-	ScirptAstExprTypeFor,
-	ScirptAstExprTypeMember,
-	ScirptAstExprTypeCall,
-	ScirptAstExprTypeIndex,
-	ScirptAstExprTypeUnary,
-	ScirptAstExprTypeBinary,
-	ScirptAstExprTypeAssign,
-	ScirptAstExprTypeLambda,
-	ScirptAstExprTypeFunction,
-	ScirptAstExprTypeLet,
-	ScirptAstExprTypeReturn,
-	ScirptAstExprTypeBreak,
-} ScirptAstExprType;
+	ScirptExprTypeEof,
+	ScirptExprTypeError,
+	ScirptExprTypeId,
+	ScirptExprTypeInt,
+	ScirptExprTypeFloat,
+	ScirptExprTypeString,
+	ScirptExprTypeNull,
+	ScirptExprTypeBool,
+	ScirptExprTypeArray,
+	ScirptExprTypeObject,
+	ScirptExprTypeBlock,
+	ScirptExprTypeIf,
+	ScirptExprTypeLoop,
+	ScirptExprTypeWhile,
+	ScirptExprTypeFor,
+	ScirptExprTypeMember,
+	ScirptExprTypeCall,
+	ScirptExprTypeIndex,
+	ScirptExprTypeUnary,
+	ScirptExprTypeBinary,
+	ScirptExprTypeAssign,
+	ScirptExprTypeLambda,
+	ScirptExprTypeFunction,
+	ScirptExprTypeLet,
+	ScirptExprTypeReturn,
+	ScirptExprTypeBreak,
+} ScirptExprType;

-typedef struct ScirptAstExpr ScirptAstExpr;
+typedef struct ScirptExpr ScirptExpr;

-GENERIC_ARRAY(ScirptAstExpr*, ScirptAstExprArray, scirpt_ast_expr_array)
+GENERIC_ARRAY(ScirptExpr*, ScirptExprArray, scirpt_expr_array)

 typedef struct {
-	ScirptAstExprArray statements;
-} ScirptAstExprBlock;
+	HeapString key;
+	ScirptExpr* value;
+} ScirptExprObjectEntry;
+
+GENERIC_ARRAY(
+	ScirptExprObjectEntry,
+	ScirptExprObjectEntryArray,
+	scirpt_expr_object_entry_array
+)

 typedef struct {
-	ScirptAstExpr* condition;
-	ScirptAstExpr* truthy;
-	ScirptAstExpr* falsy;
-} ScirptAstExprIf;
+	ScirptExprObjectEntryArray entries;
+} ScirptExprObject;

 typedef struct {
-	ScirptAstExpr* body;
-} ScirptAstExprLoop;
+	ScirptExprArray statements;
+} ScirptExprBlock;

 typedef struct {
-	ScirptAstExpr* condition;
-	ScirptAstExpr* body;
-} ScirptAstExprWhile;
+	ScirptExpr* condition;
+	ScirptExpr* truthy;
+	ScirptExpr* falsy;
+} ScirptExprIf;
+
+typedef struct {
+	ScirptExpr* body;
+} ScirptExprLoop;
+
+typedef struct {
+	ScirptExpr* condition;
+	ScirptExpr* body;
+} ScirptExprWhile;

 typedef struct {
 	HeapString subject;
-	ScirptAstExpr* value;
-	ScirptAstExpr* body;
-} ScirptAstExprFor;
+	ScirptExpr* value;
+	ScirptExpr* body;
+} ScirptExprFor;

 typedef struct {
-	ScirptAstExpr* subject;
+	ScirptExpr* subject;
 	HeapString value;
-} ScirptAstExprMember;
+} ScirptExprMember;

 typedef struct {
-	ScirptAstExpr* subject;
-	ScirptAstExprArray args;
-} ScirptAstExprCall;
+	ScirptExpr* subject;
+	ScirptExprArray args;
+} ScirptExprCall;

 typedef struct {
-	ScirptAstExpr* subject;
-	ScirptAstExpr* value;
-} ScirptAstExprIndex;
+	ScirptExpr* subject;
+	ScirptExpr* value;
+} ScirptExprIndex;

 typedef enum {
-	ScirptAstExprUnaryTypeNot,
-	ScirptAstExprUnaryTypeNegate,
-} ScirptAstExprUnaryType;
+	ScirptExprUnaryTypeNot,
+	ScirptExprUnaryTypeNegate,
+} ScirptExprUnaryType;

 typedef struct {
-	ScirptAstExprUnaryType type;
-	ScirptAstExpr* subject;
-} ScirptAstExprUnary;
+	ScirptExprUnaryType type;
+	ScirptExpr* subject;
+} ScirptExprUnary;

 typedef enum {
-	ScirptAstExprBinaryTypeAdd,
-	ScirptAstExprBinaryTypeSubtract,
-	ScirptAstExprBinaryTypeMultiply,
-	ScirptAstExprBinaryTypeDivide,
-	ScirptAstExprBinaryTypeModulo,
-	ScirptAstExprBinaryTypeExponent,
-	ScirptAstExprBinaryTypeLt,
-	ScirptAstExprBinaryTypeGt,
-	ScirptAstExprBinaryTypeLtEqual,
-	ScirptAstExprBinaryTypeGtEqual,
-	ScirptAstExprBinaryTypeIn,
-	ScirptAstExprBinaryTypeEqual,
-	ScirptAstExprBinaryTypeInequal,
-	ScirptAstExprBinaryTypeAnd,
-	ScirptAstExprBinaryTypeOr,
-} ScirptAstExprBinaryType;
+	ScirptExprBinaryTypeAdd,
+	ScirptExprBinaryTypeSubtract,
+	ScirptExprBinaryTypeMultiply,
+	ScirptExprBinaryTypeDivide,
+	ScirptExprBinaryTypeModulo,
+	ScirptExprBinaryTypeExponent,
+	ScirptExprBinaryTypeLt,
+	ScirptExprBinaryTypeGt,
+	ScirptExprBinaryTypeLtEqual,
+	ScirptExprBinaryTypeGtEqual,
+	ScirptExprBinaryTypeIn,
+	ScirptExprBinaryTypeEqual,
+	ScirptExprBinaryTypeInequal,
+	ScirptExprBinaryTypeAnd,
+	ScirptExprBinaryTypeOr,
+} ScirptExprBinaryType;

 typedef struct {
-	ScirptAstExprBinaryType type;
-	ScirptAstExpr* left;
-	ScirptAstExpr* right;
-} ScirptAstExprBinary;
+	ScirptExprBinaryType type;
+	ScirptExpr* left;
+	ScirptExpr* right;
+} ScirptExprBinary;

 typedef enum {
-	ScirptAstExprAssignTypeEqual,
-	ScirptAstExprAssignTypeAdd,
-	ScirptAstExprAssignTypeSubtract,
-	ScirptAstExprAssignTypeMultiply,
-	ScirptAstExprAssignTypeDivide,
-	ScirptAstExprAssignTypeModulo,
-	ScirptAstExprAssignTypeExponent,
-} ScirptAstExprAssignType;
+	ScirptExprAssignTypeEqual,
+	ScirptExprAssignTypeAdd,
+	ScirptExprAssignTypeSubtract,
+	ScirptExprAssignTypeMultiply,
+	ScirptExprAssignTypeDivide,
+	ScirptExprAssignTypeModulo,
+	ScirptExprAssignTypeExponent,
+} ScirptExprAssignType;

 typedef struct {
-	ScirptAstExprAssignType type;
-	ScirptAstExpr* subject;
-	ScirptAstExpr* value;
-} ScirptAstExprAssign;
+	ScirptExprAssignType type;
+	ScirptExpr* subject;
+	ScirptExpr* value;
+} ScirptExprAssign;

 typedef struct {
 	HeapStringArray params;
-	ScirptAstExpr* body;
-} ScirptAstExprLambda;
+	ScirptExpr* body;
+} ScirptExprLambda;

 typedef struct {
 	HeapString subject;
 	HeapStringArray params;
-	ScirptAstExpr* body;
-} ScirptAstExprFunction;
+	ScirptExpr* body;
+} ScirptExprFunction;

 typedef struct {
 	HeapString subject;
-	ScirptAstExpr* value;
-} ScirptAstExprLet;
+	ScirptExpr* value;
+} ScirptExprLet;

 typedef struct {
-	ScirptAstExpr* value;
-} ScirptAstExprReturn;
+	ScirptExpr* value;
+} ScirptExprReturn;

 typedef struct {
-	ScirptAstExpr* value;
-} ScirptAstExprBreak;
+	ScirptExpr* value;
+} ScirptExprBreak;

-struct ScirptAstExpr {
-	ScirptAstExprType type;
+struct ScirptExpr {
+	ScirptExprType type;
 	ScirptPosition pos;
 	union {
 		HeapString id_value;
@ -162,25 +179,29 @@ struct ScirptAstExpr {
 		double float_value;
 		HeapString string_value;
 		bool bool_value;
-		ScirptAstExprBlock block;
-		ScirptAstExprIf if_expr;
-		ScirptAstExprLoop loop;
-		ScirptAstExprWhile while_expr;
-		ScirptAstExprFor for_expr;
-		ScirptAstExprMember member;
-		ScirptAstExprCall call;
-		ScirptAstExprIndex index;
-		ScirptAstExprUnary unary;
-		ScirptAstExprBinary binary;
-		ScirptAstExprAssign assign;
-		ScirptAstExprLambda lambda;
-		ScirptAstExprFunction function;
-		ScirptAstExprLet let;
-		ScirptAstExprReturn return_statement;
-		ScirptAstExprBreak break_statement;
+		ScirptExprArray array_value;
+		ScirptExprObject object;
+		ScirptExprBlock block;
+		ScirptExprIf if_expr;
+		ScirptExprLoop loop;
+		ScirptExprWhile while_expr;
+		ScirptExprFor for_expr;
+		ScirptExprMember member;
+		ScirptExprCall call;
+		ScirptExprIndex index;
+		ScirptExprUnary unary;
+		ScirptExprBinary binary;
+		ScirptExprAssign assign;
+		ScirptExprLambda lambda;
+		ScirptExprFunction function;
+		ScirptExprLet let;
+		ScirptExprReturn return_statement;
+		ScirptExprBreak break_statement;
 	};
 };

-void scirpt_ast_expr_delete(ScirptAstExpr* expr);
+void scirpt_expr_delete(ScirptExpr* expr);
+void scirpt_expr_array_clean_and_destroy(ScirptExprArray* array);
+void heapstring_array_clean_and_destroy(HeapStringArray* array);

 #endif
--- a/include/scirpt/parser.h
+++ b/include/scirpt/parser.h
@ -12,6 +12,8 @@ typedef struct {
 	ScirptPosition pos;
 } ScirptParserError;

+void scirpt_parser_error_destroy(ScirptParserError* error);
+
 GENERIC_ARRAY(
 	ScirptParserError, ScirptParserErrorArray, scirpt_parser_error_array
 )
@ -21,7 +23,7 @@ typedef struct ScirptParser ScirptParser;
 ScirptParser*
 scirpt_parser_new(const char* text, size_t text_length, ScirptLexer* lexer);
 void scirpt_parser_delete(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_next(ScirptParser* parser);
+ScirptExpr* scirpt_parser_next(ScirptParser* parser);
 bool scirpt_parser_ok(const ScirptParser* parser);
 const ScirptParserErrorArray* scirpt_parser_errors(const ScirptParser* parser);

--- a/scirpt/ast.c
+++ b/scirpt/ast.c
@ -4,97 +4,112 @@
 #include <stddef.h>
 #include <stdlib.h>

-void scirpt_ast_expr_delete(ScirptAstExpr* expr)
+void scirpt_expr_delete(ScirptExpr* expr)
 {
 	switch (expr->type) {
-		case ScirptAstExprTypeEof:
+		case ScirptExprTypeEof:
 			break;
-		case ScirptAstExprTypeError:
+		case ScirptExprTypeError:
 			break;
-		case ScirptAstExprTypeId:
+		case ScirptExprTypeId:
 			heapstring_destroy(&expr->id_value);
 			break;
-		case ScirptAstExprTypeInt:
+		case ScirptExprTypeInt:
 			break;
-		case ScirptAstExprTypeFloat:
+		case ScirptExprTypeFloat:
 			break;
-		case ScirptAstExprTypeString:
+		case ScirptExprTypeString:
 			heapstring_destroy(&expr->string_value);
 			break;
-		case ScirptAstExprTypeBool:
+		case ScirptExprTypeBool:
 			break;
-		case ScirptAstExprTypeNull:
+		case ScirptExprTypeNull:
 			break;
-		case ScirptAstExprTypeBlock:
-			for (size_t i = 0; i < expr->block.statements.length; ++i)
-				scirpt_ast_expr_delete(expr->block.statements.data[i]);
-			scirpt_ast_expr_array_destroy(&expr->block.statements);
+		case ScirptExprTypeArray:
+			scirpt_expr_array_clean_and_destroy(&expr->array_value);
 			break;
-		case ScirptAstExprTypeIf:
-			scirpt_ast_expr_delete(expr->if_expr.condition);
-			scirpt_ast_expr_delete(expr->if_expr.truthy);
+		case ScirptExprTypeObject:
+			for (size_t i = 0; i < expr->object.entries.length; ++i) {
+				heapstring_destroy(&expr->object.entries.data[i].key);
+				scirpt_expr_delete(expr->object.entries.data[i].value);
+			}
+			break;
+		case ScirptExprTypeBlock:
+			scirpt_expr_array_clean_and_destroy(&expr->block.statements);
+			break;
+		case ScirptExprTypeIf:
+			scirpt_expr_delete(expr->if_expr.condition);
+			scirpt_expr_delete(expr->if_expr.truthy);
 			if (expr->if_expr.falsy)
-				scirpt_ast_expr_delete(expr->if_expr.falsy);
+				scirpt_expr_delete(expr->if_expr.falsy);
 			break;
-		case ScirptAstExprTypeLoop:
-			scirpt_ast_expr_delete(expr->loop.body);
+		case ScirptExprTypeLoop:
+			scirpt_expr_delete(expr->loop.body);
 			break;
-		case ScirptAstExprTypeWhile:
-			scirpt_ast_expr_delete(expr->while_expr.condition);
-			scirpt_ast_expr_delete(expr->while_expr.body);
+		case ScirptExprTypeWhile:
+			scirpt_expr_delete(expr->while_expr.condition);
+			scirpt_expr_delete(expr->while_expr.body);
 			break;
-		case ScirptAstExprTypeFor:
+		case ScirptExprTypeFor:
 			heapstring_destroy(&expr->for_expr.subject);
-			scirpt_ast_expr_delete(expr->for_expr.value);
-			scirpt_ast_expr_delete(expr->for_expr.body);
+			scirpt_expr_delete(expr->for_expr.value);
+			scirpt_expr_delete(expr->for_expr.body);
 			break;
-		case ScirptAstExprTypeMember:
-			scirpt_ast_expr_delete(expr->member.subject);
+		case ScirptExprTypeMember:
+			scirpt_expr_delete(expr->member.subject);
 			heapstring_destroy(&expr->member.value);
 			break;
-		case ScirptAstExprTypeCall:
-			scirpt_ast_expr_delete(expr->call.subject);
-			for (size_t i = 0; i < expr->call.args.length; ++i)
-				scirpt_ast_expr_delete(expr->call.args.data[i]);
-			scirpt_ast_expr_array_destroy(&expr->call.args);
+		case ScirptExprTypeCall:
+			scirpt_expr_delete(expr->call.subject);
+			scirpt_expr_array_clean_and_destroy(&expr->call.args);
 			break;
-		case ScirptAstExprTypeIndex:
-			scirpt_ast_expr_delete(expr->index.subject);
-			scirpt_ast_expr_delete(expr->index.value);
+		case ScirptExprTypeIndex:
+			scirpt_expr_delete(expr->index.subject);
+			scirpt_expr_delete(expr->index.value);
 			break;
-		case ScirptAstExprTypeUnary:
-			scirpt_ast_expr_delete(expr->unary.subject);
+		case ScirptExprTypeUnary:
+			scirpt_expr_delete(expr->unary.subject);
 			break;
-		case ScirptAstExprTypeBinary:
-			scirpt_ast_expr_delete(expr->binary.left);
-			scirpt_ast_expr_delete(expr->binary.right);
+		case ScirptExprTypeBinary:
+			scirpt_expr_delete(expr->binary.left);
+			scirpt_expr_delete(expr->binary.right);
 			break;
-		case ScirptAstExprTypeAssign:
-			scirpt_ast_expr_delete(expr->assign.subject);
-			scirpt_ast_expr_delete(expr->assign.value);
+		case ScirptExprTypeAssign:
+			scirpt_expr_delete(expr->assign.subject);
+			scirpt_expr_delete(expr->assign.value);
 			break;
-		case ScirptAstExprTypeLambda:
-			for (size_t i = 0; i < expr->lambda.params.length; ++i)
-				heapstring_destroy(&expr->lambda.params.data[i]);
-			heapstring_array_destroy(&expr->lambda.params);
-			scirpt_ast_expr_delete(expr->lambda.body);
+		case ScirptExprTypeLambda:
+			heapstring_array_clean_and_destroy(&expr->lambda.params);
+			scirpt_expr_delete(expr->lambda.body);
 			break;
-		case ScirptAstExprTypeFunction:
-			heapstring_destroy(&expr->function.subject);
-			for (size_t i = 0; i < expr->function.params.length; ++i)
-				heapstring_destroy(&expr->function.params.data[i]);
-			heapstring_array_destroy(&expr->function.params);
-			scirpt_ast_expr_delete(expr->function.body);
+		case ScirptExprTypeFunction:
+			heapstring_array_clean_and_destroy(&expr->function.params);
+			scirpt_expr_delete(expr->function.body);
 			break;
-		case ScirptAstExprTypeLet:
+		case ScirptExprTypeLet:
 			heapstring_destroy(&expr->let.subject);
-			scirpt_ast_expr_delete(expr->let.value);
+			scirpt_expr_delete(expr->let.value);
 			break;
-		case ScirptAstExprTypeReturn:
-			scirpt_ast_expr_delete(expr->return_statement.value);
+		case ScirptExprTypeReturn:
+			scirpt_expr_delete(expr->return_statement.value);
 			break;
-		case ScirptAstExprTypeBreak:
-			scirpt_ast_expr_delete(expr->break_statement.value);
+		case ScirptExprTypeBreak:
+			scirpt_expr_delete(expr->break_statement.value);
 			break;
 	}
 }
+
+void scirpt_expr_array_clean_and_destroy(ScirptExprArray* array)
+{
+	for (size_t i = 0; i < array->length; ++i)
+		scirpt_expr_delete(array->data[i]);
+	scirpt_expr_array_destroy(array);
+}
+
+void heapstring_array_clean_and_destroy(HeapStringArray* array)
+{
+
+	for (size_t i = 0; i < array->length; ++i)
+		heapstring_destroy(&array->data[i]);
+	heapstring_array_destroy(array);
+}
--- a/scirpt/main.c
+++ b/scirpt/main.c
@ -5,12 +5,14 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>

 int main(void)
 {
 	const char* text
-		= "if 123 { \"abc\"; abc()() }; for a in b { print(123, 123, 123,) }";
+		= "if 123 { \"abc\"; abc()() }; for a in b { print(123, "
+		  "123, 123, [123, 123], !{ \"foo\": 123, bar: \"baz\" }) }";
 	printf("\nprogram = \"\"\"\n%s\n\"\"\"\n", text);

 	{
@ -30,8 +32,8 @@ int main(void)
 		ScirptLexer* lexer = scirpt_lexer_new(text, strlen(text));
 		ScirptParser* parser = scirpt_parser_new(text, strlen(text), lexer);
 		while (true) {
-			ScirptAstExpr* expr = scirpt_parser_next(parser);
-			if (expr->type == ScirptAstExprTypeEof) {
+			ScirptExpr* expr = scirpt_parser_next(parser);
+			if (expr->type == ScirptExprTypeEof) {
 				break;
 			} else if (!scirpt_parser_ok(parser)) {
 				const ScirptParserErrorArray* errors
@ -50,8 +52,10 @@ int main(void)
 				break;
 			}
 			printf("%d\n", expr->type);
-			scirpt_ast_expr_delete(expr);
+			scirpt_expr_delete(expr);
 		}
 		scirpt_parser_delete(parser);
 	}
+
+	return EXIT_SUCCESS;
 }
--- a/scirpt/parser.c
+++ b/scirpt/parser.c
--- a/scirpt/parser.h
+++ b/scirpt/parser.h
@ -25,32 +25,35 @@ void scirpt_parser_construct(
 	ScirptLexer* lexer
 );
 void scirpt_parser_destroy(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_statement(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_assign(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_expr(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_or(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_and(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_equality(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_comparison(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_add_subtract(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_multiply_divide_modulo(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_negate(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_exponent(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_unary(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_member_call_index_expr(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_operand(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_int_or_float(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_string(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_block(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_if(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_loop(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_while(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_for(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_lambda(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_function(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_let(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_return(ScirptParser* parser);
-ScirptAstExpr* scirpt_parser_parse_break(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_statement(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_assign(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_expr(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_or(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_and(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_equality(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_comparison(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_add_subtract(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_multiply_divide_modulo(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_negate(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_exponent(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_unary(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_member_call_index_expr(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_operand(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_int_or_float(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_string(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_group(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_array(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_object(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_block(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_if(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_loop(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_while(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_for(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_lambda(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_function(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_let(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_return(ScirptParser* parser);
+ScirptExpr* scirpt_parser_parse_break(ScirptParser* parser);
 void scirpt_parser_error(
 	ScirptParser* parser, HeapString message, ScirptPosition pos
 );