sfja.skp/codebased
sfja.skp/codebased
1
0
Fork 0
Code Issues Pull Requests Releases Activity

scirpt: add group, array, object

Browse Source
This commit is contained in:
SimonFJ20 2023-04-19 00:03:40 +02:00
parent d768346178
commit 29abedb032
7 changed files with 640 additions and 414 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/common/string.h
View File

@ -39,6 +39,11 @@ static inline void heapstring_destroy(HeapString* string)
free(string->data); free(string->data);
} }
static inline HeapString heapstring_clone(const HeapString* source)
{
return heapstring_from(source->data, source->length);
}
GENERIC_ARRAY(char, StringBuilder, stringbuilder) GENERIC_ARRAY(char, StringBuilder, stringbuilder)
HeapString stringbuilder_build(StringBuilder* builder); HeapString stringbuilder_build(StringBuilder* builder);

253
include/scirpt/ast.h
View File

@ -9,152 +9,169 @@
#include <stdint.h> #include <stdint.h>
typedef enum { typedef enum {
ScirptAstExprTypeEof, ScirptExprTypeEof,
ScirptAstExprTypeError, ScirptExprTypeError,
ScirptAstExprTypeId, ScirptExprTypeId,
ScirptAstExprTypeInt, ScirptExprTypeInt,
ScirptAstExprTypeFloat, ScirptExprTypeFloat,
ScirptAstExprTypeString, ScirptExprTypeString,
ScirptAstExprTypeNull, ScirptExprTypeNull,
ScirptAstExprTypeBool, ScirptExprTypeBool,
ScirptAstExprTypeBlock, ScirptExprTypeArray,
ScirptAstExprTypeIf, ScirptExprTypeObject,
ScirptAstExprTypeLoop, ScirptExprTypeBlock,
ScirptAstExprTypeWhile, ScirptExprTypeIf,
ScirptAstExprTypeFor, ScirptExprTypeLoop,
ScirptAstExprTypeMember, ScirptExprTypeWhile,
ScirptAstExprTypeCall, ScirptExprTypeFor,
ScirptAstExprTypeIndex, ScirptExprTypeMember,
ScirptAstExprTypeUnary, ScirptExprTypeCall,
ScirptAstExprTypeBinary, ScirptExprTypeIndex,
ScirptAstExprTypeAssign, ScirptExprTypeUnary,
ScirptAstExprTypeLambda, ScirptExprTypeBinary,
ScirptAstExprTypeFunction, ScirptExprTypeAssign,
ScirptAstExprTypeLet, ScirptExprTypeLambda,
ScirptAstExprTypeReturn, ScirptExprTypeFunction,
ScirptAstExprTypeBreak, ScirptExprTypeLet,
} ScirptAstExprType; 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 { typedef struct {
ScirptAstExprArray statements; HeapString key;
} ScirptAstExprBlock; ScirptExpr* value;
} ScirptExprObjectEntry;
GENERIC_ARRAY(
ScirptExprObjectEntry,
ScirptExprObjectEntryArray,
scirpt_expr_object_entry_array
)
typedef struct { typedef struct {
ScirptAstExpr* condition; ScirptExprObjectEntryArray entries;
ScirptAstExpr* truthy; } ScirptExprObject;
ScirptAstExpr* falsy;
} ScirptAstExprIf;
typedef struct { typedef struct {
ScirptAstExpr* body; ScirptExprArray statements;
} ScirptAstExprLoop; } ScirptExprBlock;
typedef struct { typedef struct {
ScirptAstExpr* condition; ScirptExpr* condition;
ScirptAstExpr* body; ScirptExpr* truthy;
} ScirptAstExprWhile; ScirptExpr* falsy;
} ScirptExprIf;
typedef struct {
ScirptExpr* body;
} ScirptExprLoop;
typedef struct {
ScirptExpr* condition;
ScirptExpr* body;
} ScirptExprWhile;
typedef struct { typedef struct {
HeapString subject; HeapString subject;
ScirptAstExpr* value; ScirptExpr* value;
ScirptAstExpr* body; ScirptExpr* body;
} ScirptAstExprFor; } ScirptExprFor;
typedef struct { typedef struct {
ScirptAstExpr* subject; ScirptExpr* subject;
HeapString value; HeapString value;
} ScirptAstExprMember; } ScirptExprMember;
typedef struct { typedef struct {
ScirptAstExpr* subject; ScirptExpr* subject;
ScirptAstExprArray args; ScirptExprArray args;
} ScirptAstExprCall; } ScirptExprCall;
typedef struct { typedef struct {
ScirptAstExpr* subject; ScirptExpr* subject;
ScirptAstExpr* value; ScirptExpr* value;
} ScirptAstExprIndex; } ScirptExprIndex;
typedef enum { typedef enum {
ScirptAstExprUnaryTypeNot, ScirptExprUnaryTypeNot,
ScirptAstExprUnaryTypeNegate, ScirptExprUnaryTypeNegate,
} ScirptAstExprUnaryType; } ScirptExprUnaryType;
typedef struct { typedef struct {
ScirptAstExprUnaryType type; ScirptExprUnaryType type;
ScirptAstExpr* subject; ScirptExpr* subject;
} ScirptAstExprUnary; } ScirptExprUnary;
typedef enum { typedef enum {
ScirptAstExprBinaryTypeAdd, ScirptExprBinaryTypeAdd,
ScirptAstExprBinaryTypeSubtract, ScirptExprBinaryTypeSubtract,
ScirptAstExprBinaryTypeMultiply, ScirptExprBinaryTypeMultiply,
ScirptAstExprBinaryTypeDivide, ScirptExprBinaryTypeDivide,
ScirptAstExprBinaryTypeModulo, ScirptExprBinaryTypeModulo,
ScirptAstExprBinaryTypeExponent, ScirptExprBinaryTypeExponent,
ScirptAstExprBinaryTypeLt, ScirptExprBinaryTypeLt,
ScirptAstExprBinaryTypeGt, ScirptExprBinaryTypeGt,
ScirptAstExprBinaryTypeLtEqual, ScirptExprBinaryTypeLtEqual,
ScirptAstExprBinaryTypeGtEqual, ScirptExprBinaryTypeGtEqual,
ScirptAstExprBinaryTypeIn, ScirptExprBinaryTypeIn,
ScirptAstExprBinaryTypeEqual, ScirptExprBinaryTypeEqual,
ScirptAstExprBinaryTypeInequal, ScirptExprBinaryTypeInequal,
ScirptAstExprBinaryTypeAnd, ScirptExprBinaryTypeAnd,
ScirptAstExprBinaryTypeOr, ScirptExprBinaryTypeOr,
} ScirptAstExprBinaryType; } ScirptExprBinaryType;
typedef struct { typedef struct {
ScirptAstExprBinaryType type; ScirptExprBinaryType type;
ScirptAstExpr* left; ScirptExpr* left;
ScirptAstExpr* right; ScirptExpr* right;
} ScirptAstExprBinary; } ScirptExprBinary;
typedef enum { typedef enum {
ScirptAstExprAssignTypeEqual, ScirptExprAssignTypeEqual,
ScirptAstExprAssignTypeAdd, ScirptExprAssignTypeAdd,
ScirptAstExprAssignTypeSubtract, ScirptExprAssignTypeSubtract,
ScirptAstExprAssignTypeMultiply, ScirptExprAssignTypeMultiply,
ScirptAstExprAssignTypeDivide, ScirptExprAssignTypeDivide,
ScirptAstExprAssignTypeModulo, ScirptExprAssignTypeModulo,
ScirptAstExprAssignTypeExponent, ScirptExprAssignTypeExponent,
} ScirptAstExprAssignType; } ScirptExprAssignType;
typedef struct { typedef struct {
ScirptAstExprAssignType type; ScirptExprAssignType type;
ScirptAstExpr* subject; ScirptExpr* subject;
ScirptAstExpr* value; ScirptExpr* value;
} ScirptAstExprAssign; } ScirptExprAssign;
typedef struct { typedef struct {
HeapStringArray params; HeapStringArray params;
ScirptAstExpr* body; ScirptExpr* body;
} ScirptAstExprLambda; } ScirptExprLambda;
typedef struct { typedef struct {
HeapString subject; HeapString subject;
HeapStringArray params; HeapStringArray params;
ScirptAstExpr* body; ScirptExpr* body;
} ScirptAstExprFunction; } ScirptExprFunction;
typedef struct { typedef struct {
HeapString subject; HeapString subject;
ScirptAstExpr* value; ScirptExpr* value;
} ScirptAstExprLet; } ScirptExprLet;
typedef struct { typedef struct {
ScirptAstExpr* value; ScirptExpr* value;
} ScirptAstExprReturn; } ScirptExprReturn;
typedef struct { typedef struct {
ScirptAstExpr* value; ScirptExpr* value;
} ScirptAstExprBreak; } ScirptExprBreak;
struct ScirptAstExpr { struct ScirptExpr {
ScirptAstExprType type; ScirptExprType type;
ScirptPosition pos; ScirptPosition pos;
union { union {
HeapString id_value; HeapString id_value;
@ -162,25 +179,29 @@ struct ScirptAstExpr {
double float_value; double float_value;
HeapString string_value; HeapString string_value;
bool bool_value; bool bool_value;
ScirptAstExprBlock block; ScirptExprArray array_value;
ScirptAstExprIf if_expr; ScirptExprObject object;
ScirptAstExprLoop loop; ScirptExprBlock block;
ScirptAstExprWhile while_expr; ScirptExprIf if_expr;
ScirptAstExprFor for_expr; ScirptExprLoop loop;
ScirptAstExprMember member; ScirptExprWhile while_expr;
ScirptAstExprCall call; ScirptExprFor for_expr;
ScirptAstExprIndex index; ScirptExprMember member;
ScirptAstExprUnary unary; ScirptExprCall call;
ScirptAstExprBinary binary; ScirptExprIndex index;
ScirptAstExprAssign assign; ScirptExprUnary unary;
ScirptAstExprLambda lambda; ScirptExprBinary binary;
ScirptAstExprFunction function; ScirptExprAssign assign;
ScirptAstExprLet let; ScirptExprLambda lambda;
ScirptAstExprReturn return_statement; ScirptExprFunction function;
ScirptAstExprBreak break_statement; 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 #endif

4
include/scirpt/parser.h
View File

@ -12,6 +12,8 @@ typedef struct {
ScirptPosition pos; ScirptPosition pos;
} ScirptParserError; } ScirptParserError;
void scirpt_parser_error_destroy(ScirptParserError* error);
GENERIC_ARRAY( GENERIC_ARRAY(
ScirptParserError, ScirptParserErrorArray, scirpt_parser_error_array ScirptParserError, ScirptParserErrorArray, scirpt_parser_error_array
) )
@ -21,7 +23,7 @@ typedef struct ScirptParser ScirptParser;
ScirptParser* ScirptParser*
scirpt_parser_new(const char* text, size_t text_length, ScirptLexer* lexer); scirpt_parser_new(const char* text, size_t text_length, ScirptLexer* lexer);
void scirpt_parser_delete(ScirptParser* parser); 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); bool scirpt_parser_ok(const ScirptParser* parser);
const ScirptParserErrorArray* scirpt_parser_errors(const ScirptParser* parser); const ScirptParserErrorArray* scirpt_parser_errors(const ScirptParser* parser);

135
scirpt/ast.c
View File

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

12
scirpt/main.c
View File

@ -5,12 +5,14 @@
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
int main(void) int main(void)
{ {
const char* text 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); printf("\nprogram = \"\"\"\n%s\n\"\"\"\n", text);
{ {
@ -30,8 +32,8 @@ int main(void)
ScirptLexer* lexer = scirpt_lexer_new(text, strlen(text)); ScirptLexer* lexer = scirpt_lexer_new(text, strlen(text));
ScirptParser* parser = scirpt_parser_new(text, strlen(text), lexer); ScirptParser* parser = scirpt_parser_new(text, strlen(text), lexer);
while (true) { while (true) {
ScirptAstExpr* expr = scirpt_parser_next(parser); ScirptExpr* expr = scirpt_parser_next(parser);
if (expr->type == ScirptAstExprTypeEof) { if (expr->type == ScirptExprTypeEof) {
break; break;
} else if (!scirpt_parser_ok(parser)) { } else if (!scirpt_parser_ok(parser)) {
const ScirptParserErrorArray* errors const ScirptParserErrorArray* errors
@ -50,8 +52,10 @@ int main(void)
break; break;
} }
printf("%d\n", expr->type); printf("%d\n", expr->type);
scirpt_ast_expr_delete(expr); scirpt_expr_delete(expr);
} }
scirpt_parser_delete(parser); scirpt_parser_delete(parser);
} }
return EXIT_SUCCESS;
} }

590
scirpt/parser.c
View File

File diff suppressed because it is too large Load Diff

55
scirpt/parser.h
View File

@ -25,32 +25,35 @@ void scirpt_parser_construct(
ScirptLexer* lexer ScirptLexer* lexer
); );
void scirpt_parser_destroy(ScirptParser* parser); void scirpt_parser_destroy(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_statement(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_statement(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_assign(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_assign(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_expr(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_expr(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_or(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_or(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_and(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_and(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_equality(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_equality(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_comparison(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_comparison(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_add_subtract(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_add_subtract(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_multiply_divide_modulo(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_multiply_divide_modulo(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_negate(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_negate(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_exponent(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_exponent(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_unary(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_unary(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_member_call_index_expr(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_member_call_index_expr(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_operand(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_operand(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_int_or_float(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_int_or_float(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_string(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_string(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_block(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_group(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_if(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_array(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_loop(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_object(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_while(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_block(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_for(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_if(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_lambda(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_loop(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_function(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_while(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_let(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_for(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_return(ScirptParser* parser); ScirptExpr* scirpt_parser_parse_lambda(ScirptParser* parser);
ScirptAstExpr* scirpt_parser_parse_break(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( void scirpt_parser_error(
ScirptParser* parser, HeapString message, ScirptPosition pos ScirptParser* parser, HeapString message, ScirptPosition pos
); );