--- parser3/src/classes/reflection.C 2016/09/26 20:38:33 1.57 +++ parser3/src/classes/reflection.C 2020/12/31 12:08:34 1.88 @@ -1,7 +1,7 @@ /** @file Parser: @b reflection parser class. - Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com) + Copyright (c) 2001-2020 Art. Lebedev Studio (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ @@ -10,13 +10,15 @@ #include "pa_vbool.h" #include "pa_vobject.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.57 2016/09/26 20:38:33 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.88 2020/12/31 12:08:34 moko Exp $"; static const String class_type_methoded("methoded"); static const String method_type_native("native"); static const String method_type_parser("parser"); +static const String method_name("name"); +static const String method_class_name("class"); static const String method_call_type("call_type"); static const String method_inherited("inherited"); static const String method_overridden("overridden"); @@ -40,68 +42,83 @@ DECLARE_CLASS_VAR(reflection, new MRefle // methods +const int MAX_CREATE_PARAMS = 100; static void _create(Request& r, MethodParams& params) { - const String& class_name=params.as_string(0, "class_name must be string"); - VStateless_class* vclass=r.get_class(class_name); + int params_offset; + HashStringValue* params_hash=0; - if(!vclass) - throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); + const String* class_name=0; + const String* constructor_name=0; - const String& constructor_name=params.as_string(1, "constructor_name must be string"); - Value* constructor_value=vclass->get_element(constructor_name); + Value& voptions=params.as_no_junction(0, "param must not be code"); + if(HashStringValue* options=voptions.get_hash()) { + int valid_options=0; + if(Value* vclass_name=options->get("class")) { + valid_options++; + class_name=&vclass_name->as_string(); + } + if(Value* vconstructor_name=options->get("constructor")) { + valid_options++; + constructor_name=&vconstructor_name->as_string(); + } + if(Value* vparams_hash=options->get("arguments")) { + valid_options++; + params_hash=vparams_hash->as_hash("arguments"); + if(params.count()>1) + throw Exception(PARSER_RUNTIME, 0, "arguments should not be specified as hash and as create params"); + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); - if(!constructor_value || !constructor_value->get_junction()) - throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", vclass->type()); + if(!class_name) + throw Exception(PARSER_RUNTIME, 0, "class name must be specified"); + if(!constructor_name) + throw Exception(PARSER_RUNTIME, 0, "constructor name must be specified"); - Junction* junction=constructor_value->get_junction(); - const Method* method=junction->method; + params_offset=1; + } else { + class_name=¶ms.as_string(0, "param must not be code"); - int nparams=params.count()-2; - int max_params_count; + if(params.count()==1) + throw Exception(PARSER_RUNTIME, 0, "constructor name must be specified"); - if(method->native_code){ - if(method->call_type==Method::CT_STATIC) - throw Exception(PARSER_RUNTIME, - &constructor_name, - "native method of class '%s' is not allowed to be called dynamically", - vclass->type()); - - if(nparamsmin_numbered_params_count) - throw Exception(PARSER_RUNTIME, - &constructor_name, - "native method of class '%s' accepts minimum %d parameter(s) (%d passed)", - vclass->type(), - method->min_numbered_params_count, - nparams); + constructor_name=¶ms.as_string(1, "constructor name must be string"); - max_params_count=method->max_numbered_params_count; - } else { - max_params_count=method->params_names?method->params_names->count():0; + params_offset=2; } - if(nparams>max_params_count) - throw Exception(PARSER_RUNTIME, - &constructor_name, - "method of class '%s' accepts maximum %d parameter(s) (%d passed)", - vclass->type(), - max_params_count, - nparams); - - Value &object = r.construct(*vclass, *method); - VConstructorFrame frame(*method, r.get_method_frame(), object); - - Value* v[100]; - if(nparams>0){ - for(int i=0; icount() : (params.count()-params_offset); + if(nparams>MAX_CREATE_PARAMS) + throw Exception(PARSER_RUNTIME, 0, "arguments count should not exceed %d", MAX_CREATE_PARAMS); + + Value* args[MAX_CREATE_PARAMS]; + CONSTRUCTOR_FRAME_ACTION(*method, r.get_method_frame(), object, { + if(nparams>0){ + if(params_hash){ + int i=0; + for(HashStringValue::Iterator h(*params_hash); h; h.next()) + args[i++]=h.value(); + } else { + for(int i=0; i::Iterator i(r.classes()); i; i.next()){ result.hash().put(i.key(), i.value()->get_methods().count()>0 ? new VString(class_type_methoded) : VVoid::get() ); } - r.write_no_lang(result); + r.write(result); } @@ -133,26 +150,23 @@ static const String& get_class_name(Valu static void _class(Request& r, MethodParams& params) { - r.write_no_lang(get_class(params[0])); + r.write(get_class(params[0])); } static void _class_name(Request& r, MethodParams& params) { - r.write_no_lang(get_class_name(params[0])); + r.write(get_class_name(params[0])); } static void _class_by_name(Request& r, MethodParams& params) { const String& class_name=params.as_string(0, "class_name must be string"); - Value* class_value=r.get_class(class_name); - if(!class_value) - throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); - r.write_no_lang(*class_value); + r.write(r.get_class_ref(class_name)); } static void _base(Request& r, MethodParams& params) { if(VStateless_class* vclass=params[0].get_class()) if(Value* base=vclass->base()){ - r.write_no_lang(get_class(*base)); + r.write(get_class(*base)); return; } @@ -164,7 +178,7 @@ static void _base(Request& r, MethodPara static void _base_name(Request& r, MethodParams& params) { if(VStateless_class* vclass=params[0].get_class()) if(Value* base=vclass->base()) - r.write_no_lang(get_class_name(*base)); + r.write(get_class_name(*base)); } static void _def(Request& r, MethodParams& params) { @@ -172,7 +186,7 @@ static void _def(Request& r, MethodParam if(type == def_class) { const String& name=params.as_string(1, "name must be string"); // can't use get_class because it will call @autouse[] if the class wasn't loaded - r.write_no_lang(VBool::get(r.classes().get(name)!=0)); + r.write(VBool::get(r.classes().get(name)!=0)); } else { throw Exception(PARSER_RUNTIME, &type, "is invalid type, must be '%s'", def_class.cstr()); } @@ -180,16 +194,42 @@ static void _def(Request& r, MethodParam static void _methods(Request& r, MethodParams& params) { const String& class_name=params.as_string(0, "class_name must be string"); - VStateless_class* vclass=r.get_class(class_name); - if(!vclass) - throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); + VStateless_class& vclass=r.get_class_ref(class_name); + + bool reverse=true; + + if(params.count()>1) + if(HashStringValue* options=params.as_hash(1, "methods options")) { + int valid_options=0; + for(HashStringValue::Iterator i(*options); i; i.next() ){ + String::Body key=i.key(); + Value* value=i.value(); + if(key == "reverse") { + reverse=r.process(*value).as_bool(); + valid_options++; + } + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + } VHash& result=*new VHash; - for(HashStringMethod::Iterator i(vclass->get_methods()); i; i.next()){ - result.hash().put(i.key(), new VString(i.value()->native_code ? method_type_native : method_type_parser)); + +#ifdef HASH_ORDER + if(reverse){ + for(HashStringMethod::ReverseIterator i(vclass.get_methods()); i; i.prev()){ + result.hash().put(i.key(), new VString(i.value()->native_code ? method_type_native : method_type_parser)); + } + } else { +#else + { +#endif + for(HashStringMethod::Iterator i(vclass.get_methods()); i; i.next()){ + result.hash().put(i.key(), new VString(i.value()->native_code ? method_type_native : method_type_parser)); + } } - r.write_no_lang(result); + r.write(result); } static VJunction &method_junction(Value &self, Method &method){ @@ -203,12 +243,12 @@ static VJunction &method_junction(Value } static void _method(Request& r, MethodParams& params) { - Value &source=*params.get(0); + Value &source=params[0]; if(Junction *j=source.get_junction()){ if(Method* method=const_cast(j->method)){ Value& self=params.count()>1 ? params.as_no_junction(1, "self must be object, not junction") : r.get_method_frame()->caller()->self(); - r.write_no_lang(method_junction(self, *method)); + r.write(method_junction(self, *method)); return; } throw Exception(PARSER_RUNTIME, 0, "param must be method junction"); @@ -221,7 +261,7 @@ static void _method(Request& r, MethodPa if(VStateless_class* vclass=source.get_class()) { if(Method* method=vclass->get_method(name)){ - r.write_no_lang( params.count()>2 ? method_junction(params.as_no_junction(2, "self must be object, not junction"), *method) : *method->get_vjunction(source) ); + r.write( params.count()>2 ? method_junction(params.as_no_junction(2, "self must be object, not junction"), *method) : *method->get_vjunction(source) ); return; } } @@ -232,16 +272,16 @@ static void _fields(Request& r, MethodPa Value& o=params.as_no_junction(0, "param must be object or class, not junction"); if(HashStringValue* fields=o.get_fields()) - r.write_no_lang(*new VHash(*fields)); + r.write(*new VHash(*fields)); else - r.write_no_lang(*new VHash()); + r.write(*new VHash()); } static void _fields_reference(Request& r, MethodParams& params) { Value& o=params.as_no_junction(0, "param must be object or hash, not junction"); if(HashStringValue* fields=o.get_fields_reference()) - r.write_no_lang(*new VHashReference(*fields)); + r.write(*new VHashReference(*fields)); else throw Exception(PARSER_RUNTIME, 0, "param must be object or hash"); } @@ -252,30 +292,40 @@ static void _field(Request& r, MethodPar if(HashStringValue* fields=o.get_fields()) if(Value* value=fields->get(name)) - r.write_no_lang(*value); + r.write(*value); } static void _method_info(Request& r, MethodParams& params) { - const String& class_name=params.as_string(0, "class_name must be string"); - VStateless_class* vclass=r.get_class(class_name); - if(!vclass) - throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); - - const String& method_name=params.as_string(1, "method_name must be string"); - Method* method=vclass->get_method(method_name); - if(!method) - throw Exception(PARSER_RUNTIME, &method_name, "method not found in class '%s'", vclass->type()); + const Method* method; VHash& result=*new VHash; HashStringValue* hash=result.get_hash(); - VStateless_class* c=vclass; - Method* base_method; - if(c->base() && (base_method=c->base()->get_method(method_name))){ - c=c->base()->get_class(); - while(c->base() && base_method==c->base()->get_method(method_name)) - c=c->base()->get_class(); - hash->put((base_method==method) ? method_inherited : method_overridden, new VString(*new String(c->type()))); + if(Junction *j=params[0].get_junction()){ + if(!(method=j->method)) + throw Exception(PARSER_RUNTIME, 0, "param must be class name or method junction"); + + hash->put(method_name, new VString(*method->name)); + hash->put(method_class_name, new VString(*new String(j->self.type()))); + + } else { + const String& class_name=params.as_string(0, "param must be class name or method junction"); + VStateless_class& vclass=r.get_class_ref(class_name); + + if(params.count()==1) + throw Exception(PARSER_RUNTIME, 0, "method name must be specified"); + + const String& method_name=params.as_string(1, "method name must be string"); + if(!(method=vclass.get_method(method_name))) + throw Exception(PARSER_RUNTIME, &method_name, "method not found in class '%s'", vclass.type()); + + Method* base_method; + if(vclass.base() && (base_method=vclass.base()->get_method(*method->name))){ + VStateless_class* c=vclass.base()->get_class(); + while(c->base() && base_method==c->base()->get_method(*method->name)) + c=c->base()->get_class(); + hash->put((base_method==method) ? method_inherited : method_overridden, new VString(*new String(c->type()))); + } } Value* call_type=0; @@ -298,7 +348,7 @@ static void _method_info(Request& r, Met hash->put(method_max_params, new VInt(method->max_numbered_params_count)); } else { // parser code - const String* filespec = r.get_method_filename(method); + const String* filespec = r.get_method_filespec(method); if( filespec ) hash->put("file", new VString(*filespec)); @@ -312,15 +362,31 @@ static void _method_info(Request& r, Met hash->put(method_extra_param, new VString(*method->extra_params)); } - r.write_no_lang(result); + r.write(result); +} + +static void _filename(Request& r, MethodParams& params) { + if(Junction *j=params[0].get_junction()){ + if(const Method* method=j->method){ + if(!method->native_code) + if(const String* filespec = r.get_method_filespec(method)) + r.write(*new VString(*filespec)); + return; + } + throw Exception(PARSER_RUNTIME, 0, "param must be object, class or method junction"); + } + + if(VClass* vclass = dynamic_cast(params[0].get_class())){ + r.write(*new VString(vclass->get_filespec())); + } } static void _dynamical(Request& r, MethodParams& params) { if(params.count()){ - r.write_no_lang(VBool::get(params[0].get_class() != ¶ms[0])); + r.write(VBool::get(params[0].get_class() != ¶ms[0])); } else { VMethodFrame* caller=r.get_method_frame()->caller(); - r.write_no_lang(VBool::get(caller && caller->get_class() != &caller->self())); + r.write(VBool::get(caller && caller->get_class() != &caller->self())); } } @@ -333,12 +399,12 @@ static void _is(Request& r, MethodParams if(value) { if(type == "code" || type == "method") { Junction *junction=value->get_junction(); - r.write_no_lang(VBool::get(junction && ((junction->code==0) ^ (type == "code"))) ); + r.write(VBool::get(junction && ((junction->code==0) ^ (type == "code"))) ); } else { - r.write_no_lang(VBool::get( value->is(type.cstr()) )); + r.write(VBool::get( value->is(type.cstr()) )); } } else - r.write_no_lang(VBool::get(type == "void")); + r.write(VBool::get(type == "void")); } static void _copy(Request& r, MethodParams& params) { @@ -359,13 +425,20 @@ static void _uid(Request& r, MethodParam char local_buf[MAX_NUMBER]; int size=snprintf(local_buf, sizeof(local_buf), "%p", &obj); - r.write_pass_lang(*new String(String::C(pa_strdup(local_buf, (size_t)size), size))); + r.write(*new String(String::C(pa_strdup(local_buf, (size_t)size), size))); } static void _delete(Request&, MethodParams& params) { + Value* v=¶ms.as_no_junction(0, "param must be object or class, not junction"); const String& key=params.as_string(1, "field name must be string"); - if(HashStringValue* fields=params[0].get_fields()){ - fields->remove(key); + + if(VObject* o=dynamic_cast(v)){ + o->get_fields()->remove(key); + } else if(VClass* c=dynamic_cast(v)){ + HashStringProperty &p=*c->get_properties(); + if(Property* property=p.get(key)) + if(property->value) + p.remove(key); } } @@ -376,29 +449,30 @@ static void _mixin(Request& r, MethodPar const String *name=0; bool copy_methods=true; bool copy_fields=true; - bool overwrite=true; + bool overwrite=false; if(params.count()>1) if(HashStringValue* options=params.as_hash(1, "mixin options")) { int valid_options=0; - if(vtarget=options->get("to")) { - valid_options++; - } - if(Value* vname=options->get("name")) { - name=&vname->as_string(); - valid_options++; - } - if(Value* vmethods=options->get("methods")) { - copy_methods=r.process_to_value(*vmethods).as_bool(); - valid_options++; - } - if(Value* vfields=options->get("fields")) { - copy_fields=r.process_to_value(*vfields).as_bool(); - valid_options++; - } - if(Value* voverwrite=options->get("overwrite")) { - overwrite=r.process_to_value(*voverwrite).as_bool(); - valid_options++; + for(HashStringValue::Iterator i(*options); i; i.next() ){ + String::Body key=i.key(); + Value* value=i.value(); + if(key == "to") { + vtarget=value; + valid_options++; + } else if(key == "name") { + name=&value->as_string(); + valid_options++; + } else if(key == "methods") { + copy_methods=r.process(*value).as_bool(); + valid_options++; + } else if(key == "fields") { + copy_fields=r.process(*value).as_bool(); + valid_options++; + } else if(key == "overwrite") { + overwrite=r.process(*value).as_bool(); + valid_options++; + } } if(valid_options!=options->count()) throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); @@ -419,7 +493,7 @@ static void _mixin(Request& r, MethodPar if(copy_methods) if(Method* method=source->get_method(*name)) if(overwrite || !target->get_method(*name)){ - target->set_method(*name, method); + target->set_method(*name, new Method(*method)); } if(copy_fields) @@ -432,7 +506,7 @@ static void _mixin(Request& r, MethodPar if(copy_methods) for(HashStringMethod::Iterator i(source->get_methods()); i; i.next()){ if(overwrite || !target->get_method(i.key())) - target->set_method(*i.value()->name, i.value()); + target->set_method(*i.value()->name, new Method(*i.value())); } if(copy_fields) for(HashStringProperty::Iterator i(*source->get_properties()); i; i.next()){ @@ -442,11 +516,147 @@ static void _mixin(Request& r, MethodPar } } +String::Language get_untaint_lang(const String& lang_name); // op.C + +static void _tainting(Request& r, MethodParams& params) { + const String& str=params.as_string(params.count()-1, "param must be string"); + String::Language lang = String::L_UNSPECIFIED; + bool optimized=false; + + if(params.count()==2){ + const String& slang=params.as_string(0, "language name must be string"); + if(slang == "optimized") + optimized=true; + else if(slang == "tainted") + lang=String::L_TAINTED; + else lang=get_untaint_lang(slang); + } + + if(!str.is_empty()){ + char *visual=str.visualize_langs(); + + if(optimized){ + for(char *c=visual; *c; c++) + *c = *c<0 ? '+':'-'; + } else if(lang != String::L_UNSPECIFIED){ + for(char *c=visual; *c; c++) + *c = *c==lang ? '+':'-'; + } else { + for(char *c=visual; *c; c++) + *c = *c & 0x7F; + } + + r.write(*new String(visual)); + } +} + +static void _stack(Request& r, MethodParams& params) { + bool show_args=false; + bool show_locals=false; + + int limit=1000000; + int offset=0; + + if(params.count()>0) + if(HashStringValue* options=params.as_hash(0, "stack options")) { + int valid_options=0; + for(HashStringValue::Iterator i(*options); i; i.next() ){ + String::Body key=i.key(); + Value* value=i.value(); + + if(key == "args") { + show_args=r.process(*value).as_bool(); + valid_options++; + } else if(key == "locals") { + show_locals=r.process(*value).as_bool(); + valid_options++; + } else if(key == "limit") { + limit=r.process(*value).as_int(); + valid_options++; + } else if(key == "offset") { + offset=r.process(*value).as_int(); + valid_options++; + } + } + + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + } + + limit+=offset; + + VHash& vresult=*new VHash; + HashStringValue* result=vresult.get_hash(); + int index=1; + VMethodFrame* caller=r.get_method_frame()->caller(); + while(caller && index <= limit){ + if(index>offset){ + VHash& vcurrent=*new VHash; + HashStringValue* current=vcurrent.get_hash(); + + current->put(Symbols::SELF_SYMBOL, &caller->self()); + + const Method& method=caller->method; + + current->put(method_name, new VString(*method.name)); + + if(!method.native_code){ + Operation::Origin origin=r.get_method_origin(&method); + if(origin.file_no){ + current->put("file", new VString(*r.get_used_filespec(origin.file_no))); + current->put("line", new VInt(origin.line)); // no +1 as declaration before first command + } + + if(show_args || show_locals){ + + VHash& vargs=*new VHash; + HashStringValue* args=vargs.get_hash(); + + if(method.params_names){ + for(size_t i=0; icount(); i++){ + const String& pname=*(*method.params_names)[i]; + Value* value=caller->get_element(pname); + args->put(pname, value->get_junction() ? VVoid::get() : value); + } + } + if(method.extra_params) + args->put(*method.extra_params, caller->get_element(*method.extra_params)); + + if(show_args) + current->put("args", &vargs); + + if(show_locals){ + VHash& vlocals=*new VHash; + HashStringValue* locals=vlocals.get_hash(); + + if(VParserMethodFrame* frame=dynamic_cast(caller)) + for(HashString::Iterator h(frame->my); h; h.next()){ + String::Body key=h.key(); + Value* value=h.value(); + if(!args->contains(key) && (key != "result")){ + locals->put(key, value->get_junction() ? VVoid::get() : value); + } + } + + current->put("locals", &vlocals); + } + } + } + + result->put(format(index, 0), &vcurrent); + } + caller=caller->caller(); + index++; + } + + r.write(vresult); +} // constructor MReflection::MReflection(): Methoded("reflection") { // ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]] - add_native_method("create", Method::CT_STATIC, _create, 2, 102); + // ^reflection:create[ $.class[name] $.constructor[name] $.arguments[ $.1[param1] $.2[param2] ...] ] + add_native_method("create", Method::CT_STATIC, _create, 1, MAX_CREATE_PARAMS + 2); // ^reflection:classes[] add_native_method("classes", Method::CT_STATIC, _classes, 0, 0); @@ -470,14 +680,18 @@ MReflection::MReflection(): Methoded("re add_native_method("def", Method::CT_STATIC, _def, 2, 2); // ^reflection:methods[class_name] - add_native_method("methods", Method::CT_STATIC, _methods, 1, 1); + add_native_method("methods", Method::CT_STATIC, _methods, 1, 2); // ^reflection:method[object or class;method_name[;self]] // ^reflection:method[junction[;self]] add_native_method("method", Method::CT_STATIC, _method, 1, 3); // ^reflection:method_info[class_name;method_name] - add_native_method("method_info", Method::CT_STATIC, _method_info, 2, 2); + // ^reflection:method_info[junction] + add_native_method("method_info", Method::CT_STATIC, _method_info, 1, 2); + + // ^reflection:filename[object or class or method] + add_native_method("filename", Method::CT_STATIC, _filename, 1, 1); // ^reflection:fields[object or class] add_native_method("fields", Method::CT_STATIC, _fields, 1, 1); @@ -506,4 +720,10 @@ MReflection::MReflection(): Methoded("re // ^reflection:mixin[object or class or junction;options] add_native_method("mixin", Method::CT_STATIC, _mixin, 1, 2); + // ^reflection:tainting[[language or 'tainted' or 'optimized';]string] + add_native_method("tainting", Method::CT_STATIC, _tainting, 1, 2); + + // ^reflection:stack[options] + add_native_method("stack", Method::CT_STATIC, _stack, 0, 1); + }