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.2 and 1.3

version 1.2, 2009/07/26 05:41:54	version 1.3, 2009/07/28 08:03:05
Line 11 static const char * const IDENT_REFLECTI	Line 11 static const char * const IDENT_REFLECTI
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vbool.h"	#include "pa_vbool.h"

const char* const METHOD_TYPE_NATIVE="native";	static const String class_type_methoded("methoded");
const char* const METHOD_TYPE_PARSER="parser";

const char* const METHOD_CALL_TYPE_STATIC="static";	static const String method_type_native("native");
const char* const METHOD_CALL_TYPE_DYNAMIC="dynamic";	static const String method_type_parser("parser");
const char* const METHOD_CALL_TYPE_ANY="any";

const char* const METHOD_MIN_PARAMS="min_params";	static const String method_call_type_static("static");
const char* const METHOD_MAX_PARAMS="max_params";	static const String method_call_type_dynamic("dynamic");
	static const String method_call_type_any("any");

static const String method_type_native(METHOD_TYPE_NATIVE);	static const String method_min_params("min_params");
static const String method_type_parser(METHOD_TYPE_PARSER);	static const String method_max_params("max_params");

static const String method_call_type_static(METHOD_CALL_TYPE_STATIC);
static const String method_call_type_dynamic(METHOD_CALL_TYPE_DYNAMIC);
static const String method_call_type_any(METHOD_CALL_TYPE_ANY);

static const String method_min_params(METHOD_MIN_PARAMS);
static const String method_max_params(METHOD_MAX_PARAMS);

// class	// class

Line 104 static void _create(Request& r, MethodPa	Line 96 static void _create(Request& r, MethodPa

VMethodFrame frame(*junction, r.get_method_frame());	VMethodFrame frame(*junction, r.get_method_frame());

Value* v[100];	Value* v[100];
if(nparams>0){	if(nparams>0){
for(int i=0; i<nparams; i++)	for(int i=0; i<nparams; i++)
v[i]=&r.process_to_value(params[i+2]);	v[i]=&r.process_to_value(params[i+2]);
Line 117 static void _create(Request& r, MethodPa	Line 109 static void _create(Request& r, MethodPa
}	}


// @todo: something wring with native classes (it returns stateless_class)	static void store_vlass_info(
static void _class(Request& r, MethodParams& params) {	HashStringValue::key_type key,
if(Value* lclass=params[0].get_last_derived_class())	HashStringValue::value_type value,
r.write_no_lang(*lclass);	HashStringValue* result
	){
	Value* v;
	if(value->get_class())
	v=new VString(class_type_methoded);
else	else
throw Exception(PARSER_RUNTIME,	v=VVoid::get();
0,	result->put(key, v);
"class is undefined");	}

	static void _classes(Request& r, MethodParams&) {
	VHash& result=*new VHash;
	r.classes().for_each(store_vlass_info, result.get_hash());
	r.write_no_lang(result);
	}


	static Value* get_class(Value* value){
	if(VStateless_class* result=value->get_class())
	return result;
	else
	// classes with fields only, like env & console
	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 void _class(Request& r, MethodParams& params) {
	r.write_no_lang(*get_class(&params[0]));
}	}


static void _class_name(Request& r, MethodParams& params) {	static void _class_name(Request& r, MethodParams& params) {
r.write_no_lang(String(params[0].type()));	r.write_no_lang(*get_class_name(&params[0]));
}	}


static void _base(Request& r, MethodParams& params) {	static void _base(Request& r, MethodParams& params) {
if(Value* lclass=params[0].get_class())	if(VStateless_class* lclass=params[0].get_class())
if(Value* base=lclass->base())	if(Value* base=lclass->base()){
r.write_no_lang(*lclass->base());	r.write_no_lang(*get_class(base));
else	return;
r.write_no_lang(*VVoid::get());	}
else
throw Exception(PARSER_RUNTIME,	// classes with fields only, like env & console or without base
0,	r.write_no_lang(*VVoid::get());
"class is undefined");
}	}


static void _base_name(Request& r, MethodParams& params) {	static void _base_name(Request& r, MethodParams& params) {
if(Value* lclass=params[0].get_class())	if(VStateless_class* lclass=params[0].get_class())
if(Value* base=lclass->base())	if(Value* base=lclass->base())
r.write_no_lang(String(base->type()));	r.write_no_lang(*get_class_name(base));
}	}


Line 173 static void _methods(Request& r, MethodP	Line 195 static void _methods(Request& r, MethodP
if(VStateless_class* lclass=class_value->get_class()){	if(VStateless_class* lclass=class_value->get_class()){
HashString<Method*> methods=lclass->get_methods();	HashString<Method*> methods=lclass->get_methods();
methods.for_each(store_method_info, result.get_hash());	methods.for_each(store_method_info, result.get_hash());
/*
} else {	} else {
// exception?	// class which does not have methods (env, console, etc)
throw Exception(PARSER_RUNTIME,
&class_name,
"class does not have methods");
*/
}	}
r.write_no_lang(result);	r.write_no_lang(result);
}	}
Line 199 static void _method_params(Request& r, M	Line 216 static void _method_params(Request& r, M
&class_name,	&class_name,
"class does not have methods");	"class does not have methods");


const String& method_name=params.as_string(1, "method_name must be string");	const String& method_name=params.as_string(1, "method_name must be string");
Method* method=lclass->get_method(method_name);	Method* method=lclass->get_method(method_name);
if(!method)	if(!method)
Line 242 MReflection::MReflection(): Methoded("re	Line 258 MReflection::MReflection(): Methoded("re
// ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]]	// ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]]
add_native_method("create", Method::CT_STATIC, _create, 2, 102);	add_native_method("create", Method::CT_STATIC, _create, 2, 102);

	// ^reflection:classes[]
	add_native_method("classes", Method::CT_STATIC, _classes, 0, 0);

// ^reflection:class[object]	// ^reflection:class[object]
add_native_method("class", Method::CT_STATIC, _class, 1, 1);	add_native_method("class", Method::CT_STATIC, _class, 1, 1);

Line 259 MReflection::MReflection(): Methoded("re	Line 278 MReflection::MReflection(): Methoded("re

// ^reflection:method_params[class_name;method_name]	// ^reflection:method_params[class_name;method_name]
add_native_method("method_params", Method::CT_STATIC, _method_params, 2, 2);	add_native_method("method_params", Method::CT_STATIC, _method_params, 2, 2);

// @todo: check how 'create' and 'methods' work with ancestors-classes
}	}

E-mail:

Removed from v.1.2
changed lines
	Added in v.1.3