--- parser3/src/classes/reflection.C 2016/12/02 21:36:25 1.75 +++ parser3/src/classes/reflection.C 2024/12/23 16:59:17 1.97 @@ -1,16 +1,17 @@ /** @file Parser: @b reflection parser class. - Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com) - Author: Alexandr Petrosian (http://paf.design.ru) + Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com) + Authors: Konstantin Morshnev , Alexandr Petrosian */ #include "pa_vmethod_frame.h" #include "pa_request.h" #include "pa_vbool.h" +#include "pa_varray.h" #include "pa_vobject.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.75 2016/12/02 21:36:25 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.97 2024/12/23 16:59:17 moko Exp $"; static const String class_type_methoded("methoded"); @@ -26,6 +27,7 @@ static const String method_overridden("o static const String method_min_params("min_params"); static const String method_max_params("max_params"); static const String method_extra_param("extra_param"); +static const String method_named_params("named_params"); static const String def_class("class"); @@ -66,7 +68,7 @@ static void _create(Request& r, MethodPa valid_options++; params_hash=vparams_hash->as_hash("arguments"); if(params.count()>1) - throw Exception(PARSER_RUNTIME, 0, "agruments should not be specified as hash and as create params"); + 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); @@ -88,15 +90,13 @@ static void _create(Request& r, MethodPa params_offset=2; } - 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); - const Method* method=vclass->get_method(*constructor_name); + const Method* method=vclass.get_method(*constructor_name); if(!method) - throw Exception(PARSER_RUNTIME, constructor_name, "constructor not found in class '%s'", vclass->type()); + throw Exception(PARSER_RUNTIME, constructor_name, "constructor not found in class '%s'", vclass.type()); - Value &object = r.construct(*vclass, *method); + Value &object = r.construct(vclass, *method); int nparams=params_hash ? params_hash->count() : (params.count()-params_offset); if(nparams>MAX_CREATE_PARAMS) @@ -162,10 +162,16 @@ static void _class_name(Request& r, Meth 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(*class_value); + r.write(r.get_class_ref(class_name)); +} + +static void _class_alias(Request& r, MethodParams& params) { + const String& src_class_name=params.as_string(0, "source class_name must be string"); + const String& new_class_name=params.as_string(1, "alias class_name must be string"); + + VStateless_class &src_class=r.get_class_ref(src_class_name); + if(!r.add_class(new_class_name.cstr(), &src_class)) + throw Exception(PARSER_RUNTIME, &new_class_name, "class is already defined"); } static void _base(Request& r, MethodParams& params) { @@ -193,19 +199,45 @@ static void _def(Request& r, MethodParam // can't use get_class because it will call @autouse[] if the class wasn't loaded r.write(VBool::get(r.classes().get(name)!=0)); } else { - throw Exception(PARSER_RUNTIME, &type, "is invalid type, must be '%s'", def_class.cstr()); + throw Exception(PARSER_RUNTIME, &type, "is an invalid type, must be '%s'", def_class.cstr()); } } 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(result); @@ -226,7 +258,7 @@ static void _method(Request& r, MethodPa 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(); + Value& self=params.count()>1 ? params.as_no_junction(1, "self must be object") : r.get_method_frame()->caller()->self(); r.write(method_junction(self, *method)); return; } @@ -240,7 +272,7 @@ static void _method(Request& r, MethodPa if(VStateless_class* vclass=source.get_class()) { if(Method* method=vclass->get_method(name)){ - r.write( 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"), *method) : *method->get_vjunction(source) ); return; } } @@ -248,7 +280,7 @@ static void _method(Request& r, MethodPa } static void _fields(Request& r, MethodParams& params) { - Value& o=params.as_no_junction(0, "param must be object or class, not junction"); + Value& o=params.as_no_junction(0, "param must be object or class"); if(HashStringValue* fields=o.get_fields()) r.write(*new VHash(*fields)); @@ -257,7 +289,7 @@ static void _fields(Request& r, MethodPa } static void _fields_reference(Request& r, MethodParams& params) { - Value& o=params.as_no_junction(0, "param must be object or hash, not junction"); + Value& o=params.as_no_junction(0, "param must be object or hash"); if(HashStringValue* fields=o.get_fields_reference()) r.write(*new VHashReference(*fields)); @@ -266,7 +298,7 @@ static void _fields_reference(Request& r } static void _field(Request& r, MethodParams& params) { - Value& o=params.as_no_junction(0, "first param must be object or class, not junction"); + Value& o=params.as_no_junction(0, "first param must be object or class"); const String& name=params.as_string(1, "field name must be string"); if(HashStringValue* fields=o.get_fields()) @@ -289,21 +321,18 @@ static void _method_info(Request& r, Met } else { const String& class_name=params.as_string(0, "param must be class name or method junction"); - 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); 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()); + 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 && vclass->base() && (base_method=vclass->base()->get_method(*method->name))){ - VStateless_class* c=vclass->base()->get_class(); + 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()))); @@ -334,14 +363,25 @@ static void _method_info(Request& r, Met if( filespec ) hash->put("file", new VString(*filespec)); - hash->put(method_max_params, new VInt(method->params_names ? method->params_names->count() : 0)); + hash->put(method_max_params, new VInt(method->params_count + (method->named_params ? 1 : 0))); if(method->params_names) for(size_t i=0; iparams_names->count(); i++) - hash->put(String::Body::Format(i), new VString(*method->params_names->get(i))); + hash->put(pa_uitoa(i), new VString(*method->params_names->get(i))); if(method->extra_params) hash->put(method_extra_param, new VString(*method->extra_params)); + if(method->named_params){ + size_t named_count=method->named_params->count(); + VArray& named_params=*new VArray(named_count); + ArrayValue &array=named_params.array(); + + for(size_t i=0; inamed_params)[i]; + array+=new VString(fname); + } + hash->put(method_named_params, &named_params); + } } r.write(result); @@ -411,7 +451,7 @@ static void _uid(Request& r, MethodParam } static void _delete(Request&, MethodParams& params) { - Value* v=¶ms.as_no_junction(0, "param must be object or class, not junction"); + Value* v=¶ms.as_no_junction(0, "param must be object or class"); const String& key=params.as_string(1, "field name must be string"); if(VObject* o=dynamic_cast(v)){ @@ -436,24 +476,25 @@ static void _mixin(Request& r, MethodPar 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(*vmethods).as_bool(); - valid_options++; - } - if(Value* vfields=options->get("fields")) { - copy_fields=r.process(*vfields).as_bool(); - valid_options++; - } - if(Value* voverwrite=options->get("overwrite")) { - overwrite=r.process(*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); @@ -497,6 +538,141 @@ 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(pa_uitoa(index), &vcurrent); + } + caller=caller->caller(); + index++; + } + + r.write(vresult); +} // constructor MReflection::MReflection(): Methoded("reflection") { @@ -516,6 +692,9 @@ MReflection::MReflection(): Methoded("re // ^reflection:class_by_name[class_name] add_native_method("class_by_name", Method::CT_STATIC, _class_by_name, 1, 1); + // ^reflection:class_alias[class_name;new_class_name] + add_native_method("class_alias", Method::CT_STATIC, _class_alias, 2, 2); + // ^reflection:base_class[object] add_native_method("base", Method::CT_STATIC, _base, 1, 1); @@ -526,7 +705,7 @@ 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]] @@ -536,7 +715,7 @@ MReflection::MReflection(): Methoded("re // ^reflection:method_info[junction] add_native_method("method_info", Method::CT_STATIC, _method_info, 1, 2); - // ^reflection:filename[object or class] + // ^reflection:filename[object or class or method] add_native_method("filename", Method::CT_STATIC, _filename, 1, 1); // ^reflection:fields[object or class] @@ -566,4 +745,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); + }