+#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 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_WriteScript(void *Buffer, tAST_Script *Script)
+{
+ tAST_Function *fcn;
+ size_t ret = 0, ptr = 0;
+
+ for( fcn = Script->Functions; fcn; fcn = fcn->Next )
+ {
+// printf("fcn = %p, fcn->Name = %p\n", fcn, fcn->Name);
+ 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;
+}
+
+/**
+ * \brief Write a node to a file
+ */
+size_t AST_WriteNode(void *Buffer, size_t Offset, tAST_Node *Node)
+{
+ size_t baseOfs = Offset;
+
+ if(!Node) {
+ //fprintf(stderr, "Possible Bug - NULL passed to AST_WriteNode\n");
+ WRITE_32(Buffer, Offset, 0);
+ WRITE_16(Buffer, Offset, NODETYPE_NOP);
+ WRITE_16(Buffer, Offset, 0); // Line (0)
+ return 0;
+ }
+
+ 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:
+ WRITE_NODELIST(Buffer, Offset, Node->Block.FirstChild);
+ break;
+
+ // Function Call
+ case NODETYPE_METHODCALL:
+ Offset += AST_WriteNode(Buffer, Offset, Node->FunctionCall.Object);
+ case NODETYPE_FUNCTIONCALL:
+ 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:
+ 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:
+ 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:
+ 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:
+ WRITE_8(Buffer, Offset, Node->Cast.DataType);
+ Offset += AST_WriteNode(Buffer, Offset, Node->Cast.Value);
+ break;
+
+ // Define a variable
+ case NODETYPE_DEFVAR:
+ 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);
+ Offset += AST_WriteNode(Buffer, Offset, Node->DefVar.InitialValue);
+ 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:
+ 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
+ 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_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
+ case NODETYPE_NOP:
+ break;
+ case NODETYPE_VARIABLE:
+ case NODETYPE_CONSTANT:
+ // TODO: De-Duplicate the strings
+ WRITE_STR(Buffer, Offset, Node->Variable.Name);
+ break;
+ case NODETYPE_STRING:
+ WRITE_32(Buffer, Offset, Node->Constant.String.Length);
+ WRITE_N(Buffer, Offset, Node->Constant.String.Length, Node->Constant.String.Data);
+ break;
+ case NODETYPE_INTEGER:
+ WRITE_64(Buffer, Offset, Node->Constant.Integer);
+ break;
+ case NODETYPE_REAL:
+ WRITE_REAL(Buffer, Offset, Node->Constant.Real);
+ break;
+
+ //default:
+ // fprintf(stderr, "AST_WriteNode: Unknown node type %i\n", Node->Type);
+ // break;
+ }
+
+ return Offset - baseOfs;
+}
+