-moved script to modules

1 files changed, 1531 insertions, 0 deletions

diff --git a/modules/gdscript/gd_compiler.cpp b/modules/gdscript/gd_compiler.cpp
new file mode 100644
index 0000000000..dd2834bf34
--- /dev/null
+++ b/modules/gdscript/gd_compiler.cpp
@@ -0,0 +1,1531 @@
+/*************************************************************************/
+/*  gd_compiler.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "gd_compiler.h"
+#include "gd_script.h"
+/* TODO:
+
+   *AND and OR need early abort
+   -Inheritance properly process (done?)
+   *create built in initializer and constructor
+   *assign operators
+   *build arrays and dictionaries
+   *call parent constructor
+ */
+
+
+void GDCompiler::_set_error(const String& p_error,const GDParser::Node *p_node) {
+
+	if (error!="")
+		return;
+
+	error=p_error;
+	err_line=p_node->line;
+	err_column=p_node->column;
+}
+
+bool GDCompiler::_create_unary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level) {
+
+	ERR_FAIL_COND_V(on->arguments.size()!=1,false);
+
+	int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level);
+	if (src_address_a<0)
+		return false;
+
+	codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(op); //which operator
+	codegen.opcodes.push_back(src_address_a); // argument 1
+	codegen.opcodes.push_back(GDFunction::ADDR_TYPE_NIL); // argument 2 (unary only takes one parameter)
+	return true;
+}
+
+bool GDCompiler::_create_binary_operator(CodeGen& codegen,const GDParser::OperatorNode *on,Variant::Operator op, int p_stack_level) {
+
+	ERR_FAIL_COND_V(on->arguments.size()!=2,false);
+
+
+	int src_address_a = _parse_expression(codegen,on->arguments[0],p_stack_level);
+	if (src_address_a<0)
+		return false;
+	if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)
+		p_stack_level++; //uses stack for return, increase stack
+
+	int src_address_b = _parse_expression(codegen,on->arguments[1],p_stack_level);
+	if (src_address_b<0)
+		return false;
+
+
+	codegen.opcodes.push_back(GDFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(op); //which operator
+	codegen.opcodes.push_back(src_address_a); // argument 1
+	codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+	return true;
+}
+
+
+/*
+int GDCompiler::_parse_subexpression(CodeGen& codegen,const GDParser::Node *p_expression) {
+
+
+	int ret = _parse_expression(codegen,p_expression);
+	if (ret<0)
+		return ret;
+
+	if (ret&(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)) {
+		codegen.stack_level++;
+		codegen.check_max_stack_level();
+		//stack was used, keep value
+	}
+
+	return ret;
+}
+*/
+
+int GDCompiler::_parse_assign_right_expression(CodeGen& codegen,const GDParser::OperatorNode *p_expression, int p_stack_level) {
+
+	Variant::Operator var_op=Variant::OP_MAX;
+
+	switch(p_expression->op) {
+
+		case GDParser::OperatorNode::OP_ASSIGN_ADD: var_op=Variant::OP_ADD; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SUB: var_op=Variant::OP_SUBSTRACT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_MUL: var_op=Variant::OP_MULTIPLY; break;
+		case GDParser::OperatorNode::OP_ASSIGN_DIV: var_op=Variant::OP_DIVIDE; break;
+		case GDParser::OperatorNode::OP_ASSIGN_MOD: var_op=Variant::OP_MODULE; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT: var_op=Variant::OP_SHIFT_LEFT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: var_op=Variant::OP_SHIFT_RIGHT; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: var_op=Variant::OP_BIT_AND; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: var_op=Variant::OP_BIT_OR; break;
+		case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: var_op=Variant::OP_BIT_XOR; break;
+		case GDParser::OperatorNode::OP_ASSIGN: {
+
+			//none
+		} break;
+	default: {
+
+			ERR_FAIL_V(-1);
+		}
+	}
+
+	if (var_op==Variant::OP_MAX) {
+
+		return _parse_expression(codegen,p_expression->arguments[1],p_stack_level);
+	}
+
+	if (!_create_binary_operator(codegen,p_expression,var_op,p_stack_level))
+		return -1;
+
+	int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+	codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+	codegen.alloc_stack(p_stack_level);
+	return dst_addr;
+
+}
+
+int GDCompiler::_parse_expression(CodeGen& codegen,const GDParser::Node *p_expression, int p_stack_level,bool p_root) {
+
+
+	switch(p_expression->type) {
+		//should parse variable declaration and adjust stack accordingly...
+		case GDParser::Node::TYPE_IDENTIFIER: {
+			//return identifier
+			//wait, identifier could be a local variable or something else... careful here, must reference properly
+			//as stack may be more interesting to work with
+
+			//This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases peformance a lot.
+
+			const GDParser::IdentifierNode *in = static_cast<const GDParser::IdentifierNode*>(p_expression);
+
+			StringName identifier = in->name;
+
+			// TRY STACK!
+			if (codegen.stack_identifiers.has(identifier)) {
+
+				int pos = codegen.stack_identifiers[identifier];
+				return pos|(GDFunction::ADDR_TYPE_STACK_VARIABLE<<GDFunction::ADDR_BITS);
+
+			}
+			//TRY ARGUMENTS!
+			if (!codegen.function_node || !codegen.function_node->_static) {
+
+				// TRY MEMBER VARIABLES!
+
+				//static function
+				if (codegen.script->member_indices.has(identifier)) {
+
+					int idx = codegen.script->member_indices[identifier];
+					return idx|(GDFunction::ADDR_TYPE_MEMBER<<GDFunction::ADDR_BITS); //argument (stack root)
+				}
+			}
+
+			//TRY CLASS CONSTANTS
+
+			GDScript *scr = codegen.script;
+			GDNativeClass *nc=NULL;
+			while(scr) {
+
+				if (scr->constants.has(identifier)) {
+
+					//int idx=scr->constants[identifier];
+					int idx = codegen.get_name_map_pos(identifier);
+					return idx|(GDFunction::ADDR_TYPE_CLASS_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root)
+				}
+				if (scr->native.is_valid())
+					nc=scr->native.ptr();
+				scr=scr->_base;
+			}
+
+			// CLASS C++ Integer Constant
+
+			if (nc) {
+
+				bool success=false;
+				int constant = ObjectTypeDB::get_integer_constant(nc->get_name(),identifier,&success);
+				if (success) {
+					Variant key=constant;
+					int idx;
+
+					if (!codegen.constant_map.has(key)) {
+
+						idx=codegen.constant_map.size();
+						codegen.constant_map[key]=idx;
+
+					} else {
+						idx=codegen.constant_map[key];
+					}
+
+					return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //make it a local constant (faster access)
+				}
+
+			}
+
+			if (codegen.script->subclasses.has(identifier)) {
+				//same with a subclass, make it a local constant.
+				int idx = codegen.get_constant_pos(codegen.script->subclasses[identifier]);
+				return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //make it a local constant (faster access)
+
+			}
+
+			if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
+
+				int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier];
+				return idx|(GDFunction::ADDR_TYPE_GLOBAL<<GDFunction::ADDR_BITS); //argument (stack root)
+			}
+
+			//not found, error
+
+			_set_error("Identifier not found: "+String(identifier),p_expression);
+
+			return -1;
+
+
+		} break;
+		case GDParser::Node::TYPE_CONSTANT: {
+			//return constant
+			const GDParser::ConstantNode *cn = static_cast<const GDParser::ConstantNode*>(p_expression);
+
+
+			int idx;
+
+			if (!codegen.constant_map.has(cn->value)) {
+
+				idx=codegen.constant_map.size();
+				codegen.constant_map[cn->value]=idx;
+
+			} else {
+				idx=codegen.constant_map[cn->value];
+			}
+
+
+			return idx|(GDFunction::ADDR_TYPE_LOCAL_CONSTANT<<GDFunction::ADDR_BITS); //argument (stack root)
+
+		} break;
+		case GDParser::Node::TYPE_SELF: {
+			//return constant
+			if (codegen.function_node && codegen.function_node->_static) {
+				_set_error("'self' not present in static function!",p_expression);
+				return -1;
+			}
+			return (GDFunction::ADDR_TYPE_SELF<<GDFunction::ADDR_BITS);
+		} break;
+		case GDParser::Node::TYPE_ARRAY: {
+
+			const GDParser::ArrayNode *an = static_cast<const GDParser::ArrayNode*>(p_expression);
+			Vector<int> values;
+
+			int slevel=p_stack_level;
+
+			for(int i=0;i<an->elements.size();i++) {
+
+				int ret = _parse_expression(codegen,an->elements[i],slevel);
+				if (ret<0)
+					return ret;
+				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+			}
+
+			codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_ARRAY);
+			codegen.opcodes.push_back(values.size());
+			for(int i=0;i<values.size();i++)
+				codegen.opcodes.push_back(values[i]);
+
+			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+
+		} break;
+		case GDParser::Node::TYPE_DICTIONARY: {
+
+			const GDParser::DictionaryNode *dn = static_cast<const GDParser::DictionaryNode*>(p_expression);
+			Vector<int> values;
+
+			int slevel=p_stack_level;
+
+			for(int i=0;i<dn->elements.size();i++) {
+
+				int ret = _parse_expression(codegen,dn->elements[i].key,slevel);
+				if (ret<0)
+					return ret;
+				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+
+				ret = _parse_expression(codegen,dn->elements[i].value,slevel);
+				if (ret<0)
+					return ret;
+				if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+					slevel++;
+					codegen.alloc_stack(slevel);
+				}
+
+				values.push_back(ret);
+			}
+
+			codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT_DICTIONARY);
+			codegen.opcodes.push_back(dn->elements.size());
+			for(int i=0;i<values.size();i++)
+				codegen.opcodes.push_back(values[i]);
+
+			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+
+		} break;
+		case GDParser::Node::TYPE_OPERATOR: {
+			//hell breaks loose
+
+			const GDParser::OperatorNode *on = static_cast<const GDParser::OperatorNode*>(p_expression);
+			switch(on->op) {
+
+
+				//call/constructor operator
+				case GDParser::OperatorNode::OP_PARENT_CALL: {
+
+
+					ERR_FAIL_COND_V(on->arguments.size()<1,-1);
+
+					const GDParser::IdentifierNode *in = (const GDParser::IdentifierNode *)on->arguments[0];
+
+
+					Vector<int> arguments;
+					int slevel = p_stack_level;
+					for(int i=1;i<on->arguments.size();i++) {
+
+						int ret = _parse_expression(codegen,on->arguments[i],slevel);
+						if (ret<0)
+							return ret;
+						if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+						arguments.push_back(ret);
+					}
+
+					//push call bytecode
+					codegen.opcodes.push_back(GDFunction::OPCODE_CALL_SELF_BASE); // basic type constructor
+
+					codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance
+					codegen.opcodes.push_back(arguments.size()); //argument count
+					codegen.alloc_call(arguments.size());
+					for(int i=0;i<arguments.size();i++)
+						codegen.opcodes.push_back(arguments[i]); //arguments
+
+				} break;
+				case GDParser::OperatorNode::OP_CALL: {
+
+					if (on->arguments[0]->type==GDParser::Node::TYPE_TYPE) {
+						//construct a basic type
+						ERR_FAIL_COND_V(on->arguments.size()<1,-1);
+
+						const GDParser::TypeNode *tn = (const GDParser::TypeNode *)on->arguments[0];
+						int vtype = tn->vtype;
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+						for(int i=1;i<on->arguments.size();i++) {
+
+							int ret = _parse_expression(codegen,on->arguments[i],slevel);
+							if (ret<0)
+								return ret;
+							if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+							arguments.push_back(ret);
+						}
+
+						//push call bytecode
+						codegen.opcodes.push_back(GDFunction::OPCODE_CONSTRUCT); // basic type constructor
+						codegen.opcodes.push_back(vtype); //instance
+						codegen.opcodes.push_back(arguments.size()); //argument count
+						codegen.alloc_call(arguments.size());
+						for(int i=0;i<arguments.size();i++)
+							codegen.opcodes.push_back(arguments[i]); //arguments
+
+					} else if (on->arguments[0]->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
+						//built in function
+
+						ERR_FAIL_COND_V(on->arguments.size()<1,-1);
+
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+						for(int i=1;i<on->arguments.size();i++) {
+
+							int ret = _parse_expression(codegen,on->arguments[i],slevel);
+							if (ret<0)
+								return ret;
+
+							if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+
+							arguments.push_back(ret);
+						}
+
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_CALL_BUILT_IN);
+						codegen.opcodes.push_back(static_cast<const GDParser::BuiltInFunctionNode*>(on->arguments[0])->function);
+						codegen.opcodes.push_back(on->arguments.size()-1);
+						codegen.alloc_call(on->arguments.size()-1);
+						for(int i=0;i<arguments.size();i++)
+							codegen.opcodes.push_back(arguments[i]);
+
+					} else {
+						//regular function
+						ERR_FAIL_COND_V(on->arguments.size()<2,-1);
+
+						const GDParser::Node *instance = on->arguments[0];
+
+						if (instance->type==GDParser::Node::TYPE_SELF) {
+							//room for optimization
+
+						}
+
+
+						Vector<int> arguments;
+						int slevel = p_stack_level;
+
+						for(int i=0;i<on->arguments.size();i++) {
+
+							int ret;
+
+							if (i==1) {
+
+								if (on->arguments[i]->type!=GDParser::Node::TYPE_IDENTIFIER) {
+									_set_error("Attempt to call a non-identifier.",on);
+									return -1;
+								}
+								GDParser::IdentifierNode *id = static_cast<GDParser::IdentifierNode*>(on->arguments[i]);
+								ret=codegen.get_name_map_pos(id->name);
+
+							} else {
+								ret = _parse_expression(codegen,on->arguments[i],slevel);
+								if (ret<0)
+									return ret;
+								if (ret&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+									slevel++;
+									codegen.alloc_stack(slevel);
+								}
+							}
+							arguments.push_back(ret);
+
+						}
+
+						codegen.opcodes.push_back(p_root?GDFunction::OPCODE_CALL:GDFunction::OPCODE_CALL_RETURN); // perform operator
+						codegen.opcodes.push_back(on->arguments.size()-2);
+						codegen.alloc_call(on->arguments.size()-2);
+						for(int i=0;i<arguments.size();i++)
+							codegen.opcodes.push_back(arguments[i]);
+					}
+				} break;
+				//indexing operator
+				case GDParser::OperatorNode::OP_INDEX:
+				case GDParser::OperatorNode::OP_INDEX_NAMED: {
+
+					ERR_FAIL_COND_V(on->arguments.size()!=2,-1);
+
+					int slevel = p_stack_level;
+					bool named=(on->op==GDParser::OperatorNode::OP_INDEX_NAMED);
+
+					int from = _parse_expression(codegen,on->arguments[0],slevel);
+					if (from<0)
+						return from;
+
+					int index;
+					if (named) {
+
+						index=codegen.get_name_map_pos(static_cast<GDParser::IdentifierNode*>(on->arguments[1])->name);
+
+					} else {
+
+						if (on->arguments[1]->type==GDParser::Node::TYPE_CONSTANT && static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value.get_type()==Variant::STRING) {
+							//also, somehow, named (speed up anyway)
+							StringName name = static_cast<const GDParser::ConstantNode*>(on->arguments[1])->value;
+							index=codegen.get_name_map_pos(name);
+							named=true;
+
+						} else {
+							//regular indexing
+							if (from&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+								slevel++;
+								codegen.alloc_stack(slevel);
+							}
+
+							index = _parse_expression(codegen,on->arguments[1],slevel);
+							if (index<0)
+								return index;
+						}
+					}
+
+					codegen.opcodes.push_back(named?GDFunction::OPCODE_GET_NAMED:GDFunction::OPCODE_GET); // perform operator
+					codegen.opcodes.push_back(from); // argument 1
+					codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter)
+
+				} break;
+				case GDParser::OperatorNode::OP_AND: {
+
+					// AND operator with early out on failure
+
+					int res = _parse_expression(codegen,on->arguments[0],p_stack_level);
+					if (res<0)
+						return res;
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(res);
+					int jump_fail_pos=codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					res = _parse_expression(codegen,on->arguments[1],p_stack_level);
+					if (res<0)
+						return res;
+
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(res);
+					int jump_fail_pos2=codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					codegen.alloc_stack(p_stack_level); //it will be used..
+					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(codegen.opcodes.size()+3);
+					codegen.opcodes[jump_fail_pos]=codegen.opcodes.size();
+					codegen.opcodes[jump_fail_pos2]=codegen.opcodes.size();
+					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS;
+
+				} break;
+				case GDParser::OperatorNode::OP_OR: {
+
+					// OR operator with early out on success
+
+					int res = _parse_expression(codegen,on->arguments[0],p_stack_level);
+					if (res<0)
+						return res;
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(res);
+					int jump_success_pos=codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					res = _parse_expression(codegen,on->arguments[1],p_stack_level);
+					if (res<0)
+						return res;
+
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(res);
+					int jump_success_pos2=codegen.opcodes.size();
+					codegen.opcodes.push_back(0);
+
+					codegen.alloc_stack(p_stack_level); //it will be used..
+					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(codegen.opcodes.size()+3);
+					codegen.opcodes[jump_success_pos]=codegen.opcodes.size();
+					codegen.opcodes[jump_success_pos2]=codegen.opcodes.size();
+					codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+					return p_stack_level|GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS;
+
+				} break;
+				//unary operators
+				case GDParser::OperatorNode::OP_NEG: { if (!_create_unary_operator(codegen,on,Variant::OP_NEGATE,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_NOT: { if (!_create_unary_operator(codegen,on,Variant::OP_NOT,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_BIT_INVERT: { if (!_create_unary_operator(codegen,on,Variant::OP_BIT_NEGATE,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_PREINC: { } break; //?
+				case GDParser::OperatorNode::OP_PREDEC: { } break;
+				case GDParser::OperatorNode::OP_INC: { } break;
+				case GDParser::OperatorNode::OP_DEC: { } break;
+				//binary operators (in precedence order)
+				case GDParser::OperatorNode::OP_IN: { if (!_create_binary_operator(codegen,on,Variant::OP_IN,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_EQUAL,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_NOT_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_NOT_EQUAL,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_LESS: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_LESS_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_LESS_EQUAL,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_GREATER: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_GREATER_EQUAL: { if (!_create_binary_operator(codegen,on,Variant::OP_GREATER_EQUAL,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_ADD: { if (!_create_binary_operator(codegen,on,Variant::OP_ADD,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_SUB: { if (!_create_binary_operator(codegen,on,Variant::OP_SUBSTRACT,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_MUL: { if (!_create_binary_operator(codegen,on,Variant::OP_MULTIPLY,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_DIV: { if (!_create_binary_operator(codegen,on,Variant::OP_DIVIDE,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_MOD: { if (!_create_binary_operator(codegen,on,Variant::OP_MODULE,p_stack_level)) return -1;} break;
+				//case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
+				//case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_BIT_AND: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_AND,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_BIT_OR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_OR,p_stack_level)) return -1;} break;
+				case GDParser::OperatorNode::OP_BIT_XOR: { if (!_create_binary_operator(codegen,on,Variant::OP_BIT_XOR,p_stack_level)) return -1;} break;
+                //shift
+                case GDParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
+                case GDParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
+				//assignment operators
+				case GDParser::OperatorNode::OP_ASSIGN_ADD:
+				case GDParser::OperatorNode::OP_ASSIGN_SUB:
+				case GDParser::OperatorNode::OP_ASSIGN_MUL:
+				case GDParser::OperatorNode::OP_ASSIGN_DIV:
+				case GDParser::OperatorNode::OP_ASSIGN_MOD:
+				case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+				case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+				case GDParser::OperatorNode::OP_ASSIGN_BIT_AND:
+				case GDParser::OperatorNode::OP_ASSIGN_BIT_OR:
+				case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR:
+				case GDParser::OperatorNode::OP_ASSIGN: {
+
+					ERR_FAIL_COND_V(on->arguments.size()!=2,-1);
+
+
+					if (on->arguments[0]->type==GDParser::Node::TYPE_OPERATOR && (static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX || static_cast<GDParser::OperatorNode*>(on->arguments[0])->op==GDParser::OperatorNode::OP_INDEX_NAMED)) {
+						//SET (chained) MODE!!
+
+						int slevel=p_stack_level;
+
+						GDParser::OperatorNode* op = static_cast<GDParser::OperatorNode*>(on->arguments[0]);
+
+						/* Find chain of sets */
+
+						List<GDParser::OperatorNode*> chain;
+
+						{
+							//create get/set chain
+							GDParser::OperatorNode* n=op;
+							while(true) {
+
+								chain.push_back(n);
+								if (n->arguments[0]->type!=GDParser::Node::TYPE_OPERATOR)
+									break;
+								n = static_cast<GDParser::OperatorNode*>(n->arguments[0]);
+								if (n->op!=GDParser::OperatorNode::OP_INDEX && n->op!=GDParser::OperatorNode::OP_INDEX_NAMED)
+									break;
+							}
+						}
+
+						/* Chain of gets */
+
+						//get at (potential) root stack pos, so it can be returned
+						int prev_pos = _parse_expression(codegen,chain.back()->get()->arguments[0],slevel);
+						if (prev_pos<0)
+							return prev_pos;
+						int retval=prev_pos;
+
+						if (retval&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+
+						Vector<int> setchain;
+
+						for(List<GDParser::OperatorNode*>::Element *E=chain.back();E;E=E->prev()) {
+
+
+							if (E==chain.front()) //ignore first
+								break;
+
+							bool named = E->get()->op==GDParser::OperatorNode::OP_INDEX_NAMED;
+							int key_idx;
+
+							if (named) {
+
+								key_idx = codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(E->get()->arguments[1])->name);
+							} else {
+
+								GDParser::Node *key = E->get()->arguments[1];
+								key_idx = _parse_expression(codegen,key,slevel);
+								if (retval&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+									slevel++;
+									codegen.alloc_stack(slevel);
+								}
+
+							}
+
+							if (key_idx<0)
+								return key_idx;
+
+							codegen.opcodes.push_back(named ? GDFunction::OPCODE_GET_NAMED : GDFunction::OPCODE_GET);
+							codegen.opcodes.push_back(prev_pos);
+							codegen.opcodes.push_back(key_idx);
+							slevel++;
+							codegen.alloc_stack(slevel);
+							int dst_pos = (GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|slevel;
+							codegen.opcodes.push_back(dst_pos);
+
+							//add in reverse order, since it will be reverted
+							setchain.push_back(dst_pos);
+							setchain.push_back(key_idx);
+							setchain.push_back(prev_pos);
+							setchain.push_back(named ? GDFunction::OPCODE_SET_NAMED : GDFunction::OPCODE_SET);
+
+							prev_pos=dst_pos;
+
+						}
+
+						setchain.invert();
+
+
+						int set_index;
+						bool named=false;
+
+
+						if (static_cast<const GDParser::OperatorNode*>(op)->op==GDParser::OperatorNode::OP_INDEX_NAMED) {
+
+
+							set_index=codegen.get_name_map_pos(static_cast<const GDParser::IdentifierNode*>(op->arguments[1])->name);
+							named=true;
+						} else {
+
+							set_index = _parse_expression(codegen,op->arguments[1],slevel+1);
+							named=false;
+						}
+
+
+						if (set_index<0)
+							return set_index;
+
+						if (set_index&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+
+						int set_value = _parse_assign_right_expression(codegen,on,slevel+1);
+						if (set_value<0)
+							return set_value;
+
+						codegen.opcodes.push_back(named?GDFunction::OPCODE_SET_NAMED:GDFunction::OPCODE_SET);
+						codegen.opcodes.push_back(prev_pos);
+						codegen.opcodes.push_back(set_index);
+						codegen.opcodes.push_back(set_value);
+
+						for(int i=0;i<setchain.size();i+=4) {
+
+
+							codegen.opcodes.push_back(setchain[i+0]);
+							codegen.opcodes.push_back(setchain[i+1]);
+							codegen.opcodes.push_back(setchain[i+2]);
+							codegen.opcodes.push_back(setchain[i+3]);
+						}
+
+						return retval;
+
+
+					} else {
+						//ASSIGNMENT MODE!!
+
+						int slevel = p_stack_level;
+
+						int dst_address_a = _parse_expression(codegen,on->arguments[0],slevel);
+						if (dst_address_a<0)
+							return -1;
+
+						if (dst_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS) {
+							slevel++;
+							codegen.alloc_stack(slevel);
+						}
+
+						int src_address_b = _parse_assign_right_expression(codegen,on,slevel);
+						if (src_address_b<0)
+							return -1;
+
+
+
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN); // perform operator
+						codegen.opcodes.push_back(dst_address_a); // argument 1
+						codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+						return dst_address_a; //if anything, returns wathever was assigned or correct stack position
+
+					}
+
+
+				} break;
+				case GDParser::OperatorNode::OP_EXTENDS: {
+
+					ERR_FAIL_COND_V(on->arguments.size()!=2,false);
+
+
+					int slevel = p_stack_level;
+
+					int src_address_a = _parse_expression(codegen,on->arguments[0],slevel);
+					if (src_address_a<0)
+						return -1;
+
+					if (src_address_a&GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)
+						slevel++; //uses stack for return, increase stack
+
+					int src_address_b = _parse_expression(codegen,on->arguments[1],slevel);
+					if (src_address_b<0)
+						return -1;
+
+					codegen.opcodes.push_back(GDFunction::OPCODE_EXTENDS_TEST); // perform operator
+					codegen.opcodes.push_back(src_address_a); // argument 1
+					codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
+
+				} break;
+				default: {
+
+
+					ERR_EXPLAIN("Bug in bytecode compiler, unexpected operator #"+itos(on->op)+" in parse tree while parsing expression.");
+					ERR_FAIL_V(0); //unreachable code
+
+				} break;
+			}
+
+			int dst_addr=(p_stack_level)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
+			codegen.alloc_stack(p_stack_level);
+			return dst_addr;
+		} break;
+		//TYPE_TYPE,
+		default: {
+
+			ERR_EXPLAIN("Bug in bytecode compiler, unexpected node in parse tree while parsing expression.");
+			ERR_FAIL_V(-1); //unreachable code
+		} break;
+
+
+	}
+
+	ERR_FAIL_V(-1); //unreachable code
+}
+
+
+Error GDCompiler::_parse_block(CodeGen& codegen,const GDParser::BlockNode *p_block,int p_stack_level,int p_break_addr,int p_continue_addr) {
+
+	codegen.push_stack_identifiers();
+	int new_identifiers=0;
+	codegen.current_line=p_block->line;
+
+	for(int i=0;i<p_block->statements.size();i++) {
+
+		const GDParser::Node *s = p_block->statements[i];
+
+
+		switch(s->type) {
+			case GDParser::Node::TYPE_NEWLINE: {
+
+				const GDParser::NewLineNode *nl = static_cast<const GDParser::NewLineNode*>(s);
+				codegen.opcodes.push_back(GDFunction::OPCODE_LINE);
+				codegen.opcodes.push_back(nl->line);
+				codegen.current_line=nl->line;
+
+			} break;
+			case GDParser::Node::TYPE_CONTROL_FLOW: {
+				// try subblocks
+
+				const GDParser::ControlFlowNode *cf = static_cast<const GDParser::ControlFlowNode*>(s);
+
+				switch(cf->cf_type) {
+
+
+					case GDParser::ControlFlowNode::CF_IF: {
+
+#ifdef DEBUG_ENABLED
+						codegen.opcodes.push_back(GDFunction::OPCODE_LINE);
+						codegen.opcodes.push_back(cf->line);
+						codegen.current_line=cf->line;
+#endif
+						int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
+						if (ret<0)
+							return ERR_PARSE_ERROR;
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(ret);
+						int else_addr=codegen.opcodes.size();
+						codegen.opcodes.push_back(0); //temporary
+
+						Error err = _parse_block(codegen,cf->body,p_stack_level,p_break_addr,p_continue_addr);
+						if (err)
+							return err;
+
+						if (cf->body_else) {
+
+							codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+							int end_addr=codegen.opcodes.size();
+							codegen.opcodes.push_back(0);
+							codegen.opcodes[else_addr]=codegen.opcodes.size();
+
+							Error err = _parse_block(codegen,cf->body_else,p_stack_level,p_break_addr,p_continue_addr);
+							if (err)
+								return err;
+
+							codegen.opcodes[end_addr]=codegen.opcodes.size();
+						} else {
+							//end without else
+							codegen.opcodes[else_addr]=codegen.opcodes.size();
+
+						}
+
+					} break;
+					case GDParser::ControlFlowNode::CF_FOR: {
+
+
+
+						int slevel=p_stack_level;
+						int iter_stack_pos=slevel;
+						int iterator_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+						int counter_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+						int container_pos = (slevel++)|(GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS);
+						codegen.alloc_stack(slevel);
+
+						    codegen.push_stack_identifiers();
+						      codegen.add_stack_identifier(static_cast<const GDParser::IdentifierNode*>(cf->arguments[0])->name,iter_stack_pos);
+
+						int ret = _parse_expression(codegen,cf->arguments[1],slevel,false);
+						if (ret<0)
+							return ERR_COMPILATION_FAILED;
+
+						//assign container
+						codegen.opcodes.push_back(GDFunction::OPCODE_ASSIGN);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(ret);
+
+						//begin loop
+						codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE_BEGIN);
+						codegen.opcodes.push_back(counter_pos);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(codegen.opcodes.size()+4);
+						codegen.opcodes.push_back(iterator_pos);
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(codegen.opcodes.size()+8);
+						//break loop
+						int break_pos=codegen.opcodes.size();
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(0); //skip code for next
+						//next loop
+						int continue_pos=codegen.opcodes.size();
+						codegen.opcodes.push_back(GDFunction::OPCODE_ITERATE);
+						codegen.opcodes.push_back(counter_pos);
+						codegen.opcodes.push_back(container_pos);
+						codegen.opcodes.push_back(break_pos);
+						codegen.opcodes.push_back(iterator_pos);
+
+
+						Error err = _parse_block(codegen,cf->body,slevel,break_pos,continue_pos);
+						if (err)
+							return err;
+
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(continue_pos);
+						codegen.opcodes[break_pos+1]=codegen.opcodes.size();
+
+
+						codegen.pop_stack_identifiers();
+
+					} break;
+					case GDParser::ControlFlowNode::CF_WHILE: {
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(codegen.opcodes.size()+3);
+						int break_addr=codegen.opcodes.size();
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(0);
+						int continue_addr=codegen.opcodes.size();
+
+						int ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
+						if (ret<0)
+							return ERR_PARSE_ERROR;
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(ret);
+						codegen.opcodes.push_back(break_addr);
+						Error err = _parse_block(codegen,cf->body,p_stack_level,break_addr,continue_addr);
+						if (err)
+							return err;
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(continue_addr);
+
+						codegen.opcodes[break_addr+1]=codegen.opcodes.size();
+
+					} break;
+					case GDParser::ControlFlowNode::CF_SWITCH: {
+
+					} break;
+					case GDParser::ControlFlowNode::CF_BREAK: {
+
+						if (p_break_addr<0) {
+
+							_set_error("'break'' not within loop",cf);
+							return ERR_COMPILATION_FAILED;
+						}
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(p_break_addr);
+
+					} break;
+					case GDParser::ControlFlowNode::CF_CONTINUE: {
+
+						if (p_continue_addr<0) {
+
+							_set_error("'continue' not within loop",cf);
+							return ERR_COMPILATION_FAILED;
+						}
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(p_continue_addr);
+
+					} break;
+					case GDParser::ControlFlowNode::CF_RETURN: {
+
+						int ret;
+
+						if (cf->arguments.size()) {
+
+							ret = _parse_expression(codegen,cf->arguments[0],p_stack_level,false);
+							if (ret<0)
+								return ERR_PARSE_ERROR;
+
+						} else {
+
+							ret=GDFunction::ADDR_TYPE_NIL << GDFunction::ADDR_BITS;
+						}
+
+						codegen.opcodes.push_back(GDFunction::OPCODE_RETURN);
+						codegen.opcodes.push_back(ret);
+
+					} break;
+
+				}
+			} break;
+			case GDParser::Node::TYPE_ASSERT: {
+				// try subblocks
+
+				const GDParser::AssertNode *as = static_cast<const GDParser::AssertNode*>(s);
+
+				int ret = _parse_expression(codegen,as->condition,p_stack_level,false);
+				if (ret<0)
+					return ERR_PARSE_ERROR;
+
+				codegen.opcodes.push_back(GDFunction::OPCODE_ASSERT);
+				codegen.opcodes.push_back(ret);
+			} break;
+			case GDParser::Node::TYPE_LOCAL_VAR: {
+
+
+				const GDParser::LocalVarNode *lv = static_cast<const GDParser::LocalVarNode*>(s);
+
+				codegen.add_stack_identifier(lv->name,p_stack_level++);
+				codegen.alloc_stack(p_stack_level);
+				new_identifiers++;
+
+			} break;
+			default: {
+				//expression
+				int ret = _parse_expression(codegen,s,p_stack_level,true);
+				if (ret<0)
+					return ERR_PARSE_ERROR;
+			} break;
+
+		}
+
+	}
+	codegen.pop_stack_identifiers();
+	return OK;
+}
+
+
+Error GDCompiler::_parse_function(GDScript *p_script,const GDParser::ClassNode *p_class,const GDParser::FunctionNode *p_func) {
+
+	Vector<int> bytecode;
+	CodeGen codegen;
+
+	codegen.class_node=p_class;
+	codegen.script=p_script;
+	codegen.function_node=p_func;
+	codegen.stack_max=0;
+	codegen.current_line=0;
+	codegen.call_max=0;
+	codegen.debug_stack=ScriptDebugger::get_singleton()!=NULL;
+
+	int stack_level=0;
+
+	if (p_func) {
+		for(int i=0;i<p_func->arguments.size();i++) {
+			int idx = i;
+			codegen.add_stack_identifier(p_func->arguments[i],i);
+		}
+		stack_level=p_func->arguments.size();
+	}
+
+	codegen.alloc_stack(stack_level);
+
+	/* Parse initializer -if applies- */
+
+	bool is_initializer=false || !p_func;
+
+	if (!p_func || String(p_func->name)=="_init") {
+		//parse initializer for class members
+		if (!p_func && p_class->extends_used && p_script->native.is_null()){
+
+			//call implicit parent constructor
+			codegen.opcodes.push_back(GDFunction::OPCODE_CALL_SELF_BASE);
+			codegen.opcodes.push_back(codegen.get_name_map_pos("_init"));
+			codegen.opcodes.push_back(0);
+			codegen.opcodes.push_back((GDFunction::ADDR_TYPE_STACK<<GDFunction::ADDR_BITS)|0);
+
+		}
+		Error err = _parse_block(codegen,p_class->initializer,stack_level);
+		if (err)
+			return err;
+		is_initializer=true;
+
+	}
+
+	/* Parse default argument code -if applies- */
+
+	Vector<int> defarg_addr;
+	StringName func_name;
+
+	if (p_func) {
+		if (p_func->default_values.size()) {
+
+			codegen.opcodes.push_back(GDFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
+			defarg_addr.push_back(codegen.opcodes.size());
+			for(int i=0;i<p_func->default_values.size();i++) {
+
+				_parse_expression(codegen,p_func->default_values[i],stack_level,true);
+				defarg_addr.push_back(codegen.opcodes.size());
+			}
+
+
+			defarg_addr.invert();
+		}
+
+
+
+		Error err = _parse_block(codegen,p_func->body,stack_level);
+		if (err)
+			return err;
+
+		func_name=p_func->name;
+	} else {
+		func_name="_init";
+	}
+
+	codegen.opcodes.push_back(GDFunction::OPCODE_END);
+
+	GDFunction *gdfunc=NULL;
+
+	//if (String(p_func->name)=="") { //initializer func
+	//	gdfunc = &p_script->initializer;
+
+	//} else { //regular func
+		p_script->member_functions[func_name]=GDFunction();
+		gdfunc = &p_script->member_functions[func_name];
+	//}
+
+	if (p_func)
+		gdfunc->_static=p_func->_static;
+
+	//constants
+	if (codegen.constant_map.size()) {
+		gdfunc->_constant_count=codegen.constant_map.size();
+		gdfunc->constants.resize(codegen.constant_map.size());
+		gdfunc->_constants_ptr=&gdfunc->constants[0];
+		const Variant *K=NULL;
+		while((K=codegen.constant_map.next(K))) {
+			int idx = codegen.constant_map[*K];
+			gdfunc->constants[idx]=*K;
+		}
+	} else {
+
+		gdfunc->_constants_ptr=NULL;
+		gdfunc->_constant_count=0;
+	}
+	//global names
+	if (codegen.name_map.size()) {
+
+		gdfunc->global_names.resize(codegen.name_map.size());
+		gdfunc->_global_names_ptr = &gdfunc->global_names[0];
+		for(Map<StringName,int>::Element *E=codegen.name_map.front();E;E=E->next()) {
+
+			gdfunc->global_names[E->get()]=E->key();
+		}
+		gdfunc->_global_names_count=gdfunc->global_names.size();
+
+	} else {
+		gdfunc->_global_names_ptr = NULL;
+		gdfunc->_global_names_count =0;
+	}
+
+
+	if (codegen.opcodes.size()) {
+
+		gdfunc->code=codegen.opcodes;
+		gdfunc->_code_ptr=&gdfunc->code[0];
+		gdfunc->_code_size=codegen.opcodes.size();
+
+	} else {
+
+		gdfunc->_code_ptr=NULL;
+		gdfunc->_code_size=0;
+	}
+
+	if (defarg_addr.size()) {
+
+		gdfunc->default_arguments=defarg_addr;
+		gdfunc->_default_arg_count=defarg_addr.size();
+		gdfunc->_default_arg_ptr=&gdfunc->default_arguments[0];
+	} else {
+		gdfunc->_default_arg_count=0;
+		gdfunc->_default_arg_ptr=NULL;
+	}
+
+	gdfunc->_argument_count=p_func ? p_func->arguments.size() : 0;
+	gdfunc->_stack_size=codegen.stack_max;
+	gdfunc->_call_size=codegen.call_max;
+	gdfunc->name=func_name;
+	gdfunc->_script=p_script;
+	gdfunc->source=source;
+	if (p_func) {
+		gdfunc->_initial_line=p_func->line;
+	} else {
+		gdfunc->_initial_line=0;
+	}
+
+	if (codegen.debug_stack)
+		gdfunc->stack_debug=codegen.stack_debug;
+
+	if (is_initializer)
+		p_script->initializer=gdfunc;
+
+
+	return OK;
+}
+
+
+
+Error GDCompiler::_parse_class(GDScript *p_script,GDScript *p_owner,const GDParser::ClassNode *p_class) {
+
+
+	p_script->native=Ref<GDNativeClass>();
+	p_script->base=Ref<GDScript>();
+	p_script->_base=NULL;
+	p_script->members.clear();
+	p_script->constants.clear();
+	p_script->member_functions.clear();
+	p_script->member_indices.clear();
+	p_script->member_info.clear();
+	p_script->initializer=NULL;
+	p_script->subclasses.clear();
+	p_script->_owner=p_owner;
+	p_script->tool=p_class->tool;
+	p_script->name=p_class->name;
+
+
+	int index_from=0;
+
+	if (p_class->extends_used) {
+		//do inheritance
+		String path = p_class->extends_file;
+
+		Ref<GDScript> script;
+		Ref<GDNativeClass> native;
+
+		if (path!="") {
+			//path (and optionally subclasses)
+
+			script = ResourceLoader::load(path);
+			if (script.is_null()) {
+				_set_error("Could not load base class: "+path,p_class);
+				return ERR_FILE_NOT_FOUND;
+			}
+
+			if (p_class->extends_class.size()) {
+
+				for(int i=0;i<p_class->extends_class.size();i++) {
+
+					String sub = p_class->extends_class[i];
+					if (script->subclasses.has(sub)) {
+
+						script=script->subclasses[sub];
+					} else {
+
+						_set_error("Could not find subclass: "+sub,p_class);
+						return ERR_FILE_NOT_FOUND;
+					}
+				}
+			}
+
+		} else {
+
+			ERR_FAIL_COND_V(p_class->extends_class.size()==0,ERR_BUG);
+			//look around for the subclasses
+
+			String base=p_class->extends_class[0];
+			GDScript *p = p_owner;
+			Ref<GDScript> base_class;
+
+			while(p) {
+
+				if (p->subclasses.has(base)) {
+
+					base_class=p->subclasses[base];
+					break;
+				}
+				p=p->_owner;
+			}
+
+			if (base_class.is_valid()) {
+
+				for(int i=1;i<p_class->extends_class.size();i++) {
+
+					String subclass=p_class->extends_class[i];
+
+					if (base_class->subclasses.has(subclass)) {
+
+						base_class=base_class->subclasses[subclass];
+					} else {
+
+						_set_error("Could not find subclass: "+subclass,p_class);
+						return ERR_FILE_NOT_FOUND;
+					}
+				}
+
+				script=base_class;
+
+
+			} else {
+
+				if (p_class->extends_class.size()>1) {
+
+					_set_error("Invalid inheritance (unknown class+subclasses)",p_class);
+					return ERR_FILE_NOT_FOUND;
+
+				}
+				//if not found, try engine classes
+				if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
+
+					_set_error("Unknown class: '"+base+"'",p_class);
+					return ERR_FILE_NOT_FOUND;
+				}
+
+				int base_idx = GDScriptLanguage::get_singleton()->get_global_map()[base];
+				native = GDScriptLanguage::get_singleton()->get_global_array()[base_idx];
+				if (!native.is_valid()) {
+
+					_set_error("Global not a class: '"+base+"'",p_class);
+
+					return ERR_FILE_NOT_FOUND;
+				}
+			}
+
+
+		}
+
+		if (script.is_valid()) {
+
+			p_script->base=script;
+			p_script->_base=p_script->base.ptr();
+			p_script->member_indices=script->member_indices;
+
+		} else if (native.is_valid()) {
+
+			p_script->native=native;
+		} else {
+
+			_set_error("Could not determine inheritance",p_class);
+			return ERR_FILE_NOT_FOUND;
+		}
+
+
+	}
+
+
+	for(int i=0;i<p_class->variables.size();i++) {
+
+		StringName name = p_class->variables[i].identifier;
+		if (p_script->member_indices.has(name)) {
+			_set_error("Member '"+name+"' already exists (in current or parent class)",p_class);
+			return ERR_ALREADY_EXISTS;
+		}
+
+		if (p_class->variables[i]._export.type!=Variant::NIL) {
+
+			p_script->member_info[name]=p_class->variables[i]._export;
+#ifdef TOOLS_ENABLED
+			if (p_class->variables[i].default_value.get_type()!=Variant::NIL) {
+
+				p_script->member_default_values[name]=p_class->variables[i].default_value;
+			}
+#endif
+		}
+
+		int new_idx = p_script->member_indices.size();
+		p_script->member_indices[name]=new_idx;
+		p_script->members.insert(name);
+
+	}
+
+	for(int i=0;i<p_class->constant_expressions.size();i++) {
+
+		StringName name = p_class->constant_expressions[i].identifier;
+		ERR_CONTINUE( p_class->constant_expressions[i].expression->type!=GDParser::Node::TYPE_CONSTANT );
+
+		GDParser::ConstantNode *constant = static_cast<GDParser::ConstantNode*>(p_class->constant_expressions[i].expression);
+
+		p_script->constants.insert(name,constant->value);
+		//p_script->constants[constant->value].make_const();
+	}
+
+
+	//parse sub-classes
+
+	for(int i=0;i<p_class->subclasses.size();i++) {
+		StringName name = p_class->subclasses[i]->name;
+
+		Ref<GDScript> subclass = memnew( GDScript );
+
+		Error err = _parse_class(subclass.ptr(),p_script,p_class->subclasses[i]);
+		if (err)
+			return err;
+		p_script->subclasses.insert(name,subclass);
+
+	}
+
+
+	//parse methods
+
+	bool has_initializer=false;
+	for(int i=0;i<p_class->functions.size();i++) {
+
+		if (!has_initializer && p_class->functions[i]->name=="_init")
+			has_initializer=true;
+		Error err = _parse_function(p_script,p_class,p_class->functions[i]);
+		if (err)
+			return err;
+	}
+
+	//parse static methods
+
+	for(int i=0;i<p_class->static_functions.size();i++) {
+
+		Error err = _parse_function(p_script,p_class,p_class->static_functions[i]);
+		if (err)
+			return err;
+	}
+
+
+	if (!has_initializer) {
+		//create a constructor
+		Error err = _parse_function(p_script,p_class,NULL);
+		if (err)
+			return err;
+	}
+
+	return OK;
+}
+
+Error GDCompiler::compile(const GDParser *p_parser,GDScript *p_script) {
+
+	err_line=-1;
+	err_column=-1;
+	error="";
+	parser=p_parser;
+	const GDParser::Node* root = parser->get_parse_tree();
+	ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,ERR_INVALID_DATA);
+
+	source=p_script->get_path();
+
+
+
+	Error err = _parse_class(p_script,NULL,static_cast<const GDParser::ClassNode*>(root));
+
+	if (err)
+		return err;
+
+	return OK;
+
+}
+
+String GDCompiler::get_error() const {
+
+	return error;
+}
+int GDCompiler::get_error_line() const{
+
+	return err_line;
+}
+int GDCompiler::get_error_column() const{
+
+	return err_column;
+}
+
+GDCompiler::GDCompiler()
+{
+}
+
+