--- parser3/src/classes/reflection.C 2015/10/08 22:49:36 1.33 +++ parser3/src/classes/reflection.C 2016/05/24 15:42:43 1.42 @@ -1,7 +1,7 @@ /** @file Parser: @b reflection parser class. - Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com) + Copyright (c) 2001-2015 Art. Lebedev Studio (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ @@ -9,7 +9,7 @@ #include "pa_request.h" #include "pa_vbool.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.33 2015/10/08 22:49:36 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.42 2016/05/24 15:42:43 moko Exp $"; static const String class_type_methoded("methoded"); @@ -19,8 +19,6 @@ static const String method_type_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_min_params("min_params"); static const String method_max_params("max_params"); @@ -37,7 +35,7 @@ public: // global variable -DECLARE_CLASS_VAR(reflection, new MReflection, 0); +DECLARE_CLASS_VAR(reflection, new MReflection); // methods @@ -58,7 +56,7 @@ static void _create(Request& r, MethodPa throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", - class_value->get_class()->name_cstr()); + class_value->type()); Junction* junction=constructor_value->get_junction(); const Method* method=junction->method; @@ -70,15 +68,13 @@ static void _create(Request& r, MethodPa if(method->call_type==Method::CT_STATIC) throw Exception(PARSER_RUNTIME, &constructor_name, - "native method of class '%s' (%s) is not allowed to be called dynamically", - class_value->get_class()->name_cstr(), + "native method of class '%s' is not allowed to be called dynamically", class_value->type()); if(nparamsmin_numbered_params_count) throw Exception(PARSER_RUNTIME, &constructor_name, - "native method of class '%s' (%s) accepts minimum %d parameter(s) (%d passed)", - class_value->get_class()->name_cstr(), + "native method of class '%s' accepts minimum %d parameter(s) (%d passed)", class_value->type(), method->min_numbered_params_count, nparams); @@ -91,8 +87,7 @@ static void _create(Request& r, MethodPa if(nparams>max_params_count) throw Exception(PARSER_RUNTIME, &constructor_name, - "method of class '%s' (%s) accepts maximum %d parameter(s) (%d passed)", - class_value->get_class()->name_cstr(), + "method of class '%s' accepts maximum %d parameter(s) (%d passed)", class_value->type(), max_params_count, nparams); @@ -144,7 +139,7 @@ static Value* get_class(Value* value){ static const String* get_class_name(Value* value){ if(VStateless_class* lclass=value->get_class()) - return &lclass->name(); + return new String(lclass->type()); else // classes with fields only, like env & console return new String(value->type()); @@ -160,6 +155,13 @@ static void _class_name(Request& r, Meth r.write_no_lang(*get_class_name(¶ms[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); +} static void _base(Request& r, MethodParams& params) { if(VStateless_class* lclass=params[0].get_class()) @@ -277,16 +279,16 @@ static void _method_info(Request& r, Met 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())); + hash->put((base_method==method) ? method_inherited : method_overridden, new VString(*new String(c->type()))); } Value* call_type=0; switch(method->call_type){ case Method::CT_DYNAMIC: - call_type=new VString(method_call_type_dynamic); + call_type=new VString(Symbols::DYNAMIC_SYMBOL); break; case Method::CT_STATIC: - call_type=new VString(method_call_type_static); + call_type=new VString(Symbols::STATIC_SYMBOL); break; case Method::CT_ANY: break; @@ -326,6 +328,23 @@ static void _dynamical(Request& r, Metho } } +static void _is(Request& r, MethodParams& params) { + const String& name=params.as_string(0, "element name must be string"); + const String& type=params.as_string(1, "class name must be string"); + Value *context=params.count()==3 ? &(params.as_no_junction(2, "context must not be code")) : r.get_method_frame()->caller(); + Value *value=context ? context->get_element(name) : 0; + + if(value) { + if(type == "code" || type == "method") { + Junction *junction=value->get_junction(); + r.write_no_lang(VBool::get(junction && ((junction->code==0) ^ (type == "code"))) ); + } else { + r.write_no_lang(VBool::get( value->is(type.cstr()) )); + } + } else + r.write_no_lang(VBool::get(type == "void")); +} + static void _copy(Request& r, MethodParams& params) { HashStringValue* src=params.as_no_junction(0, "source must not be code").get_hash(); @@ -369,6 +388,9 @@ MReflection::MReflection(): Methoded("re // ^reflection:class_name[object] add_native_method("class_name", Method::CT_STATIC, _class_name, 1, 1); + // ^reflection:class_by_name[class_name] + add_native_method("class_by_name", Method::CT_STATIC, _class_by_name, 1, 1); + // ^reflection:base_class[object] add_native_method("base", Method::CT_STATIC, _base, 1, 1); @@ -396,6 +418,9 @@ MReflection::MReflection(): Methoded("re // ^reflection:dynamical[[object or class, caller if absent]] add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1); + // ^reflection:is[element_name;class_name|code|method[;context]] + add_native_method("is", Method::CT_STATIC, _is, 2, 3); + // ^reflection:copy[src;dst] add_native_method("copy", Method::CT_STATIC, _copy, 2, 2);