--- parser3/src/classes/reflection.C	2016/09/19 22:27:57	1.52
+++ parser3/src/classes/reflection.C	2016/09/26 16:29:08	1.55
@@ -10,7 +10,7 @@
 #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.55 2016/09/26 16:29:08 moko Exp $";
 
 static const String class_type_methoded("methoded");
 
@@ -114,30 +114,31 @@ static void _classes(Request& r, MethodP
 }
 
 
-static Value* get_class(Value* value){
-	if(VStateless_class* result=value->get_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(&params[0]));
+	r.write_no_lang(get_class(params[0]));
 }
 
 
 static void _class_name(Request& r, MethodParams& params) {
-	r.write_no_lang(*get_class_name(&params[0]));
+	r.write_no_lang(get_class_name(params[0]));
 }
 
 static void _class_by_name(Request& r, MethodParams& params) {
@@ -151,7 +152,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 +164,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) {
@@ -368,6 +369,81 @@ static void _delete(Request&, MethodPara
 	}
 }
 
+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=true;
+
+	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_to_value(*vmethods).as_bool();
+				valid_options++;
+			}
+			if(Value* vfields=options->get("fields")) {
+				copy_fields=r.process_to_value(*vfields).as_bool();
+				valid_options++;
+			}
+			if(Value* voverwrite=options->get("overwrite")) {
+				overwrite=r.process_to_value(*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<VClass*>(vsource.get_class());
+	VClass* target=dynamic_cast<VClass*>(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, method);
+					return;
+				}
+
+		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());
+			}
+		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);
+			}
+	}
+}
+
 
 // constructor
 MReflection::MReflection(): Methoded("reflection") {
@@ -398,7 +474,8 @@ 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]
@@ -427,4 +504,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);
+
 }