--- parser3/src/classes/reflection.C 2009/07/26 05:41:54 1.2 +++ parser3/src/classes/reflection.C 2009/08/08 22:28:37 1.7 @@ -5,31 +5,23 @@ Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char * const IDENT_REFLECTION_C="$Date: 2009/07/26 05:41:54 $"; +static const char * const IDENT_REFLECTION_C="$Date: 2009/08/08 22:28:37 $"; #include "pa_vmethod_frame.h" #include "pa_request.h" #include "pa_vbool.h" -const char* const METHOD_TYPE_NATIVE="native"; -const char* const METHOD_TYPE_PARSER="parser"; +static const String class_type_methoded("methoded"); -const char* const METHOD_CALL_TYPE_STATIC="static"; -const char* const METHOD_CALL_TYPE_DYNAMIC="dynamic"; -const char* const METHOD_CALL_TYPE_ANY="any"; +static const String method_type_native("native"); +static const String method_type_parser("parser"); -const char* const METHOD_MIN_PARAMS="min_params"; -const char* const METHOD_MAX_PARAMS="max_params"; +static const String method_call_type("call_type"); +static const String method_call_type_static("static"); +static const String method_call_type_dynamic("dynamic"); -static const String method_type_native(METHOD_TYPE_NATIVE); -static const String method_type_parser(METHOD_TYPE_PARSER); - -static const String method_call_type_static(METHOD_CALL_TYPE_STATIC); -static const String method_call_type_dynamic(METHOD_CALL_TYPE_DYNAMIC); -static const String method_call_type_any(METHOD_CALL_TYPE_ANY); - -static const String method_min_params(METHOD_MIN_PARAMS); -static const String method_max_params(METHOD_MAX_PARAMS); +static const String method_min_params("min_params"); +static const String method_max_params("max_params"); // class @@ -57,7 +49,7 @@ 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) throw Exception(PARSER_RUNTIME, @@ -104,7 +96,7 @@ static void _create(Request& r, MethodPa VMethodFrame frame(*junction, r.get_method_frame()); - Value* v[100]; + Value* v[100]; if(nparams>0){ for(int i=0; iget_class()) + v=new VString(class_type_methoded); else - throw Exception(PARSER_RUNTIME, - 0, - "class is undefined"); + v=VVoid::get(); + result->put(key, v); +} + +static void _classes(Request& r, MethodParams&) { + VHash& result=*new VHash; + r.classes().for_each(store_vlass_info, result.get_hash()); + r.write_no_lang(result); +} + + +static Value* get_class(Value* value){ + if(VStateless_class* result=value->get_class()) + return result; + else + // classes with fields only, like env & console + return value; +} + +static const String* get_class_name(Value* value){ + if(VStateless_class* lclass=value->get_class()) + return &lclass->name(); + else + // classes with fields only, like env & console + return new String(value->type()); +} + + +static void _class(Request& r, MethodParams& params) { + r.write_no_lang(*get_class(¶ms[0])); } static void _class_name(Request& r, MethodParams& params) { - r.write_no_lang(String(params[0].type())); + r.write_no_lang(*get_class_name(¶ms[0])); } static void _base(Request& r, MethodParams& params) { - if(Value* lclass=params[0].get_class()) - if(Value* base=lclass->base()) - r.write_no_lang(*lclass->base()); - else - r.write_no_lang(*VVoid::get()); - else - throw Exception(PARSER_RUNTIME, - 0, - "class is undefined"); + if(VStateless_class* lclass=params[0].get_class()) + if(Value* base=lclass->base()){ + r.write_no_lang(*get_class(base)); + return; + } + + // classes with fields only, like env & console or without base + r.write_no_lang(*VVoid::get()); } static void _base_name(Request& r, MethodParams& params) { - if(Value* lclass=params[0].get_class()) + if(VStateless_class* lclass=params[0].get_class()) if(Value* base=lclass->base()) - r.write_no_lang(String(base->type())); + r.write_no_lang(*get_class_name(base)); } +struct Store_method_info { + VStateless_class* base_class; + HashStringValue* result; +}; static void store_method_info( - HashString::key_type key, - HashString::value_type method, - HashStringValue* result + HashStringMethod::key_type key, + HashStringMethod::value_type method, + Store_method_info* info ) { - result->put(key, new VString(method->native_code?method_type_native:method_type_parser)); + if(!info->base_class || info->base_class->get_method(String(key, String::L_CLEAN)) != method) + info->result->put(key, new VString(method->native_code?method_type_native:method_type_parser)); } static void _methods(Request& r, MethodParams& params) { @@ -171,15 +198,11 @@ static void _methods(Request& r, MethodP VHash& result=*new VHash; if(VStateless_class* lclass=class_value->get_class()){ - HashString methods=lclass->get_methods(); - methods.for_each(store_method_info, result.get_hash()); -/* + HashStringMethod methods=lclass->get_methods(); + Store_method_info info={lclass->base()?lclass->base()->get_class():0, result.get_hash()}; + methods.for_each(store_method_info, &info); } else { - // exception? - throw Exception(PARSER_RUNTIME, - &class_name, - "class does not have methods"); -*/ + // class which does not have methods (env, console, etc) } r.write_no_lang(result); } @@ -199,7 +222,6 @@ static void _method_params(Request& r, M &class_name, "class does not have methods"); - const String& method_name=params.as_string(1, "method_name must be string"); Method* method=lclass->get_method(method_name); if(!method) @@ -214,19 +236,17 @@ static void _method_params(Request& r, M // 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 if(method->params_names) @@ -242,6 +262,9 @@ MReflection::MReflection(): Methoded("re // ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]] add_native_method("create", Method::CT_STATIC, _create, 2, 102); + // ^reflection:classes[] + add_native_method("classes", Method::CT_STATIC, _classes, 0, 0); + // ^reflection:class[object] add_native_method("class", Method::CT_STATIC, _class, 1, 1); @@ -259,6 +282,4 @@ MReflection::MReflection(): Methoded("re // ^reflection:method_params[class_name;method_name] add_native_method("method_params", Method::CT_STATIC, _method_params, 2, 2); - - // @todo: check how 'create' and 'methods' work with ancestors-classes }