--- parser3/src/classes/reflection.C 2016/09/26 16:29:08 1.55 +++ parser3/src/classes/reflection.C 2016/10/04 13:23:46 1.61 @@ -10,13 +10,14 @@ #include "pa_vbool.h" #include "pa_vobject.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.55 2016/09/26 16:29:08 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.61 2016/10/04 13:23:46 moko Exp $"; static const String class_type_methoded("methoded"); static const String method_type_native("native"); static const String method_type_parser("parser"); +static const String method_name("name"); static const String method_call_type("call_type"); static const String method_inherited("inherited"); static const String method_overridden("overridden"); @@ -94,7 +95,7 @@ static void _create(Request& r, MethodPa Value* v[100]; if(nparams>0){ for(int i=0; i(&self) || dynamic_cast(&self))) throw Exception(PARSER_RUNTIME, 0, "self must be parser object or class"); @@ -221,7 +222,7 @@ static void _method(Request& r, MethodPa if(VStateless_class* vclass=source.get_class()) { if(Method* method=vclass->get_method(name)){ - r.write_no_lang( params.count()>2 ? method_junction(params.as_no_junction(2, "self must be object, not junction"), *method, &name) : *method->get_vjunction(source) ); + r.write_no_lang( params.count()>2 ? method_junction(params.as_no_junction(2, "self must be object, not junction"), *method) : *method->get_vjunction(source) ); return; } } @@ -256,24 +257,33 @@ static void _field(Request& r, MethodPar } static void _method_info(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"); + const Method* method; + VStateless_class* vclass=0; - const String& method_name=params.as_string(1, "method_name must be string"); - Method* method=vclass->get_method(method_name); - if(!method) - throw Exception(PARSER_RUNTIME, &method_name, "method not found in class '%s'", vclass->type()); + if(Junction *j=params.get(0)->get_junction()){ + if(!(method=j->method)) + throw Exception(PARSER_RUNTIME, 0, "param must be class name or method junction"); + } else { + const String& class_name=params.as_string(0, "param must be class name or method junction"); + if(!(vclass=r.get_class(class_name))) + throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); + + 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()); + } VHash& result=*new VHash; HashStringValue* hash=result.get_hash(); + hash->put(method_name, new VString(*method->name)); - VStateless_class* c=vclass; 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)) + if(vclass && 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()))); } @@ -363,9 +373,16 @@ 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"); const String& key=params.as_string(1, "field name must be string"); - if(HashStringValue* fields=params[0].get_fields()){ - fields->remove(key); + + if(VObject* o=dynamic_cast(v)){ + o->get_fields()->remove(key); + } else if(VClass* c=dynamic_cast(v)){ + HashStringProperty &p=*c->get_properties(); + if(Property* property=p.get(key)) + if(property->value) + p.remove(key); } } @@ -376,7 +393,7 @@ static void _mixin(Request& r, MethodPar const String *name=0; bool copy_methods=true; bool copy_fields=true; - bool overwrite=true; + bool overwrite=false; if(params.count()>1) if(HashStringValue* options=params.as_hash(1, "mixin options")) { @@ -389,15 +406,15 @@ static void _mixin(Request& r, MethodPar valid_options++; } if(Value* vmethods=options->get("methods")) { - copy_methods=r.process_to_value(*vmethods).as_bool(); + copy_methods=r.process(*vmethods).as_bool(); valid_options++; } if(Value* vfields=options->get("fields")) { - copy_fields=r.process_to_value(*vfields).as_bool(); + copy_fields=r.process(*vfields).as_bool(); valid_options++; } if(Value* voverwrite=options->get("overwrite")) { - overwrite=r.process_to_value(*voverwrite).as_bool(); + overwrite=r.process(*voverwrite).as_bool(); valid_options++; } if(valid_options!=options->count()) @@ -419,22 +436,20 @@ static void _mixin(Request& r, MethodPar if(copy_methods) if(Method* method=source->get_method(*name)) if(overwrite || !target->get_method(*name)){ - target->set_method(*name, method); - return; + target->set_method(*name, new Method(*method)); } if(copy_fields) if(Property* property=source->get_properties()->get(*name)) if(property->value && (overwrite || !target->get_properties()->get(*name))){ target->put_element(*target, *name, property->value); - return; } } else { if(copy_methods) for(HashStringMethod::Iterator i(source->get_methods()); i; i.next()){ if(overwrite || !target->get_method(i.key())) - target->set_method(*new String(i.key(), String::L_TAINTED), i.value()); + target->set_method(*i.value()->name, new Method(*i.value())); } if(copy_fields) for(HashStringProperty::Iterator i(*source->get_properties()); i; i.next()){ @@ -479,7 +494,8 @@ MReflection::MReflection(): Methoded("re add_native_method("method", Method::CT_STATIC, _method, 1, 3); // ^reflection:method_info[class_name;method_name] - add_native_method("method_info", Method::CT_STATIC, _method_info, 2, 2); + // ^reflection:method_info[junction] + add_native_method("method_info", Method::CT_STATIC, _method_info, 1, 2); // ^reflection:fields[object or class] add_native_method("fields", Method::CT_STATIC, _fields, 1, 1);