X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Usermode%2FLibraries%2Flibspiderscript.so_src%2Fast.c;h=1ea7e3e5ad9a5a4f8718aafef547b755e15909e3;hb=0f81e4f273cdf1032e9bca55b4185ca9113596cc;hp=b662e320ffbcfd7155bf739d17f121dfb4add4b2;hpb=36798cbabac865188cd43b04cce2b818d39ce140;p=tpg%2Facess2.git diff --git a/Usermode/Libraries/libspiderscript.so_src/ast.c b/Usermode/Libraries/libspiderscript.so_src/ast.c index b662e320..1ea7e3e5 100644 --- a/Usermode/Libraries/libspiderscript.so_src/ast.c +++ b/Usermode/Libraries/libspiderscript.so_src/ast.c @@ -65,216 +65,168 @@ void AST_SetFunctionCode(tAST_Function *Function, tAST_Node *Root) * \name Node Manipulation * \{ */ +#define WRITE_N(_buffer, _offset, _len, _dataptr) do { \ + if(_buffer) memcpy((char*)_buffer + _offset, _dataptr, _len);\ + _offset += _len; \ +} while(0) + +#define WRITE_8(_buffer, _offset, _val) do {\ + uint8_t v = (_val);\ + WRITE_N(_buffer, _offset, 1, &v);\ +} while(0) +#define WRITE_16(_buffer, _offset, _val) do {\ + uint16_t v = (_val);\ + WRITE_N(_buffer, _offset, 2, &v);\ +} while(0) +#define WRITE_32(_buffer, _offset, _val) do {\ + uint32_t v = (_val);\ + WRITE_N(_buffer, _offset, 4, &v);\ +} while(0) +#define WRITE_64(_buffer, _offset, _val) do {\ + uint64_t v = (_val);\ + WRITE_N(_buffer, _offset, 8, &v);\ +} while(0) +#define WRITE_REAL(_buffer, _offset, _val) do {\ + double v = (_val);\ + WRITE_N(_buffer, _offset, sizeof(double), &v);\ +} while(0) + +#define WRITE_STR(_buffer, _offset, _string) do {\ + int len = strlen(_string);\ + WRITE_16(_buffer, _offset, len);\ + WRITE_N(_buffer, _offset, len, _string);\ + if((_offset & 1) == 1)WRITE_8(_buffer, _offset, 0); \ + if((_offset & 3) == 2)WRITE_16(_buffer, _offset, 0); \ +} while(0) +#define WRITE_NODELIST(_buffer, _offset, _listHead) do {\ + tAST_Node *node; \ + size_t ptr = -1;\ + for(node=(_listHead); node; node = node->NextSibling) {\ + ptr = _offset;\ + _offset += AST_WriteNode(_buffer, _offset, node); \ + WRITE_32(_buffer, ptr, ptr); \ + } \ + if(ptr != -1){ptr -= 4; WRITE_32(_buffer, ptr, 0);} \ +} while(0) + /** - * \brief Get the in-memory size of a node + * \brief Writes a script dump to a buffer + * \return Size of encoded data + * \note If \a Buffer is NULL, no write is done, but the size is still returned */ -size_t AST_GetNodeSize(tAST_Node *Node) +size_t AST_WriteScript(void *Buffer, tAST_Script *Script) { - size_t ret; - tAST_Node *node; - - if(!Node) - return 0; + tAST_Function *fcn; + size_t ret = 0, ptr = 0; - ret = sizeof(tAST_Node*) + sizeof(tAST_NodeType) - + sizeof(const char *) + sizeof(int); - - switch(Node->Type) + for( fcn = Script->Functions; fcn; fcn = fcn->Next ) { - // Block of code - case NODETYPE_BLOCK: - ret += sizeof(Node->Block); - for( node = Node->Block.FirstChild; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } - break; - - // Function Call - case NODETYPE_FUNCTIONCALL: - ret += sizeof(Node->FunctionCall) + strlen(Node->FunctionCall.Name) + 1; - for( node = Node->FunctionCall.FirstArg; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } - break; - - // If node - case NODETYPE_IF: - ret += sizeof(Node->If); - ret += AST_GetNodeSize(Node->If.Condition); - ret += AST_GetNodeSize(Node->If.True); - ret += AST_GetNodeSize(Node->If.False); - break; - - // Looping Construct (For loop node) - case NODETYPE_LOOP: - ret += sizeof(Node->For); - ret += AST_GetNodeSize(Node->For.Init); - ret += AST_GetNodeSize(Node->For.Condition); - ret += AST_GetNodeSize(Node->For.Increment); - ret += AST_GetNodeSize(Node->For.Code); - break; - - // Asignment - case NODETYPE_ASSIGN: - ret += sizeof(Node->Assign); - ret += AST_GetNodeSize(Node->Assign.Dest); - ret += AST_GetNodeSize(Node->Assign.Value); - break; - - // Casting - case NODETYPE_CAST: - ret += sizeof(Node->Cast); - ret += AST_GetNodeSize(Node->Cast.Value); - break; - - // Define a variable - case NODETYPE_DEFVAR: - ret += sizeof(Node->DefVar) + strlen(Node->DefVar.Name) + 1; - for( node = Node->DefVar.LevelSizes; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } - break; - - // Unary Operations - case NODETYPE_RETURN: - ret += sizeof(Node->UniOp); - ret += AST_GetNodeSize(Node->UniOp.Value); - break; - - // Binary Operations - case NODETYPE_INDEX: - case NODETYPE_ADD: - case NODETYPE_SUBTRACT: - case NODETYPE_MULTIPLY: - case NODETYPE_DIVIDE: - case NODETYPE_MODULO: - case NODETYPE_BITSHIFTLEFT: - case NODETYPE_BITSHIFTRIGHT: - case NODETYPE_BITROTATELEFT: - case NODETYPE_BWAND: case NODETYPE_LOGICALAND: - case NODETYPE_BWOR: case NODETYPE_LOGICALOR: - case NODETYPE_BWXOR: case NODETYPE_LOGICALXOR: - case NODETYPE_EQUALS: - case NODETYPE_LESSTHAN: - case NODETYPE_GREATERTHAN: - ret += sizeof(Node->BinOp); - ret += AST_GetNodeSize( Node->BinOp.Left ); - ret += AST_GetNodeSize( Node->BinOp.Right ); - break; - - // Node types with no children - case NODETYPE_NOP: - break; - case NODETYPE_VARIABLE: - case NODETYPE_CONSTANT: - ret += sizeof(Node->Variable) + strlen(Node->Variable.Name) + 1; - break; - case NODETYPE_STRING: - ret += sizeof(Node->String) + Node->String.Length; - break; - case NODETYPE_INTEGER: - ret += sizeof(Node->Integer); - break; - case NODETYPE_REAL: - ret += sizeof(Node->Real); - break; + ptr = ret; + WRITE_32(Buffer, ret, 0); // Next + WRITE_STR(Buffer, ret, fcn->Name); + WRITE_NODELIST(Buffer, ret, fcn->Arguments); // TODO: Cheaper way + ret += AST_WriteNode(Buffer, ret, fcn->Code); + WRITE_32(Buffer, ptr, ret); // Actually set next + } + if( ptr ) + { + ptr -= 4; + WRITE_32(Buffer, ptr, 0); // Clear next for final } + return ret; } -#if 0 /** * \brief Write a node to a file */ -void AST_WriteNode(FILE *FP, tAST_Node *Node) +size_t AST_WriteNode(void *Buffer, size_t Offset, tAST_Node *Node) { - tAST_Node *node; - intptr_t ptr; - int ret; + size_t baseOfs = Offset; - if(!Node) return ; - - ptr = ftell(FP) + AST_GetNodeSize(Node); - fwrite(&ptr, sizeof(ptr), 1, FP); - fwrite(&Node->Type, sizeof(Node->Type), 1, FP); - ptr = 0; fwrite(&ptr, sizeof(ptr), 1, FP); // File - fwrite(&Node->Line, sizeof(Node->Line), 1, FP); + if(!Node) { + fprintf(stderr, "Possible Bug - NULL passed to AST_WriteNode\n"); + return 0; + } - ret = sizeof(tAST_Node*) + sizeof(tAST_NodeType) - + sizeof(const char *) + sizeof(int); + WRITE_32(Buffer, Offset, 0); // Next + WRITE_16(Buffer, Offset, Node->Type); + // TODO: Scan the buffer for the location of the filename (with NULL byte) + // else, write the string at the end of the node + WRITE_16(Buffer, Offset, Node->Line); // Line + //WRITE_32(Buffer, Offset, 0); // File switch(Node->Type) { // Block of code case NODETYPE_BLOCK: - ret += sizeof(Node->Block); - for( node = Node->Block.FirstChild; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } + WRITE_NODELIST(Buffer, Offset, Node->Block.FirstChild); break; // Function Call + case NODETYPE_METHODCALL: + Offset += AST_WriteNode(Buffer, Offset, Node->FunctionCall.Object); case NODETYPE_FUNCTIONCALL: - ret += sizeof(Node->FunctionCall) + strlen(Node->FunctionCall.Name) + 1; - for( node = Node->FunctionCall.FirstArg; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } + case NODETYPE_CREATEOBJECT: + // TODO: Search for the same function name and add a pointer + WRITE_STR(Buffer, Offset, Node->FunctionCall.Name); + WRITE_NODELIST(Buffer, Offset, Node->FunctionCall.FirstArg); break; // If node case NODETYPE_IF: - ret += sizeof(Node->If); - ret += AST_GetNodeSize(Node->If.Condition); - ret += AST_GetNodeSize(Node->If.True); - ret += AST_GetNodeSize(Node->If.False); + Offset += AST_WriteNode(Buffer, Offset, Node->If.Condition); + Offset += AST_WriteNode(Buffer, Offset, Node->If.True); + Offset += AST_WriteNode(Buffer, Offset, Node->If.False); break; // Looping Construct (For loop node) case NODETYPE_LOOP: - ret += sizeof(Node->For); - ret += AST_GetNodeSize(Node->For.Init); - ret += AST_GetNodeSize(Node->For.Condition); - ret += AST_GetNodeSize(Node->For.Increment); - ret += AST_GetNodeSize(Node->For.Code); + WRITE_8(Buffer, Offset, Node->For.bCheckAfter); + + Offset += AST_WriteNode(Buffer, Offset, Node->For.Init); + Offset += AST_WriteNode(Buffer, Offset, Node->For.Condition); + Offset += AST_WriteNode(Buffer, Offset, Node->For.Increment); + Offset += AST_WriteNode(Buffer, Offset, Node->For.Code); break; // Asignment case NODETYPE_ASSIGN: - ret += sizeof(Node->Assign); - ret += AST_GetNodeSize(Node->Assign.Dest); - ret += AST_GetNodeSize(Node->Assign.Value); + WRITE_8(Buffer, Offset, Node->Assign.Operation); + Offset += AST_WriteNode(Buffer, Offset, Node->Assign.Dest); + Offset += AST_WriteNode(Buffer, Offset, Node->Assign.Value); break; // Casting case NODETYPE_CAST: - ret += sizeof(Node->Cast); - ret += AST_GetNodeSize(Node->Cast.Value); + WRITE_8(Buffer, Offset, Node->Cast.DataType); + Offset += AST_WriteNode(Buffer, Offset, Node->Cast.Value); break; // Define a variable case NODETYPE_DEFVAR: - ret += sizeof(Node->DefVar) + strlen(Node->DefVar.Name) + 1; - for( node = Node->DefVar.LevelSizes; node; ) - { - ret += AST_GetNodeSize(node); - node = node->NextSibling; - } + WRITE_8(Buffer, Offset, Node->DefVar.DataType); + // TODO: Duplicate compress the strings + WRITE_STR(Buffer, Offset, Node->DefVar.Name); + + WRITE_NODELIST(Buffer, Offset, Node->DefVar.LevelSizes); + break; + + // Scope Reference + case NODETYPE_SCOPE: + case NODETYPE_ELEMENT: + WRITE_STR(Buffer, Offset, Node->Scope.Name); + Offset += AST_WriteNode(Buffer, Offset, Node->UniOp.Value); break; // Unary Operations case NODETYPE_RETURN: - ret += sizeof(Node->UniOp); - ret += AST_GetNodeSize(Node->UniOp.Value); + case NODETYPE_BWNOT: + case NODETYPE_LOGICALNOT: + case NODETYPE_NEGATE: + case NODETYPE_POSTINC: + case NODETYPE_POSTDEC: + Offset += AST_WriteNode(Buffer, Offset, Node->UniOp.Value); break; // Binary Operations @@ -291,11 +243,10 @@ void AST_WriteNode(FILE *FP, tAST_Node *Node) case NODETYPE_BWOR: case NODETYPE_LOGICALOR: case NODETYPE_BWXOR: case NODETYPE_LOGICALXOR: case NODETYPE_EQUALS: - case NODETYPE_LESSTHAN: - case NODETYPE_GREATERTHAN: - ret += sizeof(Node->BinOp); - ret += AST_GetNodeSize( Node->BinOp.Left ); - ret += AST_GetNodeSize( Node->BinOp.Right ); + case NODETYPE_LESSTHAN: case NODETYPE_LESSTHANEQUAL: + case NODETYPE_GREATERTHAN: case NODETYPE_GREATERTHANEQUAL: + Offset += AST_WriteNode(Buffer, Offset, Node->BinOp.Left); + Offset += AST_WriteNode(Buffer, Offset, Node->BinOp.Right); break; // Node types with no children @@ -303,21 +254,27 @@ void AST_WriteNode(FILE *FP, tAST_Node *Node) break; case NODETYPE_VARIABLE: case NODETYPE_CONSTANT: - ret += sizeof(Node->Variable) + strlen(Node->Variable.Name) + 1; + // TODO: De-Duplicate the strings + WRITE_STR(Buffer, Offset, Node->Variable.Name); break; case NODETYPE_STRING: - ret += sizeof(Node->String) + Node->String.Length; + WRITE_32(Buffer, Offset, Node->Constant.String.Length); + WRITE_N(Buffer, Offset, Node->Constant.String.Length, Node->Constant.String.Data); break; case NODETYPE_INTEGER: - ret += sizeof(Node->Integer); + WRITE_64(Buffer, Offset, Node->Constant.Integer); break; case NODETYPE_REAL: - ret += sizeof(Node->Real); + WRITE_REAL(Buffer, Offset, Node->Constant.Real); break; + + //default: + // fprintf(stderr, "AST_WriteNode: Unknown node type %i\n", Node->Type); + // break; } - return ret; + + return Offset - baseOfs; } -#endif /** * \brief Free a node and all subnodes @@ -341,7 +298,10 @@ void AST_FreeNode(tAST_Node *Node) break; // Function Call + case NODETYPE_METHODCALL: + AST_FreeNode(Node->FunctionCall.Object); case NODETYPE_FUNCTIONCALL: + case NODETYPE_CREATEOBJECT: for( node = Node->FunctionCall.FirstArg; node; ) { tAST_Node *savedNext = node->NextSibling; @@ -376,6 +336,11 @@ void AST_FreeNode(tAST_Node *Node) AST_FreeNode(Node->Cast.Value); break; + case NODETYPE_SCOPE: + case NODETYPE_ELEMENT: + AST_FreeNode(Node->Scope.Element); + break; + // Define a variable case NODETYPE_DEFVAR: for( node = Node->DefVar.LevelSizes; node; ) @@ -388,6 +353,11 @@ void AST_FreeNode(tAST_Node *Node) // Unary Operations case NODETYPE_RETURN: + case NODETYPE_BWNOT: + case NODETYPE_LOGICALNOT: + case NODETYPE_NEGATE: + case NODETYPE_POSTINC: + case NODETYPE_POSTDEC: AST_FreeNode(Node->UniOp.Value); break; @@ -405,8 +375,8 @@ void AST_FreeNode(tAST_Node *Node) case NODETYPE_BWOR: case NODETYPE_LOGICALOR: case NODETYPE_BWXOR: case NODETYPE_LOGICALXOR: case NODETYPE_EQUALS: - case NODETYPE_LESSTHAN: - case NODETYPE_GREATERTHAN: + case NODETYPE_LESSTHAN: case NODETYPE_LESSTHANEQUAL: + case NODETYPE_GREATERTHAN: case NODETYPE_GREATERTHANEQUAL: AST_FreeNode( Node->BinOp.Left ); AST_FreeNode( Node->BinOp.Right ); break; @@ -415,20 +385,38 @@ void AST_FreeNode(tAST_Node *Node) case NODETYPE_NOP: break; case NODETYPE_VARIABLE: break; case NODETYPE_CONSTANT: break; - case NODETYPE_STRING: break; - case NODETYPE_INTEGER: break; - case NODETYPE_REAL: break; + + case NODETYPE_STRING: + case NODETYPE_INTEGER: + case NODETYPE_REAL: + if( Node->ValueCache ) + Object_Dereference(Node->ValueCache); + Node->ValueCache = NULL; + break; } free( Node ); } -tAST_Node *AST_NewCodeBlock(void) +tAST_Node *AST_int_AllocateNode(tParser *Parser, int Type, int ExtraSize) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); - + tAST_Node *ret = malloc( sizeof(tAST_Node) + ExtraSize ); ret->NextSibling = NULL; - //ret->Line = Parser->CurLine; - ret->Type = NODETYPE_BLOCK; + ret->File = ""; + ret->Line = Parser->CurLine; + ret->Type = Type; + + // Runtime Caching + ret->BlockState = NULL; + ret->BlockIdent = 0; + ret->ValueCache = NULL; + + return ret; +} + +tAST_Node *AST_NewCodeBlock(tParser *Parser) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_BLOCK, 0 ); + ret->Block.FirstChild = NULL; ret->Block.LastChild = NULL; @@ -466,10 +454,7 @@ void AST_AppendNode(tAST_Node *Parent, tAST_Node *Child) tAST_Node *AST_NewIf(tParser *Parser, tAST_Node *Condition, tAST_Node *True, tAST_Node *False) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_IF; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_IF, 0); ret->If.Condition = Condition; ret->If.True = True; ret->If.False = False; @@ -478,10 +463,7 @@ tAST_Node *AST_NewIf(tParser *Parser, tAST_Node *Condition, tAST_Node *True, tAS tAST_Node *AST_NewLoop(tParser *Parser, tAST_Node *Init, int bPostCheck, tAST_Node *Condition, tAST_Node *Increment, tAST_Node *Code) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_LOOP; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_LOOP, 0); ret->For.Init = Init; ret->For.bCheckAfter = !!bPostCheck; ret->For.Condition = Condition; @@ -492,11 +474,8 @@ tAST_Node *AST_NewLoop(tParser *Parser, tAST_Node *Init, int bPostCheck, tAST_No tAST_Node *AST_NewAssign(tParser *Parser, int Operation, tAST_Node *Dest, tAST_Node *Value) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_ASSIGN, 0); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_ASSIGN; ret->Assign.Operation = Operation; ret->Assign.Dest = Dest; ret->Assign.Value = Value; @@ -506,11 +485,8 @@ tAST_Node *AST_NewAssign(tParser *Parser, int Operation, tAST_Node *Dest, tAST_N tAST_Node *AST_NewCast(tParser *Parser, int Target, tAST_Node *Value) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_CAST, 0); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_CAST; ret->Cast.DataType = Target; ret->Cast.Value = Value; @@ -519,11 +495,8 @@ tAST_Node *AST_NewCast(tParser *Parser, int Target, tAST_Node *Value) tAST_Node *AST_NewBinOp(tParser *Parser, int Operation, tAST_Node *Left, tAST_Node *Right) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); + tAST_Node *ret = AST_int_AllocateNode(Parser, Operation, 0); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = Operation; ret->BinOp.Left = Left; ret->BinOp.Right = Right; @@ -534,29 +507,32 @@ tAST_Node *AST_NewBinOp(tParser *Parser, int Operation, tAST_Node *Left, tAST_No */ tAST_Node *AST_NewUniOp(tParser *Parser, int Operation, tAST_Node *Value) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); + tAST_Node *ret = AST_int_AllocateNode(Parser, Operation, 0); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = Operation; ret->UniOp.Value = Value; return ret; } +tAST_Node *AST_NewNop(tParser *Parser) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_NOP, 0); + + return ret; +} + /** * \brief Create a new string node */ tAST_Node *AST_NewString(tParser *Parser, const char *String, int Length) { - tAST_Node *ret = malloc( sizeof(tAST_Node) + Length + 1 ); + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_STRING, Length + 1); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_STRING; - ret->String.Length = Length; - memcpy(ret->String.Data, String, Length); - ret->String.Data[Length] = '\0'; + ret->Constant.Type = SS_DATATYPE_STRING; + ret->Constant.ReferenceCount = 1; + ret->Constant.String.Length = Length; + memcpy(ret->Constant.String.Data, String, Length); + ret->Constant.String.Data[Length] = '\0'; return ret; } @@ -564,13 +540,24 @@ tAST_Node *AST_NewString(tParser *Parser, const char *String, int Length) /** * \brief Create a new integer node */ -tAST_Node *AST_NewInteger(tParser *Parser, uint64_t Value) +tAST_Node *AST_NewInteger(tParser *Parser, int64_t Value) { - tAST_Node *ret = malloc( sizeof(tAST_Node) ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_INTEGER; - ret->Integer = Value; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_INTEGER, 0); + ret->Constant.Type = SS_DATATYPE_INTEGER; + ret->Constant.ReferenceCount = 1; + ret->Constant.Integer = Value; + return ret; +} + +/** + * \brief Create a new real number node + */ +tAST_Node *AST_NewReal(tParser *Parser, double Value) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_REAL, 0); + ret->Constant.Type = SS_DATATYPE_REAL; + ret->Constant.ReferenceCount = 1; + ret->Constant.Real = Value; return ret; } @@ -579,10 +566,7 @@ tAST_Node *AST_NewInteger(tParser *Parser, uint64_t Value) */ tAST_Node *AST_NewVariable(tParser *Parser, const char *Name) { - tAST_Node *ret = malloc( sizeof(tAST_Node) + strlen(Name) + 1 ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_VARIABLE; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_VARIABLE, strlen(Name) + 1 ); strcpy(ret->Variable.Name, Name); return ret; } @@ -592,13 +576,12 @@ tAST_Node *AST_NewVariable(tParser *Parser, const char *Name) */ tAST_Node *AST_NewDefineVar(tParser *Parser, int Type, const char *Name) { - tAST_Node *ret = malloc( sizeof(tAST_Node) + strlen(Name) + 1 ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_DEFVAR; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_DEFVAR, strlen(Name) + 1 ); + ret->DefVar.DataType = Type; ret->DefVar.LevelSizes = NULL; strcpy(ret->DefVar.Name, Name); + return ret; } @@ -607,11 +590,10 @@ tAST_Node *AST_NewDefineVar(tParser *Parser, int Type, const char *Name) */ tAST_Node *AST_NewConstant(tParser *Parser, const char *Name) { - tAST_Node *ret = malloc( sizeof(tAST_Node) + strlen(Name) + 1 ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_CONSTANT; + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_CONSTANT, strlen(Name) + 1 ); + strcpy(ret->Variable.Name, Name); + return ret; } @@ -621,14 +603,39 @@ tAST_Node *AST_NewConstant(tParser *Parser, const char *Name) */ tAST_Node *AST_NewFunctionCall(tParser *Parser, const char *Name) { - tAST_Node *ret = malloc( sizeof(tAST_Node) + strlen(Name) + 1 ); + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_FUNCTIONCALL, strlen(Name) + 1 ); - ret->NextSibling = NULL; - ret->Line = Parser->CurLine; - ret->Type = NODETYPE_FUNCTIONCALL; + ret->FunctionCall.Object = NULL; + ret->FunctionCall.FirstArg = NULL; + ret->FunctionCall.LastArg = NULL; + ret->FunctionCall.NumArgs = 0; + strcpy(ret->FunctionCall.Name, Name); + + return ret; +} +tAST_Node *AST_NewMethodCall(tParser *Parser, tAST_Node *Object, const char *Name) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_METHODCALL, strlen(Name) + 1 ); + + ret->FunctionCall.Object = Object; + ret->FunctionCall.FirstArg = NULL; + ret->FunctionCall.LastArg = NULL; + ret->FunctionCall.NumArgs = 0; + strcpy(ret->FunctionCall.Name, Name); + + return ret; +} + +tAST_Node *AST_NewCreateObject(tParser *Parser, const char *Name) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_CREATEOBJECT, strlen(Name) + 1 ); + + ret->FunctionCall.Object = NULL; ret->FunctionCall.FirstArg = NULL; ret->FunctionCall.LastArg = NULL; + ret->FunctionCall.NumArgs = 0; strcpy(ret->FunctionCall.Name, Name); + return ret; } @@ -637,7 +644,13 @@ tAST_Node *AST_NewFunctionCall(tParser *Parser, const char *Name) */ void AST_AppendFunctionCallArg(tAST_Node *Node, tAST_Node *Arg) { - if( Node->Type != NODETYPE_FUNCTIONCALL ) return ; + if( Node->Type != NODETYPE_FUNCTIONCALL + && Node->Type != NODETYPE_CREATEOBJECT + && Node->Type != NODETYPE_METHODCALL) + { + fprintf(stderr, "BUG REPORT: AST_AppendFunctionCallArg on an invalid node type (%i)\n", Node->Type); + return ; + } if(Node->FunctionCall.LastArg) { Node->FunctionCall.LastArg->NextSibling = Arg; @@ -647,6 +660,29 @@ void AST_AppendFunctionCallArg(tAST_Node *Node, tAST_Node *Arg) Node->FunctionCall.FirstArg = Arg; Node->FunctionCall.LastArg = Arg; } + Node->FunctionCall.NumArgs ++; +} + +/** + * \brief Add a scope node + */ +tAST_Node *AST_NewScopeDereference(tParser *Parser, const char *Name, tAST_Node *Child) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_SCOPE, strlen(Name) + 1 ); + ret->Scope.Element = Child; + strcpy(ret->Scope.Name, Name); + return ret; +} + +/** + * \brief Add a scope node + */ +tAST_Node *AST_NewClassElement(tParser *Parser, tAST_Node *Object, const char *Name) +{ + tAST_Node *ret = AST_int_AllocateNode(Parser, NODETYPE_ELEMENT, strlen(Name) + 1 ); + ret->Scope.Element = Object; + strcpy(ret->Scope.Name, Name); + return ret; } /**