--- parser3/src/classes/reflection.C 2012/05/27 22:10:09 1.26 +++ parser3/src/classes/reflection.C 2015/10/08 22:49:36 1.33 @@ -9,7 +9,7 @@ #include "pa_request.h" #include "pa_vbool.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.26 2012/05/27 22:10:09 misha Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.33 2015/10/08 22:49:36 moko Exp $"; static const String class_type_methoded("methoded"); @@ -24,6 +24,9 @@ static const String method_call_type_dyn 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 def_class("class"); // class @@ -184,6 +187,16 @@ static void store_method_info( result->put(key, new VString(method->native_code?method_type_native:method_type_parser)); } +static void _def(Request& r, MethodParams& params) { + const String& type=params.as_string(0, "type must be string"); + if(type == def_class) { + const String& name=params.as_string(1, "name must be string"); + r.write_no_lang(VBool::get(r.get_class(name)!=0)); + } else { + throw Exception(PARSER_RUNTIME, &type, "is 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"); Value* class_value=r.get_class(class_name); @@ -193,7 +206,7 @@ static void _methods(Request& r, MethodP "class is undefined"); VHash& result=*new VHash; - if(VStateless_class* lclass=class_value->get_class()){ + if(VStateless_class* lclass=class_value->get_class()) { HashStringMethod methods=lclass->get_methods(); methods.for_each(store_method_info, result.get_hash()); } else { @@ -202,14 +215,37 @@ static void _methods(Request& r, MethodP r.write_no_lang(result); } +static void _method(Request& r, MethodParams& params) { + Value& o=params.as_no_junction(0, "first param must be object or class, not junction"); + const String& name=params.as_string(1, "method name must be string"); + + if(VStateless_class* lclass=o.get_class()) { + if(Method* method=lclass->get_method(name)) + r.write_no_lang(*method->get_vjunction(o)); + } else { + // class which does not have methods (env, console, etc) + } +} + static void _fields(Request& r, MethodParams& params) { - if(HashStringValue* fields=params[0].get_fields()){ + Value& o=params.as_no_junction(0, "param must be object or class, not junction"); + + if(HashStringValue* fields=o.get_fields()) { VHash& result=*new VHash(*fields); r.write_no_lang(result); } else r.write_no_lang(*new VHash()); } +static void _field(Request& r, MethodParams& params) { + Value& o=params.as_no_junction(0, "first param must be object or class, not junction"); + const String& name=params.as_string(1, "field name must be string"); + + if(HashStringValue* fields=o.get_fields()) + if(Value* value=fields->get(name)) + r.write_no_lang(*value); +} + 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.get_class(class_name); @@ -244,29 +280,38 @@ static void _method_info(Request& r, Met hash->put((base_method==method) ? method_inherited : method_overridden, new VString(c->name())); } + Value* call_type=0; + switch(method->call_type){ + case Method::CT_DYNAMIC: + call_type=new VString(method_call_type_dynamic); + break; + case Method::CT_STATIC: + call_type=new VString(method_call_type_static); + break; + case Method::CT_ANY: + break; + } + if(call_type) + hash->put(method_call_type, call_type); + 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)); - Value* call_type=0; - switch(method->call_type){ - case Method::CT_DYNAMIC: - call_type=new VString(method_call_type_dynamic); - break; - case Method::CT_STATIC: - call_type=new VString(method_call_type_static); - break; - } - 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)); + + hash->put(method_max_params, new VInt(method->params_names ? method->params_names->count() : 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))); + + if(method->extra_params) + hash->put(method_extra_param, new VString(*method->extra_params)); } r.write_no_lang(result); @@ -299,10 +344,10 @@ 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(pa_strdup(local_buf, (size_t)size), String::L_CLEAN, size)); + r.write_pass_lang(*new String(String::C(pa_strdup(local_buf, (size_t)size), size))); } -static void _delete(Request& r, MethodParams& params) { +static void _delete(Request&, MethodParams& params) { const String& key=params.as_string(1, "field name must be string"); if(HashStringValue* fields=params[0].get_fields()){ fields->remove(key); @@ -330,15 +375,24 @@ MReflection::MReflection(): Methoded("re // ^reflection:base_class_name[object] add_native_method("base_name", Method::CT_STATIC, _base_name, 1, 1); + // ^reflection:def[class|...;name] + add_native_method("def", Method::CT_STATIC, _def, 2, 2); + // ^reflection:methods[class_name] add_native_method("methods", Method::CT_STATIC, _methods, 1, 1); - // ^reflection:fields[object or class] - add_native_method("fields", Method::CT_STATIC, _fields, 1, 1); + // ^reflection:method[object or class;method_name] + add_native_method("method", Method::CT_STATIC, _method, 2, 2); // ^reflection:method_info[class_name;method_name] add_native_method("method_info", Method::CT_STATIC, _method_info, 2, 2); + // ^reflection:fields[object or class] + add_native_method("fields", Method::CT_STATIC, _fields, 1, 1); + + // ^reflection:field[object or class;field_name] + add_native_method("field", Method::CT_STATIC, _field, 2, 2); + // ^reflection:dynamical[[object or class, caller if absent]] add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1);