X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FLibraries%2Flibspiderscript.so_src%2Fparse.c;h=6e1696e9dca6f5fe769ce364acfb27d4c95ec02e;hb=ec4d050568da0f3f18a20969bd118b5c67f03ee2;hp=720a2fe22bc3c40f7205db129263fc05b1630e1f;hpb=3887bf8941fe33071d061961f213a7da360af02a;p=tpg%2Facess2.git diff --git a/Usermode/Libraries/libspiderscript.so_src/parse.c b/Usermode/Libraries/libspiderscript.so_src/parse.c index 720a2fe2..6e1696e9 100644 --- a/Usermode/Libraries/libspiderscript.so_src/parse.c +++ b/Usermode/Libraries/libspiderscript.so_src/parse.c @@ -48,7 +48,7 @@ void SyntaxAssert(tParser *Parser, int Have, int Want); tAST_Script *Parse_Buffer(tSpiderVariant *Variant, char *Buffer) { tParser parser = {0}; - tParser *Parser = &parser; //< Keeps code consitent + tParser *Parser = &parser; //< Keeps code consistent tAST_Script *ret; tAST_Node *mainCode; char *name; @@ -110,7 +110,7 @@ tAST_Script *Parse_Buffer(tSpiderVariant *Variant, char *Buffer) // Define a function case TOK_RWD_FUNCTION: if( !Variant->bDyamicTyped ) { - fprintf(stderr, "ERROR: Attempt to create a dynamic function\n"); + fprintf(stderr, "ERROR: Dynamic functions are invalid in static mode\n"); longjmp(Parser->JmpTarget, -1); } type = SS_DATATYPE_DYNAMIC; @@ -155,7 +155,7 @@ tAST_Script *Parse_Buffer(tSpiderVariant *Variant, char *Buffer) fcn = AST_AppendFunction( ret, "" ); AST_SetFunctionCode( fcn, mainCode ); - printf("---- %p parsed as SpiderScript ----\n", Buffer); + //printf("---- %p parsed as SpiderScript ----\n", Buffer); return ret; } @@ -194,12 +194,15 @@ tAST_Node *Parse_DoBlockLine(tParser *Parser) switch(LookAhead(Parser)) { + // Empty statement + case TOK_SEMICOLON: + GetToken(Parser); + return NULL; // Return from a method case TOK_RWD_RETURN: - //printf("return\n"); GetToken(Parser); - ret = AST_NewUniOp(NODETYPE_RETURN, Parse_DoExpr0(Parser)); + ret = AST_NewUniOp(Parser, NODETYPE_RETURN, Parse_DoExpr0(Parser)); break; // Control Statements @@ -215,13 +218,39 @@ tAST_Node *Parse_DoBlockLine(tParser *Parser) GetToken(Parser); false = Parse_DoCodeBlock(Parser); } - ret = AST_NewIf(cond, true, false); + ret = AST_NewIf(Parser, cond, true, false); } return ret; + case TOK_RWD_FOR: + { + tAST_Node *init=NULL, *cond=NULL, *inc=NULL, *code; + GetToken(Parser); // Eat 'for' + SyntaxAssert(Parser, GetToken(Parser), TOK_PAREN_OPEN); + + if(LookAhead(Parser) != TOK_SEMICOLON) + init = Parse_DoExpr0(Parser); + + SyntaxAssert(Parser, GetToken(Parser), TOK_SEMICOLON); + + if(LookAhead(Parser) != TOK_SEMICOLON) + cond = Parse_DoExpr0(Parser); + + SyntaxAssert(Parser, GetToken(Parser), TOK_SEMICOLON); + + if(LookAhead(Parser) != TOK_PAREN_CLOSE) + inc = Parse_DoExpr0(Parser); + + SyntaxAssert(Parser, GetToken(Parser), TOK_PAREN_CLOSE); + + code = Parse_DoCodeBlock(Parser); + ret = AST_NewLoop(Parser, init, 0, cond, inc, code); + } + return ret; + case TOK_RWD_DO: case TOK_RWD_WHILE: - TODO(Parser, "Implement if, for, do and while\n"); + TODO(Parser, "Implement do and while\n"); break; // Define Variables @@ -268,7 +297,7 @@ tAST_Node *Parse_GetVarDef(tParser *Parser, int Type) memcpy(name, Parser->TokenStr+1, Parser->TokenLen-1); name[Parser->TokenLen-1] = 0; // Define the variable - ret = AST_NewDefineVar(Type, name); + ret = AST_NewDefineVar(Parser, Type, name); // Handle arrays while( LookAhead(Parser) == TOK_SQUARE_OPEN ) { @@ -291,18 +320,24 @@ tAST_Node *Parse_DoExpr0(tParser *Parser) { case TOK_ASSIGN: GetToken(Parser); // Eat Token - ret = AST_NewAssign(NODETYPE_NOP, ret, Parse_DoExpr0(Parser)); + ret = AST_NewAssign(Parser, NODETYPE_NOP, ret, Parse_DoExpr0(Parser)); break; - #if 0 - case TOK_DIV_EQU: + case TOK_ASSIGN_DIV: GetToken(Parser); // Eat Token - ret = AST_NewAssign(NODETYPE_DIVIDE, ret, Parse_DoExpr0(Parser)); + ret = AST_NewAssign(Parser, NODETYPE_DIVIDE, ret, Parse_DoExpr0(Parser)); break; - case TOK_MULT_EQU: + case TOK_ASSIGN_MUL: GetToken(Parser); // Eat Token - ret = AST_NewAssign(NODETYPE_MULTIPLY, ret, Parse_DoExpr0(Parser)); + ret = AST_NewAssign(Parser, NODETYPE_MULTIPLY, ret, Parse_DoExpr0(Parser)); + break; + case TOK_ASSIGN_PLUS: + GetToken(Parser); // Eat Token + ret = AST_NewAssign(Parser, NODETYPE_ADD, ret, Parse_DoExpr0(Parser)); + break; + case TOK_ASSIGN_MINUS: + GetToken(Parser); // Eat Token + ret = AST_NewAssign(Parser, NODETYPE_SUBTRACT, ret, Parse_DoExpr0(Parser)); break; - #endif default: #if DEBUG >= 2 printf("Parse_DoExpr0: Parser->Token = %i\n", Parser->Token); @@ -322,13 +357,13 @@ tAST_Node *Parse_DoExpr1(tParser *Parser) switch(GetToken(Parser)) { case TOK_LOGICAND: - ret = AST_NewBinOp(NODETYPE_LOGICALAND, ret, Parse_DoExpr1(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_LOGICALAND, ret, Parse_DoExpr1(Parser)); break; case TOK_LOGICOR: - ret = AST_NewBinOp(NODETYPE_LOGICALOR, ret, Parse_DoExpr1(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_LOGICALOR, ret, Parse_DoExpr1(Parser)); break; case TOK_LOGICXOR: - ret = AST_NewBinOp(NODETYPE_LOGICALXOR, ret, Parse_DoExpr1(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_LOGICALXOR, ret, Parse_DoExpr1(Parser)); break; default: PutBack(Parser); @@ -348,13 +383,13 @@ tAST_Node *Parse_DoExpr2(tParser *Parser) switch(GetToken(Parser)) { case TOK_EQUALS: - ret = AST_NewBinOp(NODETYPE_EQUALS, ret, Parse_DoExpr2(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_EQUALS, ret, Parse_DoExpr2(Parser)); break; case TOK_LT: - ret = AST_NewBinOp(NODETYPE_LESSTHAN, ret, Parse_DoExpr2(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_LESSTHAN, ret, Parse_DoExpr2(Parser)); break; case TOK_GT: - ret = AST_NewBinOp(NODETYPE_GREATERTHAN, ret, Parse_DoExpr2(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_GREATERTHAN, ret, Parse_DoExpr2(Parser)); break; default: PutBack(Parser); @@ -374,13 +409,13 @@ tAST_Node *Parse_DoExpr3(tParser *Parser) switch(GetToken(Parser)) { case TOK_OR: - ret = AST_NewBinOp(NODETYPE_BWOR, ret, Parse_DoExpr3(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_BWOR, ret, Parse_DoExpr3(Parser)); break; case TOK_AND: - ret = AST_NewBinOp(NODETYPE_BWAND, ret, Parse_DoExpr3(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_BWAND, ret, Parse_DoExpr3(Parser)); break; case TOK_XOR: - ret = AST_NewBinOp(NODETYPE_BWXOR, ret, Parse_DoExpr3(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_BWXOR, ret, Parse_DoExpr3(Parser)); break; default: PutBack(Parser); @@ -399,10 +434,10 @@ tAST_Node *Parse_DoExpr4(tParser *Parser) switch(GetToken(Parser)) { case TOK_SHL: - ret = AST_NewBinOp(NODETYPE_BITSHIFTLEFT, ret, Parse_DoExpr5(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_BITSHIFTLEFT, ret, Parse_DoExpr5(Parser)); break; case TOK_SHR: - ret = AST_NewBinOp(NODETYPE_BITSHIFTRIGHT, ret, Parse_DoExpr5(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_BITSHIFTRIGHT, ret, Parse_DoExpr5(Parser)); break; default: PutBack(Parser); @@ -422,10 +457,10 @@ tAST_Node *Parse_DoExpr5(tParser *Parser) switch(GetToken(Parser)) { case TOK_PLUS: - ret = AST_NewBinOp(NODETYPE_ADD, ret, Parse_DoExpr5(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_ADD, ret, Parse_DoExpr5(Parser)); break; case TOK_MINUS: - ret = AST_NewBinOp(NODETYPE_SUBTRACT, ret, Parse_DoExpr5(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_SUBTRACT, ret, Parse_DoExpr5(Parser)); break; default: PutBack(Parser); @@ -445,10 +480,10 @@ tAST_Node *Parse_DoExpr6(tParser *Parser) switch(GetToken(Parser)) { case TOK_MUL: - ret = AST_NewBinOp(NODETYPE_MULTIPLY, ret, Parse_DoExpr6(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_MULTIPLY, ret, Parse_DoExpr6(Parser)); break; case TOK_DIV: - ret = AST_NewBinOp(NODETYPE_DIVIDE, ret, Parse_DoExpr6(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_DIVIDE, ret, Parse_DoExpr6(Parser)); break; default: PutBack(Parser); @@ -480,7 +515,7 @@ tAST_Node *Parse_DoParen(tParser *Parser) GetToken(Parser); TOKEN_GET_DATATYPE(type, Parser->Token); SyntaxAssert(Parser, GetToken(Parser), TOK_PAREN_CLOSE); - ret = AST_NewCast(type, Parse_DoParen(Parser)); + ret = AST_NewCast(Parser, type, Parse_DoParen(Parser)); break; default: ret = Parse_DoExpr0(Parser); @@ -551,7 +586,7 @@ tAST_Node *Parse_GetString(tParser *Parser) } // TODO: Parse Escape Codes - ret = AST_NewString( data, j ); + ret = AST_NewString( Parser, data, j ); } return ret; } @@ -561,10 +596,50 @@ tAST_Node *Parse_GetString(tParser *Parser) */ tAST_Node *Parse_GetNumeric(tParser *Parser) { - uint64_t value; + uint64_t value = 0; + char *pos; GetToken( Parser ); - value = atoi( Parser->TokenStr ); - return AST_NewInteger( value ); + pos = Parser->TokenStr; + //printf("pos = %p, *pos = %c\n", pos, *pos); + + if( *pos == '0' ) + { + pos ++; + if(*pos == 'x') { + pos ++; + for( ;; pos++) + { + value *= 16; + if( '0' <= *pos && *pos <= '9' ) { + value += *pos - '0'; + continue; + } + if( 'A' <= *pos && *pos <= 'F' ) { + value += *pos - 'A' + 10; + continue; + } + if( 'a' <= *pos && *pos <= 'f' ) { + value += *pos - 'a' + 10; + continue; + } + break; + } + } + else { + while( '0' <= *pos && *pos <= '7' ) { + value = value*8 + *pos - '0'; + pos ++; + } + } + } + else { + while( '0' <= *pos && *pos <= '9' ) { + value = value*10 + *pos - '0'; + pos ++; + } + } + + return AST_NewInteger( Parser, value ); } /** @@ -578,7 +653,7 @@ tAST_Node *Parse_GetVariable(tParser *Parser) char name[Parser->TokenLen]; memcpy(name, Parser->TokenStr+1, Parser->TokenLen-1); name[Parser->TokenLen-1] = 0; - ret = AST_NewVariable( name ); + ret = AST_NewVariable( Parser, name ); #if DEBUG >= 2 printf("Parse_GetVariable: name = '%s'\n", name); #endif @@ -587,18 +662,18 @@ tAST_Node *Parse_GetVariable(tParser *Parser) while( LookAhead(Parser) == TOK_SQUARE_OPEN ) { GetToken(Parser); - ret = AST_NewBinOp(NODETYPE_INDEX, ret, Parse_DoExpr0(Parser)); + ret = AST_NewBinOp(Parser, NODETYPE_INDEX, ret, Parse_DoExpr0(Parser)); SyntaxAssert(Parser, GetToken(Parser), TOK_SQUARE_CLOSE); } return ret; } /** - * \brief Get an identifier (constand or function call) + * \brief Get an identifier (constant or function call) */ tAST_Node *Parse_GetIdent(tParser *Parser) { - tAST_Node *ret; + tAST_Node *ret = NULL; char *name; SyntaxAssert(Parser, GetToken(Parser), TOK_IDENT ); name = strndup( Parser->TokenStr, Parser->TokenLen ); @@ -606,7 +681,9 @@ tAST_Node *Parse_GetIdent(tParser *Parser) #if 0 while( GetToken(Parser) == TOK_SCOPE ) { - ret = AST_New + ret = AST_NewScopeDereference( Parser, ret, name ); + SyntaxAssert(Parser, GetToken(Parser), TOK_IDENT ); + name = strndup( Parser->TokenStr, Parser->TokenLen ); } PutBack(Parser); #endif @@ -617,7 +694,7 @@ tAST_Node *Parse_GetIdent(tParser *Parser) printf("Parse_GetIdent: Calling '%s'\n", name); #endif // Function Call - ret = AST_NewFunctionCall( name ); + ret = AST_NewFunctionCall( Parser, name ); // Read arguments if( GetToken(Parser) != TOK_PAREN_CLOSE ) { @@ -635,12 +712,12 @@ tAST_Node *Parse_GetIdent(tParser *Parser) } } else { - // Runtime Constant + // Runtime Constant / Variable (When implemented) #if DEBUG >= 2 printf("Parse_GetIdent: Referencing '%s'\n", name); #endif PutBack(Parser); - ret = AST_NewConstant( name ); + ret = AST_NewConstant( Parser, name ); } free(name);