/*************************************************************************/
/* test_gdscript.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2016 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 "test_gdscript.h"
#include "os/main_loop.h"
#include "os/os.h"
#include "os/file_access.h"
#ifdef GDSCRIPT_ENABLED
#include "modules/gdscript/gd_tokenizer.h"
#include "modules/gdscript/gd_parser.h"
#include "modules/gdscript/gd_compiler.h"
#include "modules/gdscript/gd_script.h"
namespace TestGDScript {
static void _print_indent(int p_ident,const String& p_text) {
String txt;
for(int i=0;i<p_ident;i++) {
txt+='\t';
}
print_line(txt+p_text);
}
static String _parser_extends(const GDParser::ClassNode *p_class) {
String txt="extends ";
if (String(p_class->extends_file)!="") {
txt+="\""+p_class->extends_file+"\"";
if (p_class->extends_class.size())
txt+=".";
}
for(int i=0;i<p_class->extends_class.size();i++) {
if (i!=0)
txt+=".";
txt+=p_class->extends_class[i];
}
return txt;
}
static String _parser_expr(const GDParser::Node *p_expr) {
String txt;
switch(p_expr->type) {
case GDParser::Node::TYPE_IDENTIFIER: {
const GDParser::IdentifierNode *id_node = static_cast<const GDParser::IdentifierNode *>(p_expr);
txt=id_node->name;
} break;
case GDParser::Node::TYPE_CONSTANT: {
const GDParser::ConstantNode *c_node = static_cast<const GDParser::ConstantNode *>(p_expr);
if (c_node->value.get_type()==Variant::STRING)
txt="\""+String(c_node->value)+"\"";
else
txt=c_node->value;
} break;
case GDParser::Node::TYPE_SELF: {
txt="self";
} break;
case GDParser::Node::TYPE_ARRAY: {
const GDParser::ArrayNode *arr_node = static_cast<const GDParser::ArrayNode *>(p_expr);
txt+="[";
for(int i=0;i<arr_node->elements.size();i++) {
if (i>0)
txt+=", ";
txt+=_parser_expr(arr_node->elements[i]);
}
txt+="]";
} break;
case GDParser::Node::TYPE_DICTIONARY: {
const GDParser::DictionaryNode *dict_node = static_cast<const GDParser::DictionaryNode *>(p_expr);
txt+="{";
for(int i=0;i<dict_node->elements.size();i++) {
if (i>0)
txt+=", ";
const GDParser::DictionaryNode::Pair &p = dict_node->elements[i];
txt+=_parser_expr(p.key);
txt+=":";
txt+=_parser_expr(p.value);
}
txt+="}";
} break;
case GDParser::Node::TYPE_OPERATOR: {
const GDParser::OperatorNode *c_node = static_cast<const GDParser::OperatorNode *>(p_expr);
switch(c_node->op) {
case GDParser::OperatorNode::OP_PARENT_CALL:
txt+=".";
case GDParser::OperatorNode::OP_CALL: {
ERR_FAIL_COND_V(c_node->arguments.size()<1,"");
String func_name;
const GDParser::Node *nfunc = c_node->arguments[0];
int arg_ofs=0;
if (nfunc->type==GDParser::Node::TYPE_BUILT_IN_FUNCTION) {
const GDParser::BuiltInFunctionNode *bif_node = static_cast<const GDParser::BuiltInFunctionNode *>(nfunc);
func_name=GDFunctions::get_func_name(bif_node->function);
arg_ofs=1;
} else if (nfunc->type==GDParser::Node::TYPE_TYPE) {
const GDParser::TypeNode *t_node = static_cast<const GDParser::TypeNode *>(nfunc);
func_name=Variant::get_type_name(t_node->vtype);
arg_ofs=1;
} else {
ERR_FAIL_COND_V(c_node->arguments.size()<2,"");
nfunc = c_node->arguments[1];
ERR_FAIL_COND_V(nfunc->type!=GDParser::Node::TYPE_IDENTIFIER,"");
if (c_node->arguments[0]->type!=GDParser::Node::TYPE_SELF)
func_name=_parser_expr(c_node->arguments[0])+".";
func_name+=_parser_expr(nfunc);
arg_ofs=2;
}
txt+=func_name+"(";
for(int i=arg_ofs;i<c_node->arguments.size();i++) {
const GDParser::Node *arg=c_node->arguments[i];
if (i>arg_ofs)
txt+=", ";
txt+=_parser_expr(arg);
}
txt+=")";
} break;
case GDParser::OperatorNode::OP_INDEX: {
ERR_FAIL_COND_V(c_node->arguments.size()!=2,"");
//index with []
txt=_parser_expr(c_node->arguments[0])+"["+_parser_expr(c_node->arguments[1])+"]";
} break;
case GDParser::OperatorNode::OP_INDEX_NAMED: {
ERR_FAIL_COND_V(c_node->arguments.size()!=2,"");
txt=_parser_expr(c_node->arguments[0])+"."+_parser_expr(c_node->arguments[1]);
} break;
case GDParser::OperatorNode::OP_NEG: { txt="-"+_parser_expr(c_node->arguments[0]); } break;
case GDParser::OperatorNode::OP_NOT: { txt="not "+_parser_expr(c_node->arguments[0]); } break;
case GDParser::OperatorNode::OP_BIT_INVERT: { txt="~"+_parser_expr(c_node->arguments[0]); } 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;
case GDParser::OperatorNode::OP_IN: { txt=_parser_expr(c_node->arguments[0])+" in "+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_EQUAL: { txt=_parser_expr(c_node->arguments[0])+"=="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_NOT_EQUAL: { txt=_parser_expr(c_node->arguments[0])+"!="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_LESS: { txt=_parser_expr(c_node->arguments[0])+"<"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_LESS_EQUAL: { txt=_parser_expr(c_node->arguments[0])+"<="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_GREATER: { txt=_parser_expr(c_node->arguments[0])+">"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_GREATER_EQUAL: { txt=_parser_expr(c_node->arguments[0])+">="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_AND: { txt=_parser_expr(c_node->arguments[0])+" and "+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_OR: { txt=_parser_expr(c_node->arguments[0])+" or "+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ADD: { txt=_parser_expr(c_node->arguments[0])+"+"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_SUB: { txt=_parser_expr(c_node->arguments[0])+"-"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_MUL: { txt=_parser_expr(c_node->arguments[0])+"*"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_DIV: { txt=_parser_expr(c_node->arguments[0])+"/"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_MOD: { txt=_parser_expr(c_node->arguments[0])+"%"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_SHIFT_LEFT: { txt=_parser_expr(c_node->arguments[0])+"<<"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_SHIFT_RIGHT: { txt=_parser_expr(c_node->arguments[0])+">>"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN: { txt=_parser_expr(c_node->arguments[0])+"="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_ADD: { txt=_parser_expr(c_node->arguments[0])+"+="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_SUB: { txt=_parser_expr(c_node->arguments[0])+"-="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_MUL: { txt=_parser_expr(c_node->arguments[0])+"*="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_DIV: { txt=_parser_expr(c_node->arguments[0])+"/="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_MOD: { txt=_parser_expr(c_node->arguments[0])+"%="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:{ txt=_parser_expr(c_node->arguments[0])+"<<="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT: { txt=_parser_expr(c_node->arguments[0])+">>="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_BIT_AND: { txt=_parser_expr(c_node->arguments[0])+"&="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_BIT_OR: { txt=_parser_expr(c_node->arguments[0])+"|="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_ASSIGN_BIT_XOR: { txt=_parser_expr(c_node->arguments[0])+"^="+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_BIT_AND: { txt=_parser_expr(c_node->arguments[0])+"&"+_parser_expr(c_node->arguments[1]); } break;;
case GDParser::OperatorNode::OP_BIT_OR: { txt=_parser_expr(c_node->arguments[0])+"|"+_parser_expr(c_node->arguments[1]); } break;
case GDParser::OperatorNode::OP_BIT_XOR: { txt=_parser_expr(c_node->arguments[0])+"^"+_parser_expr(c_node->arguments[1]); } break;
}
} break;
case GDParser::Node::TYPE_NEWLINE: {
//skippie
} break;
default: {
String error="Parser bug at "+itos(p_expr->line)+", invalid expression type: "+itos(p_expr->type);
ERR_EXPLAIN(error);
ERR_FAIL_V("");
}
}
return txt;
//return "("+txt+")";
}
static void _parser_show_block(const GDParser::BlockNode *p_block,int p_indent) {
for(int i=0;i<p_block->statements.size();i++) {
const GDParser::Node *statement=p_block->statements[i];
switch(statement->type) {
case GDParser::Node::TYPE_CONTROL_FLOW: {
const GDParser::ControlFlowNode *cf_node = static_cast<const GDParser::ControlFlowNode *>(statement);
switch(cf_node->cf_type) {
case GDParser::ControlFlowNode::CF_IF: {
ERR_FAIL_COND(cf_node->arguments.size()!=1);
String txt;
txt+="if ";
txt+=_parser_expr(cf_node->arguments[0]);
txt+=":";
_print_indent(p_indent,txt);
ERR_FAIL_COND(!cf_node->body);
_parser_show_block(cf_node->body,p_indent+1);
if (cf_node->body_else) {
_print_indent(p_indent,"else:");
_parser_show_block(cf_node->body_else,p_indent+1);
}
} break;
case GDParser::ControlFlowNode::CF_FOR: {
ERR_FAIL_COND(cf_node->arguments.size()!=2);
String txt;
txt+="for ";
txt+=_parser_expr(cf_node->arguments[0]);
txt+=" in ";
txt+=_parser_expr(cf_node->arguments[1]);
txt+=":";
_print_indent(p_indent,txt);
ERR_FAIL_COND(!cf_node->body);
_parser_show_block(cf_node->body,p_indent+1);
} break;
case GDParser::ControlFlowNode::CF_WHILE: {
ERR_FAIL_COND(cf_node->arguments.size()!=1);
String txt;
txt+="while ";
txt+=_parser_expr(cf_node->arguments[0]);
txt+=":";
_print_indent(p_indent,txt);
ERR_FAIL_COND(!cf_node->body);
_parser_show_block(cf_node->body,p_indent+1);
} break;
case GDParser::ControlFlowNode::CF_SWITCH: {
} break;
case GDParser::ControlFlowNode::CF_CONTINUE: {
_print_indent(p_indent,"continue");
} break;
case GDParser::ControlFlowNode::CF_BREAK: {
_print_indent(p_indent,"break");
} break;
case GDParser::ControlFlowNode::CF_RETURN: {
if (cf_node->arguments.size())
_print_indent(p_indent,"return "+_parser_expr(cf_node->arguments[0]));
else
_print_indent(p_indent,"return ");
} break;
}
} break;
case GDParser::Node::TYPE_LOCAL_VAR: {
const GDParser::LocalVarNode *lv_node = static_cast<const GDParser::LocalVarNode *>(statement);
_print_indent(p_indent,"var "+String(lv_node->name));
} break;
default: {
//expression i guess
_print_indent(p_indent,_parser_expr(statement));
}
}
}
}
static void _parser_show_function(const GDParser::FunctionNode *p_func,int p_indent,GDParser::BlockNode *p_initializer=NULL) {
String txt;
if (p_func->_static)
txt="static ";
txt+="func ";
if (p_func->name=="") // initializer
txt+="[built-in-initializer]";
else
txt+=String(p_func->name);
txt+="(";
for(int i=0;i<p_func->arguments.size();i++) {
if (i!=0)
txt+=", ";
txt+="var "+String(p_func->arguments[i]);
if (i>=(p_func->arguments.size()-p_func->default_values.size())) {
int defarg = i - (p_func->arguments.size() - p_func->default_values.size());
txt+="=";
txt+=_parser_expr(p_func->default_values[defarg]);
}
}
txt+=")";
//todo constructor check!
txt+=":";
_print_indent(p_indent,txt);
if (p_initializer)
_parser_show_block(p_initializer,p_indent+1);
_parser_show_block(p_func->body,p_indent+1);
}
static void _parser_show_class(const GDParser::ClassNode *p_class,int p_indent,const Vector<String>& p_code) {
if (p_indent==0 && (String(p_class->extends_file)!="" || p_class->extends_class.size())) {
_print_indent(p_indent,_parser_extends(p_class));
print_line("\n");
}
for(int i=0;i<p_class->subclasses.size();i++) {
const GDParser::ClassNode *subclass=p_class->subclasses[i];
String line="class "+subclass->name;
if (String(subclass->extends_file)!="" || subclass->extends_class.size())
line+=" "+_parser_extends(subclass);
line+=":";
_print_indent(p_indent,line);
_parser_show_class(subclass,p_indent+1,p_code);
print_line("\n");
}
for(int i=0;i<p_class->constant_expressions.size();i++) {
const GDParser::ClassNode::Constant &constant=p_class->constant_expressions[i];
_print_indent(p_indent,"const "+String(constant.identifier)+"="+_parser_expr(constant.expression));
}
for(int i=0;i<p_class->variables.size();i++) {
const GDParser::ClassNode::Member &m=p_class->variables[i];
_print_indent(p_indent,"var "+String(m.identifier));
}
print_line("\n");
for(int i=0;i<p_class->static_functions.size();i++) {
_parser_show_function(p_class->static_functions[i],p_indent);
print_line("\n");
}
for(int i=0;i<p_class->functions.size();i++) {
if (String(p_class->functions[i]->name)=="_init") {
_parser_show_function(p_class->functions[i],p_indent,p_class->initializer);
} else
_parser_show_function(p_class->functions[i],p_indent);
print_line("\n");
}
//_parser_show_function(p_class->initializer,p_indent);
print_line("\n");
}
static String _disassemble_addr(const Ref<GDScript>& p_script,const GDFunction& func, int p_addr) {
int addr=p_addr&GDFunction::ADDR_MASK;
switch(p_addr>>GDFunction::ADDR_BITS) {
case GDFunction::ADDR_TYPE_SELF: {
return "self";
} break;
case GDFunction::ADDR_TYPE_CLASS: {
return "class";
} break;
case GDFunction::ADDR_TYPE_MEMBER: {
return "member("+p_script->debug_get_member_by_index(addr)+")";
} break;
case GDFunction::ADDR_TYPE_CLASS_CONSTANT: {
return "class_const("+func.get_global_name(addr)+")";
} break;
case GDFunction::ADDR_TYPE_LOCAL_CONSTANT: {
Variant v=func.get_constant(addr);
String txt;
if (v.get_type()==Variant::STRING || v.get_type()==Variant::NODE_PATH)
txt="\""+String(v)+"\"";
else
txt=v;
return "const("+txt+")";
} break;
case GDFunction::ADDR_TYPE_STACK: {
return "stack("+itos(addr)+")";
} break;
case GDFunction::ADDR_TYPE_STACK_VARIABLE: {
return "var_stack("+itos(addr)+")";
} break;
case GDFunction::ADDR_TYPE_GLOBAL: {
return "global("+func.get_global_name(addr)+")";
} break;
case GDFunction::ADDR_TYPE_NIL: {
return "nil";
} break;
}
return "<err>";
}
static void _disassemble_class(const Ref<GDScript>& p_class,const Vector<String>& p_code) {
const Map<StringName,GDFunction>& mf = p_class->debug_get_member_functions();
for(const Map<StringName,GDFunction>::Element *E=mf.front();E;E=E->next()) {
const GDFunction &func=E->get();
const int *code = func.get_code();
int codelen=func.get_code_size();
String defargs;
if (func.get_default_argument_count()) {
defargs="defarg at: ";
for(int i=0;i<func.get_default_argument_count();i++) {
if (i>0)
defargs+=",";
defargs+=itos(func.get_default_argument_addr(i));
}
defargs+=" ";
}
print_line("== function "+String(func.get_name())+"() :: stack size: "+itos(func.get_max_stack_size())+" "+defargs+"==");
#define DADDR(m_ip) (_disassemble_addr(p_class,func,code[ip+m_ip]))
for(int ip=0;ip<codelen;) {
int incr=0;
String txt=itos(ip)+" ";
switch(code[ip]) {
case GDFunction::OPCODE_OPERATOR: {
int op = code[ip+1];
txt+="op ";
String opname = Variant::get_operator_name(Variant::Operator(op));
txt+=DADDR(4);
txt+=" = ";
txt+=DADDR(2);
txt+=" "+opname+" ";
txt+=DADDR(3);
incr+=5;
} break;
case GDFunction::OPCODE_SET: {
txt+="set ";
txt+=DADDR(1);
txt+="[";
txt+=DADDR(2);
txt+="]=";
txt+=DADDR(3);
incr+=4;
} break;
case GDFunction::OPCODE_GET: {
txt+=" get ";
txt+=DADDR(3);
txt+="=";
txt+=DADDR(1);
txt+="[";
txt+=DADDR(2);
txt+="]";
incr+=4;
} break;
case GDFunction::OPCODE_SET_NAMED: {
txt+=" set_named ";
txt+=DADDR(1);
txt+="[\"";
txt+=func.get_global_name(code[ip+2]);
txt+="\"]=";
txt+=DADDR(3);
incr+=4;
} break;
case GDFunction::OPCODE_GET_NAMED: {
txt+=" get_named ";
txt+=DADDR(3);
txt+="=";
txt+=DADDR(1);
txt+="[\"";
txt+=func.get_global_name(code[ip+2]);
txt+="\"]";
incr+=4;
} break;
case GDFunction::OPCODE_ASSIGN: {
txt+=" assign ";
txt+=DADDR(1);
txt+="=";
txt+=DADDR(2);
incr+=3;
} break;
case GDFunction::OPCODE_ASSIGN_TRUE: {
txt+=" assign ";
txt+=DADDR(1);
txt+="= true";
incr+=2;
} break;
case GDFunction::OPCODE_ASSIGN_FALSE: {
txt+=" assign ";
txt+=DADDR(1);
txt+="= false";
incr+=2;
} break;
case GDFunction::OPCODE_CONSTRUCT: {
Variant::Type t=Variant::Type(code[ip+1]);
int argc=code[ip+2];
txt+=" construct ";
txt+=DADDR(3+argc);
txt+=" = ";
txt+=Variant::get_type_name(t)+"(";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(i+3);
}
txt+=")";
incr=4+argc;
} break;
case GDFunction::OPCODE_CONSTRUCT_ARRAY: {
int argc=code[ip+1];
txt+=" make_array ";
txt+=DADDR(2+argc);
txt+=" = [ ";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(2+i);
}
txt+="]";
incr+=3+argc;
} break;
case GDFunction::OPCODE_CONSTRUCT_DICTIONARY: {
int argc=code[ip+1];
txt+=" make_dict ";
txt+=DADDR(2+argc*2);
txt+=" = { ";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(2+i*2+0);
txt+=":";
txt+=DADDR(2+i*2+1);
}
txt+="}";
incr+=3+argc*2;
} break;
case GDFunction::OPCODE_CALL:
case GDFunction::OPCODE_CALL_RETURN: {
bool ret=code[ip]==GDFunction::OPCODE_CALL_RETURN;
if (ret)
txt+=" call-ret ";
else
txt+=" call ";
int argc=code[ip+1];
if (ret) {
txt+=DADDR(4+argc)+"=";
}
txt+=DADDR(2)+".";
txt+=String(func.get_global_name(code[ip+3]));
txt+="(";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(4+i);
}
txt+=")";
incr=5+argc;
} break;
case GDFunction::OPCODE_CALL_BUILT_IN: {
txt+=" call-built-in ";
int argc=code[ip+2];
txt+=DADDR(3+argc)+"=";
txt+=GDFunctions::get_func_name(GDFunctions::Function(code[ip+1]));
txt+="(";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(3+i);
}
txt+=")";
incr=4+argc;
} break;
case GDFunction::OPCODE_CALL_SELF_BASE: {
txt+=" call-self-base ";
int argc=code[ip+2];
txt+=DADDR(3+argc)+"=";
txt+=func.get_global_name(code[ip+1]);
txt+="(";
for(int i=0;i<argc;i++) {
if (i>0)
txt+=", ";
txt+=DADDR(3+i);
}
txt+=")";
incr=4+argc;
} break;
case GDFunction::OPCODE_YIELD: {
txt+=" yield ";
incr=1;
} break;
case GDFunction::OPCODE_YIELD_SIGNAL: {
txt+=" yield_signal ";
txt+=DADDR(1);
txt+=",";
txt+=DADDR(2);
incr=3;
} break;
case GDFunction::OPCODE_YIELD_RESUME: {
txt+=" yield resume: ";
txt+=DADDR(1);
incr=2;
} break;
case GDFunction::OPCODE_JUMP: {
txt+=" jump ";
txt+=itos(code[ip+1]);
incr=2;
} break;
case GDFunction::OPCODE_JUMP_IF: {
txt+=" jump-if ";
txt+=DADDR(1);
txt+=" to ";
txt+=itos(code[ip+2]);
incr=3;
} break;
case GDFunction::OPCODE_JUMP_IF_NOT: {
txt+=" jump-if-not ";
txt+=DADDR(1);
txt+=" to ";
txt+=itos(code[ip+2]);
incr=3;
} break;
case GDFunction::OPCODE_JUMP_TO_DEF_ARGUMENT: {
txt+=" jump-to-default-argument ";
incr=1;
} break;
case GDFunction::OPCODE_RETURN: {
txt+=" return ";
txt+=DADDR(1);
incr=2;
} break;
case GDFunction::OPCODE_ITERATE_BEGIN: {
txt+=" for-init "+DADDR(4)+" in "+DADDR(2)+" counter "+DADDR(1)+" end "+itos(code[ip+3]);
incr+=5;
} break;
case GDFunction::OPCODE_ITERATE: {
txt+=" for-loop "+DADDR(4)+" in "+DADDR(2)+" counter "+DADDR(1)+" end "+itos(code[ip+3]);
incr+=5;
} break;
case GDFunction::OPCODE_LINE: {
int line = code[ip+1]-1;
if (line>=0 && line <p_code.size())
txt="\n"+itos(line+1)+": "+p_code[line]+"\n";
else
txt="";
incr+=2;
} break;
case GDFunction::OPCODE_END: {
txt+=" end";
incr+=1;
} break;
case GDFunction::OPCODE_ASSERT: {
txt+=" assert ";
txt+=DADDR(1);
incr+=2;
} break;
}
if (incr==0) {
ERR_EXPLAIN("unhandled opcode: "+itos(code[ip]));
ERR_BREAK(incr==0);
}
ip+=incr;
if (txt!="")
print_line(txt);
}
}
}
MainLoop* test(TestType p_test) {
List<String> cmdlargs = OS::get_singleton()->get_cmdline_args();
if (cmdlargs.empty()) {
//try editor!
return NULL;
}
String test = cmdlargs.back()->get();
FileAccess *fa = FileAccess::open(test,FileAccess::READ);
if (!fa) {
ERR_EXPLAIN("Could not open file: "+test);
ERR_FAIL_V(NULL);
}
Vector<uint8_t> buf;
int flen = fa->get_len();
buf.resize(fa->get_len()+1);
fa->get_buffer(&buf[0],flen);
buf[flen]=0;
String code;
code.parse_utf8((const char*)&buf[0]);
Vector<String> lines;
int last=0;
for(int i=0;i<=code.length();i++) {
if (code[i]=='\n' || code[i]==0) {
lines.push_back(code.substr(last,i-last));
last=i+1;
}
}
if (p_test==TEST_TOKENIZER) {
GDTokenizerText tk;
tk.set_code(code);
int line=-1;
while(tk.get_token()!=GDTokenizer::TK_EOF) {
String text;
if (tk.get_token()==GDTokenizer::TK_IDENTIFIER)
text="'"+tk.get_token_identifier()+"' (identifier)";
else if (tk.get_token()==GDTokenizer::TK_CONSTANT) {
Variant c= tk.get_token_constant();
if (c.get_type()==Variant::STRING)
text="\""+String(c)+"\"";
else
text=c;
text=text+" ("+Variant::get_type_name(c.get_type())+" constant)";
} else if (tk.get_token()==GDTokenizer::TK_ERROR)
text="ERROR: "+tk.get_token_error();
else if (tk.get_token()==GDTokenizer::TK_NEWLINE)
text="newline ("+itos(tk.get_token_line())+") + indent: "+itos(tk.get_token_line_indent());
else if (tk.get_token()==GDTokenizer::TK_BUILT_IN_FUNC)
text="'"+String(GDFunctions::get_func_name(tk.get_token_built_in_func()))+"' (built-in function)";
else
text=tk.get_token_name(tk.get_token());
if (tk.get_token_line()!=line) {
int from=line+1;
line = tk.get_token_line();;
for(int i=from;i<=line;i++) {
int l=i-1;
if (l>=0 && l<lines.size()) {
print_line("\n"+itos(i)+": "+lines[l]+"\n");
}
}
}
print_line("\t("+itos(tk.get_token_column())+"): "+text);
tk.advance();
}
}
if (p_test==TEST_PARSER) {
GDParser parser;
Error err = parser.parse(code);
if (err) {
print_line("Parse Error:\n"+itos(parser.get_error_line())+":"+itos(parser.get_error_column())+":"+parser.get_error());
memdelete(fa);
return NULL;
}
const GDParser::Node* root = parser.get_parse_tree();
ERR_FAIL_COND_V(root->type!=GDParser::Node::TYPE_CLASS,NULL);
const GDParser::ClassNode *cnode=static_cast<const GDParser::ClassNode*>(root);
_parser_show_class(cnode,0,lines);
}
if (p_test==TEST_COMPILER) {
GDParser parser;
Error err = parser.parse(code);
if (err) {
print_line("Parse Error:\n"+itos(parser.get_error_line())+":"+itos(parser.get_error_column())+":"+parser.get_error());
memdelete(fa);
return NULL;
}
GDScript *script = memnew( GDScript );
GDCompiler gdc;
err = gdc.compile(&parser,script);
if (err) {
print_line("Compile Error:\n"+itos(gdc.get_error_line())+":"+itos(gdc.get_error_column())+":"+gdc.get_error());
memdelete(script);
return NULL;
}
Ref<GDScript> gds =Ref<GDScript>( script );
Ref<GDScript> current=gds;
while(current.is_valid()) {
print_line("** CLASS **");
_disassemble_class(current,lines);
current=current->get_base();
}
} else if (p_test==TEST_BYTECODE) {
Vector<uint8_t> buf = GDTokenizerBuffer::parse_code_string(code);
String dst = test.basename()+".gdc";
FileAccess *fw = FileAccess::open(dst,FileAccess::WRITE);
fw->store_buffer(buf.ptr(),buf.size());
memdelete(fw);
}
#if 0
Parser parser;
Error err = parser.parse(code);
if (err) {
print_line("error:"+itos(parser.get_error_line())+":"+itos(parser.get_error_column())+":"+parser.get_error());
} else {
print_line("Parse O-K!");
}
#endif
memdelete(fa);
return NULL;
}
}
#else
namespace TestGDScript {
MainLoop* test(TestType p_test) {
return NULL;
}
}
#endif