--- parser3/src/classes/reflection.C 2015/10/26 01:21:54 1.38 +++ parser3/src/classes/reflection.C 2016/11/30 21:30:24 1.71 @@ -8,19 +8,20 @@ #include "pa_vmethod_frame.h" #include "pa_request.h" #include "pa_vbool.h" +#include "pa_vobject.h" -volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.38 2015/10/26 01:21:54 moko Exp $"; +volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.71 2016/11/30 21:30:24 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_class_name("class"); 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,28 +38,23 @@ public: // global variable -DECLARE_CLASS_VAR(reflection, new MReflection, 0); +DECLARE_CLASS_VAR(reflection, new MReflection); // methods static void _create(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); + VStateless_class* vclass=r.get_class(class_name); - if(!class_value) - throw Exception(PARSER_RUNTIME, - &class_name, - "class is undefined"); + if(!vclass) + throw Exception(PARSER_RUNTIME, &class_name, "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); + Value* constructor_value=vclass->get_element(constructor_name); if(!constructor_value || !constructor_value->get_junction()) - throw Exception(PARSER_RUNTIME, - &constructor_name, - "constructor must be declared in class '%s'", - class_value->get_class()->name_cstr()); + throw Exception(PARSER_RUNTIME, &constructor_name, "constructor must be declared in class '%s'", vclass->type()); Junction* junction=constructor_value->get_junction(); const Method* method=junction->method; @@ -67,97 +63,63 @@ static void _create(Request& r, MethodPa int max_params_count; if(method->native_code){ - 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(), - 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(), - class_value->type(), - method->min_numbered_params_count, - nparams); - max_params_count=method->max_numbered_params_count; } else { - max_params_count=method->params_names?method->params_names->count():0; - } - - 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(), - class_value->type(), - max_params_count, - nparams); - - Value &object = r.construct(*class_value, *method); - VConstructorFrame frame(*method, r.get_method_frame(), object); - - Value* v[100]; - if(nparams>0){ - for(int i=0; iparams_count; } - r.op_call(frame); - object.enable_default_setter(); - r.write_pass_lang(frame.result()); -} + Value &object = r.construct(*vclass, *method); -static void store_vlass_info( - HashStringValue::key_type key, - HashStringValue::value_type value, - HashStringValue* result -){ - Value* v; - if(value->get_class()) - v=new VString(class_type_methoded); - else - v=VVoid::get(); - result->put(key, v); + CONSTRUCTOR_FRAME_ACTION(*method, r.get_method_frame(), object, { + Value* v[100]; + if(nparams>0){ + for(int i=0; i::Iterator i(r.classes()); i; i.next()){ + result.hash().put(i.key(), i.value()->get_methods().count()>0 ? new VString(class_type_methoded) : VVoid::get() ); + } + r.write(result); } -static Value* get_class(Value* value){ - if(VStateless_class* result=value->get_class()) - return result; - else - // classes with fields only, like env & console +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* lclass=value->get_class()) - return &lclass->name(); - else - // classes with fields only, like env & console - 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(get_class(params[0])); } static void _class_name(Request& r, MethodParams& params) { - r.write_no_lang(*get_class_name(¶ms[0])); + r.write(get_class_name(params[0])); } static void _class_by_name(Request& r, MethodParams& params) { @@ -165,40 +127,33 @@ static void _class_by_name(Request& r, M 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); + r.write(*class_value); } static void _base(Request& r, MethodParams& params) { - if(VStateless_class* lclass=params[0].get_class()) - if(Value* base=lclass->base()){ - r.write_no_lang(*get_class(base)); + if(VStateless_class* vclass=params[0].get_class()) + if(Value* base=vclass->base()){ + r.write(get_class(*base)); return; } // classes with fields only, like env & console or without base - r.write_no_lang(*VVoid::get()); + r.write_value(*VVoid::get()); } static void _base_name(Request& r, MethodParams& params) { - if(VStateless_class* lclass=params[0].get_class()) - if(Value* base=lclass->base()) - r.write_no_lang(*get_class_name(base)); -} - -static void store_method_info( - HashStringMethod::key_type key, - HashStringMethod::value_type method, - HashStringValue* result -) { - result->put(key, new VString(method->native_code?method_type_native:method_type_parser)); + if(VStateless_class* vclass=params[0].get_class()) + if(Value* base=vclass->base()) + r.write(get_class_name(*base)); } 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)); + // can't use get_class because it will call @autouse[] if the class wasn't loaded + r.write(VBool::get(r.classes().get(name)!=0)); } else { throw Exception(PARSER_RUNTIME, &type, "is invalid type, must be '%s'", def_class.cstr()); } @@ -206,42 +161,70 @@ static void _def(Request& r, MethodParam 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); - if(!class_value) - throw Exception(PARSER_RUNTIME, - &class_name, - "class is undefined"); + VStateless_class* vclass=r.get_class(class_name); + if(!vclass) + throw Exception(PARSER_RUNTIME, &class_name, "class is undefined"); VHash& result=*new VHash; - if(VStateless_class* lclass=class_value->get_class()) { - HashStringMethod methods=lclass->get_methods(); - methods.for_each(store_method_info, result.get_hash()); - } else { - // class which does not have methods (env, console, etc) + for(HashStringMethod::Iterator i(vclass->get_methods()); i; i.next()){ + result.hash().put(i.key(), new VString(i.value()->native_code ? method_type_native : method_type_parser)); } - r.write_no_lang(result); + + r.write(result); +} + +static VJunction &method_junction(Value &self, Method &method){ + if(method.native_code) + 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"); + + return *method.get_vjunction(self); } static void _method(Request& r, MethodParams& params) { - Value& o=params.as_no_junction(0, "first param must be object or class, not junction"); + Value &source=params[0]; + + if(Junction *j=source.get_junction()){ + if(Method* method=const_cast(j->method)){ + Value& self=params.count()>1 ? params.as_no_junction(1, "self must be object, not junction") : r.get_method_frame()->caller()->self(); + r.write(method_junction(self, *method)); + return; + } + throw Exception(PARSER_RUNTIME, 0, "param must be method junction"); + } + + if(params.count()==1) + throw Exception(PARSER_RUNTIME, 0, "method name must be specified"); + 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) + if(VStateless_class* vclass=source.get_class()) { + if(Method* method=vclass->get_method(name)){ + r.write( params.count()>2 ? method_junction(params.as_no_junction(2, "self must be object, not junction"), *method) : *method->get_vjunction(source) ); + return; + } } + r.write_value(*VVoid::get()); } static void _fields(Request& r, MethodParams& params) { 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()); + if(HashStringValue* fields=o.get_fields()) + r.write(*new VHash(*fields)); + else + r.write(*new VHash()); +} + +static void _fields_reference(Request& r, MethodParams& params) { + Value& o=params.as_no_junction(0, "param must be object or hash, not junction"); + + if(HashStringValue* fields=o.get_fields_reference()) + r.write(*new VHashReference(*fields)); + else + throw Exception(PARSER_RUNTIME, 0, "param must be object or hash"); } static void _field(Request& r, MethodParams& params) { @@ -250,50 +233,52 @@ static void _field(Request& r, MethodPar if(HashStringValue* fields=o.get_fields()) if(Value* value=fields->get(name)) - r.write_no_lang(*value); + r.write(*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); - if(!class_value) - throw Exception(PARSER_RUNTIME, - &class_name, - "class is undefined"); - - VStateless_class* lclass=class_value->get_class(); - if(!lclass) - throw Exception(PARSER_RUNTIME, - &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) - throw Exception(PARSER_RUNTIME, - &method_name, - "method not found in class %s", - class_name.cstr()); + const Method* method; VHash& result=*new VHash; HashStringValue* hash=result.get_hash(); - VStateless_class* c=lclass; - 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)) - c=c->base()->get_class(); - hash->put((base_method==method) ? method_inherited : method_overridden, new VString(c->name())); + if(Junction *j=params[0].get_junction()){ + if(!(method=j->method)) + throw Exception(PARSER_RUNTIME, 0, "param must be class name or method junction"); + + hash->put(method_name, new VString(*method->name)); + hash->put(method_class_name, new VString(*new String(j->self.type()))); + + } else { + const String& class_name=params.as_string(0, "param must be class name or method junction"); + VStateless_class* vclass=r.get_class(class_name); + + if(!vclass) + 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()); + + Method* base_method; + 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()))); + } } 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; @@ -307,7 +292,7 @@ static void _method_info(Request& r, Met hash->put(method_max_params, new VInt(method->max_numbered_params_count)); } else { // parser code - const String* filespec = r.get_method_filename(method); + const String* filespec = r.get_method_filespec(method); if( filespec ) hash->put("file", new VString(*filespec)); @@ -321,39 +306,55 @@ static void _method_info(Request& r, Met hash->put(method_extra_param, new VString(*method->extra_params)); } - r.write_no_lang(result); + r.write(result); +} + +static void _filename(Request& r, MethodParams& params) { + if(Junction *j=params[0].get_junction()){ + if(const Method* method=j->method){ + if(!method->native_code) + if(const String* filespec = r.get_method_filespec(method)) + r.write(*new VString(*filespec)); + return; + } + throw Exception(PARSER_RUNTIME, 0, "param must be object, class or method junction"); + } + + if(VClass* vclass = dynamic_cast(params[0].get_class())){ + r.write(*new VString(vclass->get_filespec())); + } } static void _dynamical(Request& r, MethodParams& params) { if(params.count()){ - r.write_no_lang(VBool::get(params[0].get_class() != ¶ms[0])); + r.write(VBool::get(params[0].get_class() != ¶ms[0])); } else { VMethodFrame* caller=r.get_method_frame()->caller(); - r.write_no_lang(VBool::get(caller && caller->get_class() != &caller->self())); + r.write(VBool::get(caller && caller->get_class() != &caller->self())); } } static void _is(Request& r, MethodParams& params) { - const String& type=params.as_string(0, "class name must be string"); - const String& name=params.as_string(params.count()-1, "element name must be string"); - Value *context=params.count()==3 ? &(params.as_no_junction(1, "context must not be code")) : r.get_method_frame()->caller(); + 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"))) ); + r.write(VBool::get(junction && ((junction->code==0) ^ (type == "code"))) ); } else { - r.write_no_lang(VBool::get( value->is(type.cstr()) )); + r.write(VBool::get( value->is(type.cstr()) )); } } else - r.write_no_lang(VBool::get(type == "void")); + r.write(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(); - if(src==NULL) + if(src==NULL) throw Exception(PARSER_RUNTIME, 0, "source must have hash representation"); Value& dst=params.as_no_junction(1, "destination must not be code"); @@ -368,13 +369,93 @@ 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(String::C(pa_strdup(local_buf, (size_t)size), size))); + r.write(*new String(String::C(pa_strdup(local_buf, (size_t)size), size))); } 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); + } } } @@ -408,22 +489,30 @@ 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] - add_native_method("method", Method::CT_STATIC, _method, 2, 2); + // ^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:filename[object or class] + add_native_method("filename", Method::CT_STATIC, _filename, 1, 1); // ^reflection:fields[object or class] add_native_method("fields", Method::CT_STATIC, _fields, 1, 1); + // ^reflection:fields_reference[object] + add_native_method("fields_reference", Method::CT_STATIC, _fields_reference, 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); - // ^reflection:is[class_name|code|method;[context;]element_name] + // ^reflection:is[element_name;class_name|code|method[;context]] add_native_method("is", Method::CT_STATIC, _is, 2, 3); // ^reflection:copy[src;dst] @@ -434,4 +523,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); + }