/*************************************************************************/ /* test_gdscript.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 "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;iextends_file)!="") { txt+="\""+p_class->extends_file+"\""; if (p_class->extends_class.size()) txt+="."; } for(int i=0;iextends_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(p_expr); txt=id_node->name; } break; case GDParser::Node::TYPE_CONSTANT: { const GDParser::ConstantNode *c_node = static_cast(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(p_expr); txt+="["; for(int i=0;ielements.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(p_expr); txt+="{"; for(int i=0;ielements.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(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(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(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;iarguments.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;istatements.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(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(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;iarguments.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& 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;isubclasses.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;iconstant_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;ivariables.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;istatic_functions.size();i++) { _parser_show_function(p_class->static_functions[i],p_indent); print_line("\n"); } for(int i=0;ifunctions.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& 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_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 ""; } static void _disassemble_class(const Ref& p_class,const Vector& p_code) { const Map& mf = p_class->debug_get_member_functions(); for(const Map::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;i0) 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;ip0) 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;i0) 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;i0) 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;i0) 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;i0) 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;i0) txt+=", "; txt+=DADDR(3+i); } txt+=")"; incr=4+argc; } 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 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 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 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 && ltype!=GDParser::Node::TYPE_CLASS,NULL); const GDParser::ClassNode *cnode=static_cast(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 gds =Ref( script ); Ref current=gds; while(current.is_valid()) { print_line("** CLASS **"); _disassemble_class(current,lines); current=current->get_base(); } } else if (p_test==TEST_BYTECODE) { Vector 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