--- parser3/src/classes/reflection.C 2009/07/28 08:03:05 1.3 +++ parser3/src/classes/reflection.C 2011/02/20 05:32:39 1.23 @@ -5,7 +5,7 @@ Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char * const IDENT_REFLECTION_C="$Date: 2009/07/28 08:03:05 $"; +static const char * const IDENT_REFLECTION_C="$Date: 2011/02/20 05:32:39 $"; #include "pa_vmethod_frame.h" #include "pa_request.h" @@ -16,9 +16,11 @@ static const String class_type_methoded( static const String method_type_native("native"); static const String method_type_parser("parser"); +static const String method_call_type("call_type"); +static const String method_inherited("inherited"); +static const String method_overridden("overridden"); static const String method_call_type_static("static"); static const String method_call_type_dynamic("dynamic"); -static const String method_call_type_any("any"); static const String method_min_params("min_params"); static const String method_max_params("max_params"); @@ -28,8 +30,6 @@ static const String method_max_params("m class MReflection: public Methoded { public: MReflection(); -public: // Methoded - bool used_directly() { return true; } }; // global variable @@ -41,7 +41,7 @@ DECLARE_CLASS_VAR(reflection, new MRefle static void _create(Request& r, MethodParams& params) { const String& class_name=params.as_string(0, "class_name must be string"); - Value* class_value=r.classes().get(class_name); + Value* class_value=r.get_class(class_name); if(!class_value) throw Exception(PARSER_RUNTIME, @@ -49,9 +49,9 @@ static void _create(Request& r, MethodPa "class is undefined"); const String& constructor_name=params.as_string(1, "constructor_name must be string"); - Value* constructor_value=class_value->get_element(constructor_name, *class_value, true); + Value* constructor_value=class_value->get_element(constructor_name); - if(!constructor_value || !constructor_value->get_junction() || constructor_value->get_junction()->self.get_class()!=class_value) + if(!constructor_value || !constructor_value->get_junction()) throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", @@ -82,7 +82,7 @@ static void _create(Request& r, MethodPa max_params_count=method->max_numbered_params_count; } else { - max_params_count=method->params_names->count(); + max_params_count=method->params_names?method->params_names->count():0; } if(nparams>max_params_count) @@ -94,7 +94,8 @@ static void _create(Request& r, MethodPa max_params_count, nparams); - VMethodFrame frame(*junction, r.get_method_frame()); + Value &object = r.construct(*class_value, *method); + VConstructorFrame frame(*method, r.get_method_frame(), object); Value* v[100]; if(nparams>0){ @@ -104,7 +105,8 @@ static void _create(Request& r, MethodPa } else { frame.empty_params(); } - r.op_call(frame, true/*constructing*/); + r.op_call(frame); + object.enable_default_setter(); r.write_pass_lang(frame.result()); } @@ -174,10 +176,9 @@ static void _base_name(Request& r, Metho r.write_no_lang(*get_class_name(base)); } - static void store_method_info( - HashString::key_type key, - HashString::value_type method, + HashStringMethod::key_type key, + HashStringMethod::value_type method, HashStringValue* result ) { result->put(key, new VString(method->native_code?method_type_native:method_type_parser)); @@ -185,7 +186,7 @@ static void store_method_info( static void _methods(Request& r, MethodParams& params) { const String& class_name=params.as_string(0, "class_name must be string"); - Value* class_value=r.classes().get(class_name); + Value* class_value=r.get_class(class_name); if(!class_value) throw Exception(PARSER_RUNTIME, &class_name, @@ -193,7 +194,7 @@ static void _methods(Request& r, MethodP VHash& result=*new VHash; if(VStateless_class* lclass=class_value->get_class()){ - HashString methods=lclass->get_methods(); + HashStringMethod methods=lclass->get_methods(); methods.for_each(store_method_info, result.get_hash()); } else { // class which does not have methods (env, console, etc) @@ -201,10 +202,17 @@ static void _methods(Request& r, MethodP r.write_no_lang(result); } +static void _fields(Request& r, MethodParams& params) { + if(HashStringValue* fields=params[0].get_fields()){ + VHash& result=*new VHash(*fields); + r.write_no_lang(result); + } else + r.write_no_lang(*new VHash()); +} -static void _method_params(Request& r, MethodParams& params) { +static void _method_info(Request& r, MethodParams& params) { const String& class_name=params.as_string(0, "class_name must be string"); - Value* class_value=r.classes().get(class_name); + Value* class_value=r.get_class(class_name); if(!class_value) throw Exception(PARSER_RUNTIME, &class_name, @@ -226,25 +234,36 @@ static void _method_params(Request& r, M VHash& result=*new VHash; HashStringValue* hash=result.get_hash(); + + VStateless_class* c=lclass; + 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(c->name())); + } + if(method->native_code){ // native code hash->put(method_min_params, new VInt(method->min_numbered_params_count)); hash->put(method_max_params, new VInt(method->max_numbered_params_count)); - const String* call_type; + Value* call_type=0; switch(method->call_type){ case Method::CT_DYNAMIC: - call_type=&method_call_type_dynamic; + call_type=new VString(method_call_type_dynamic); break; case Method::CT_STATIC: - call_type=&method_call_type_static; + call_type=new VString(method_call_type_static); break; - default: - call_type=&method_call_type_any; } - hash->put(String("call_type"), new VString(*call_type)); - + if(call_type) + hash->put(method_call_type, call_type); } else { // parser code + const String* filespec = r.get_method_filename(method); + if( filespec ) + hash->put("file", new VString(*filespec)); 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))); @@ -253,6 +272,27 @@ static void _method_params(Request& r, M r.write_no_lang(result); } +static void _dynamical(Request& r, MethodParams& params) { + if(params.count()){ + r.write_no_lang(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())); + } +} + +static void _copy(Request& r, MethodParams& params) { + HashStringValue* src=params.as_no_junction(0, "source must not be code").get_hash(); + + if(src==NULL) + throw Exception(PARSER_RUNTIME, 0, "source must have hash representation"); + + Value& dst=params.as_no_junction(1, "destination must not be code"); + + for(HashStringValue::Iterator i(*src); i; i.next()) + r.put_element(dst, *new String(i.key(), String::L_TAINTED), i.value()); +} + // constructor MReflection::MReflection(): Methoded("reflection") { // ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]] @@ -276,6 +316,15 @@ MReflection::MReflection(): Methoded("re // ^reflection:methods[class_name] add_native_method("methods", Method::CT_STATIC, _methods, 1, 1); - // ^reflection:method_params[class_name;method_name] - add_native_method("method_params", Method::CT_STATIC, _method_params, 2, 2); + // ^reflection:fields[object or class] + add_native_method("fields", Method::CT_STATIC, _fields, 1, 1); + + // ^reflection:method_info[class_name;method_name] + add_native_method("method_info", Method::CT_STATIC, _method_info, 2, 2); + + // ^reflection:dynamical[[object or class, caller if absent]] + add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1); + + // ^reflection:copy[src;dst] + add_native_method("copy", Method::CT_STATIC, _copy, 2, 2); }