--- parser3/src/classes/reflection.C 2016/09/19 22:27:57 1.52 +++ parser3/src/classes/reflection.C 2016/10/11 21:30:16 1.63 @@ -10,13 +10,14 @@ #include "pa_vbool.h" #include "pa_vobject.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.52 2016/09/19 22:27:57 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.63 2016/10/11 21:30:16 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,12 +95,12 @@ static void _create(Request& r, MethodPa Value* v[100]; if(nparams>0){ for(int i=0; iget_class()) - return result; - else - // junction +static Value& get_class(Value& value){ + if(VStateless_class* result=value.get_class()) + return *result; + else { + // we can't return code junction to outside as it's stack value + if(Junction *j=value.get_junction()) + if(j->code) + throw Exception(PARSER_RUNTIME, 0, "param must not be code junction"); + // method junction return value; + } } -static const String* get_class_name(Value* value){ - if(VStateless_class* vclass=value->get_class()) - return new String(vclass->type()); - else - // junction - return new String(value->type()); +static const String& get_class_name(Value& value){ + return *new String(get_class(value).type()); } static void _class(Request& r, MethodParams& params) { - r.write_no_lang(*get_class(¶ms[0])); + r.write_no_lang(get_class(params[0])); } static void _class_name(Request& r, MethodParams& params) { - r.write_no_lang(*get_class_name(¶ms[0])); + r.write_no_lang(get_class_name(params[0])); } static void _class_by_name(Request& r, MethodParams& params) { @@ -151,7 +153,7 @@ static void _class_by_name(Request& r, M static void _base(Request& r, MethodParams& params) { if(VStateless_class* vclass=params[0].get_class()) if(Value* base=vclass->base()){ - r.write_no_lang(*get_class(base)); + r.write_no_lang(get_class(*base)); return; } @@ -163,7 +165,7 @@ static void _base(Request& r, MethodPara static void _base_name(Request& r, MethodParams& params) { if(VStateless_class* vclass=params[0].get_class()) if(Value* base=vclass->base()) - r.write_no_lang(*get_class_name(base)); + r.write_no_lang(get_class_name(*base)); } static void _def(Request& r, MethodParams& params) { @@ -191,9 +193,9 @@ static void _methods(Request& r, MethodP r.write_no_lang(result); } -static VJunction &method_junction(Value &self, Method &method, const String *name=0){ +static VJunction &method_junction(Value &self, Method &method){ if(method.native_code) - throw Exception(PARSER_RUNTIME, name, "method must not be native"); + throw Exception(PARSER_RUNTIME, method.name, "method must not be native"); if(!(dynamic_cast(&self) || dynamic_cast(&self))) throw Exception(PARSER_RUNTIME, 0, "self must be parser object or class"); @@ -202,7 +204,7 @@ static VJunction &method_junction(Value } static void _method(Request& r, MethodParams& params) { - Value &source=*params.get(0); + Value &source=params[0]; if(Junction *j=source.get_junction()){ if(Method* method=const_cast(j->method)){ @@ -220,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; } } @@ -255,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[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()))); } @@ -362,9 +373,89 @@ 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); + } +} + +static void _mixin(Request& r, MethodParams& params) { + Value& vsource=params.as_no_junction(0, "source must not be code"); + + Value* vtarget=0; + const String *name=0; + bool copy_methods=true; + bool copy_fields=true; + bool overwrite=false; + + if(params.count()>1) + if(HashStringValue* options=params.as_hash(1, "mixin options")) { + int valid_options=0; + if(vtarget=options->get("to")) { + valid_options++; + } + if(Value* vname=options->get("name")) { + name=&vname->as_string(); + valid_options++; + } + if(Value* vmethods=options->get("methods")) { + copy_methods=r.process(*vmethods).as_bool(); + valid_options++; + } + if(Value* vfields=options->get("fields")) { + copy_fields=r.process(*vfields).as_bool(); + valid_options++; + } + if(Value* voverwrite=options->get("overwrite")) { + overwrite=r.process(*voverwrite).as_bool(); + valid_options++; + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + } + + if(!vtarget) + vtarget=&r.get_method_frame()->caller()->self(); + + VClass* source=dynamic_cast(vsource.get_class()); + VClass* target=dynamic_cast(vtarget->get_class()); + + if(!source) + throw Exception(PARSER_RUNTIME, 0, "source must be parser object or class"); + if(!target) + throw Exception(PARSER_RUNTIME, 0, "destination must be parser object or class"); + + if(name){ + if(copy_methods) + if(Method* method=source->get_method(*name)) + if(overwrite || !target->get_method(*name)){ + 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); + } + + } else { + if(copy_methods) + for(HashStringMethod::Iterator i(source->get_methods()); i; i.next()){ + if(overwrite || !target->get_method(i.key())) + target->set_method(*i.value()->name, new Method(*i.value())); + } + if(copy_fields) + for(HashStringProperty::Iterator i(*source->get_properties()); i; i.next()){ + if(i.value()->value && ( overwrite || !target->get_properties()->get(i.key()) )) + target->put_element(*target, *new String(i.key(), String::L_TAINTED), i.value()->value); + } } } @@ -398,11 +489,13 @@ MReflection::MReflection(): Methoded("re // ^reflection:methods[class_name] add_native_method("methods", Method::CT_STATIC, _methods, 1, 1); - // ^reflection:method[object or class;method_name] + // ^reflection:method[object or class;method_name[;self]] + // ^reflection:method[junction[;self]] 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); @@ -427,4 +520,8 @@ MReflection::MReflection(): Methoded("re // ^reflection:delete[object or class;field_name] add_native_method("delete", Method::CT_STATIC, _delete, 2, 2); + + // ^reflection:mixin[object or class or junction;options] + add_native_method("mixin", Method::CT_STATIC, _mixin, 1, 2); + }