--- parser3/src/classes/reflection.C	2016/09/27 21:11:18	1.58
+++ 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.58 2016/09/27 21:11:18 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<nparams; i++)
-			v[i]=&r.process_to_value(params[i+2]);
+			v[i]=&r.process(params[i+2]);
 		frame.store_params((Value**)&v, nparams);
 	} else {
 		frame.empty_params();
@@ -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())));
 	}
@@ -383,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")) {
@@ -396,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())
@@ -426,7 +436,7 @@ 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);
+					target->set_method(*name, new Method(*method));
 				}
 
 		if(copy_fields)
@@ -439,7 +449,7 @@ static void _mixin(Request& r, MethodPar
 		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, 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()){
@@ -484,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);