parser3/src/classes/reflection.C - diff

Return to reflection.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/reflection.C between versions 1.15 and 1.25

version 1.15, 2010/05/20 04:37:50	version 1.25, 2012/05/19 20:44:57
Line 1	Line 1
/** @file	/** @file
Parser: @b reflection parser class.	Parser: @b reflection parser class.

Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

static const char * const IDENT_REFLECTION_C="$Date$";

#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vbool.h"	#include "pa_vbool.h"

	volatile const char * IDENT_REFLECTION_C="$Id$";

static const String class_type_methoded("methoded");	static const String class_type_methoded("methoded");

static const String method_type_native("native");	static const String method_type_native("native");
Line 18 static const String method_type_parser("	Line 18 static const String method_type_parser("

static const String method_call_type("call_type");	static const String method_call_type("call_type");
static const String method_inherited("inherited");	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_static("static");
static const String method_call_type_dynamic("dynamic");	static const String method_call_type_dynamic("dynamic");

Line 29 static const String method_max_params("m	Line 30 static const String method_max_params("m
class MReflection: public Methoded {	class MReflection: public Methoded {
public:	public:
MReflection();	MReflection();
public: // Methoded
bool used_directly() { return true; }
};	};

// global variable	// global variable
Line 95 static void _create(Request& r, MethodPa	Line 94 static void _create(Request& r, MethodPa
max_params_count,	max_params_count,
nparams);	nparams);

VMethodFrame frame(*junction, r.get_method_frame());	Value &object = r.construct(class_value, method);
	VConstructorFrame frame(*method, r.get_method_frame(), object);

Value* v[100];	Value* v[100];
if(nparams>0){	if(nparams>0){
Line 105 static void _create(Request& r, MethodPa	Line 105 static void _create(Request& r, MethodPa
} else {	} else {
frame.empty_params();	frame.empty_params();
}	}
r.op_call(frame, true/constructing/);	r.op_call(frame);
	object.enable_default_setter();
r.write_pass_lang(frame.result());	r.write_pass_lang(frame.result());
}	}

Line 235 static void _method_info(Request& r, Met	Line 236 static void _method_info(Request& r, Met
HashStringValue* hash=result.get_hash();	HashStringValue* hash=result.get_hash();

VStateless_class* c=lclass;	VStateless_class* c=lclass;
while(c->base() && c->base()->get_method(method_name))	Method* base_method;
	if(c->base() && (base_method=c->base()->get_method(method_name))){
c=c->base()->get_class();	c=c->base()->get_class();
	while(c->base() && base_method==c->base()->get_method(method_name))
if(c!=lclass)	c=c->base()->get_class();
hash->put(method_inherited, new VString(c->name()));	hash->put((base_method==method) ? method_inherited : method_overridden, new VString(c->name()));
	}

if(method->native_code){	if(method->native_code){
// native code	// native code
Line 258 static void _method_info(Request& r, Met	Line 261 static void _method_info(Request& r, Met
hash->put(method_call_type, call_type);	hash->put(method_call_type, call_type);
} else {	} else {
// parser code	// parser code
hash->put("file", new VString(*r.get_method_filename(method)));	const String* filespec = r.get_method_filename(method);
	if( filespec )
	hash->put("file", new VString(*filespec));
if(method->params_names)	if(method->params_names)
for(size_t i=0; i<method->params_names->count(); i++)	for(size_t i=0; i<method->params_names->count(); i++)
hash->put(String::Body::Format(i), new VString(*method->params_names->get(i)));	hash->put(String::Body::Format(i), new VString(*method->params_names->get(i)));
Line 276 static void _dynamical(Request& r, Metho	Line 281 static void _dynamical(Request& r, Metho
}	}
}	}

	static void _copy(Request& r, MethodParams& params) {
	HashStringValue* src=params.as_no_junction(0, "source must not be code").get_hash();

	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");

	for(HashStringValue::Iterator i(*src); i; i.next())
	r.put_element(dst, *new String(i.key(), String::L_TAINTED), i.value());
	}

	static void _uid(Request& r, MethodParams& params) {
	Value& obj=params.as_no_junction(0, "object must not be code");

	char local_buf[MAX_NUMBER];
	int size=snprintf(local_buf, sizeof(local_buf), "%p", &obj);

	r.write_pass_lang(*new String(pa_strdup(local_buf, (size_t)size), String::L_CLEAN, size));
	}

// constructor	// constructor
MReflection::MReflection(): Methoded("reflection") {	MReflection::MReflection(): Methoded("reflection") {
// ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]]	// ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]]
Line 307 MReflection::MReflection(): Methoded("re	Line 333 MReflection::MReflection(): Methoded("re

// ^reflection:dynamical[[object or class, caller if absent]]	// ^reflection:dynamical[[object or class, caller if absent]]
add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1);	add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1);

	// ^reflection:copy[src;dst]
	add_native_method("copy", Method::CT_STATIC, _copy, 2, 2);

	// ^reflection:uid[object or class]
	add_native_method("uid", Method::CT_STATIC, _uid, 1, 1);
}	}

E-mail:

Removed from v.1.15
changed lines
	Added in v.1.25