Annotation of parser3/src/classes/reflection.C, revision 1.36
1.1 misha 1: /** @file
2: Parser: @b reflection parser class.
3:
1.24 moko 4: Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
1.1 misha 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
6: */
7:
8: #include "pa_vmethod_frame.h"
9: #include "pa_request.h"
10: #include "pa_vbool.h"
11:
1.36 ! moko 12: volatile const char * IDENT_REFLECTION_C="$Id: reflection.C,v 1.35 2015/10/25 22:24:05 moko Exp $";
1.24 moko 13:
1.3 misha 14: static const String class_type_methoded("methoded");
1.2 misha 15:
1.3 misha 16: static const String method_type_native("native");
17: static const String method_type_parser("parser");
1.2 misha 18:
1.5 misha 19: static const String method_call_type("call_type");
1.8 misha 20: static const String method_inherited("inherited");
1.23 misha 21: static const String method_overridden("overridden");
1.3 misha 22: static const String method_call_type_static("static");
23: static const String method_call_type_dynamic("dynamic");
1.2 misha 24:
1.3 misha 25: static const String method_min_params("min_params");
26: static const String method_max_params("max_params");
1.29 misha 27: static const String method_extra_param("extra_param");
1.2 misha 28:
1.30 misha 29: static const String def_class("class");
30:
1.1 misha 31: // class
32:
33: class MReflection: public Methoded {
34: public:
35: MReflection();
36: };
37:
38: // global variable
39:
40: DECLARE_CLASS_VAR(reflection, new MReflection, 0);
41:
42: // methods
43:
1.2 misha 44:
45: static void _create(Request& r, MethodParams& params) {
1.1 misha 46: const String& class_name=params.as_string(0, "class_name must be string");
1.11 misha 47: Value* class_value=r.get_class(class_name);
1.1 misha 48:
49: if(!class_value)
50: throw Exception(PARSER_RUNTIME,
51: &class_name,
52: "class is undefined");
53:
54: const String& constructor_name=params.as_string(1, "constructor_name must be string");
1.6 misha 55: Value* constructor_value=class_value->get_element(constructor_name);
1.1 misha 56:
1.10 misha 57: if(!constructor_value || !constructor_value->get_junction())
1.1 misha 58: throw Exception(PARSER_RUNTIME,
59: &constructor_name,
60: "constructor must be declared in class '%s'",
1.2 misha 61: class_value->get_class()->name_cstr());
1.1 misha 62:
63: Junction* junction=constructor_value->get_junction();
1.2 misha 64: const Method* method=junction->method;
65:
66: int nparams=params.count()-2;
67: int max_params_count;
68:
69: if(method->native_code){
70: if(method->call_type==Method::CT_STATIC)
71: throw Exception(PARSER_RUNTIME,
72: &constructor_name,
73: "native method of class '%s' (%s) is not allowed to be called dynamically",
74: class_value->get_class()->name_cstr(),
75: class_value->type());
76:
77: if(nparams<method->min_numbered_params_count)
78: throw Exception(PARSER_RUNTIME,
79: &constructor_name,
80: "native method of class '%s' (%s) accepts minimum %d parameter(s) (%d passed)",
81: class_value->get_class()->name_cstr(),
82: class_value->type(),
83: method->min_numbered_params_count,
84: nparams);
85:
86: max_params_count=method->max_numbered_params_count;
87: } else {
1.12 misha 88: max_params_count=method->params_names?method->params_names->count():0;
1.2 misha 89: }
90:
91: if(nparams>max_params_count)
92: throw Exception(PARSER_RUNTIME,
93: &constructor_name,
94: "method of class '%s' (%s) accepts maximum %d parameter(s) (%d passed)",
95: class_value->get_class()->name_cstr(),
96: class_value->type(),
97: max_params_count,
98: nparams);
1.1 misha 99:
1.17 moko 100: Value &object = r.construct(*class_value, *method);
101: VConstructorFrame frame(*method, r.get_method_frame(), object);
1.1 misha 102:
1.3 misha 103: Value* v[100];
1.1 misha 104: if(nparams>0){
1.2 misha 105: for(int i=0; i<nparams; i++)
1.1 misha 106: v[i]=&r.process_to_value(params[i+2]);
107: frame.store_params((Value**)&v, nparams);
108: } else {
109: frame.empty_params();
110: }
1.17 moko 111: r.op_call(frame);
1.18 moko 112: object.enable_default_setter();
1.21 moko 113: r.write_pass_lang(frame.result());
1.1 misha 114: }
115:
1.2 misha 116:
1.3 misha 117: static void store_vlass_info(
118: HashStringValue::key_type key,
119: HashStringValue::value_type value,
120: HashStringValue* result
121: ){
122: Value* v;
123: if(value->get_class())
124: v=new VString(class_type_methoded);
125: else
126: v=VVoid::get();
127: result->put(key, v);
128: }
129:
130: static void _classes(Request& r, MethodParams&) {
131: VHash& result=*new VHash;
132: r.classes().for_each(store_vlass_info, result.get_hash());
133: r.write_no_lang(result);
134: }
135:
136:
137: static Value* get_class(Value* value){
138: if(VStateless_class* result=value->get_class())
139: return result;
140: else
141: // classes with fields only, like env & console
142: return value;
143: }
144:
145: static const String* get_class_name(Value* value){
146: if(VStateless_class* lclass=value->get_class())
147: return &lclass->name();
148: else
149: // classes with fields only, like env & console
150: return new String(value->type());
151: }
152:
153:
1.1 misha 154: static void _class(Request& r, MethodParams& params) {
1.3 misha 155: r.write_no_lang(*get_class(¶ms[0]));
1.1 misha 156: }
157:
1.2 misha 158:
1.1 misha 159: static void _class_name(Request& r, MethodParams& params) {
1.3 misha 160: r.write_no_lang(*get_class_name(¶ms[0]));
1.1 misha 161: }
162:
1.34 moko 163: static void _class_by_name(Request& r, MethodParams& params) {
164: const String& class_name=params.as_string(0, "class_name must be string");
165: Value* class_value=r.get_class(class_name);
166: if(!class_value)
167: throw Exception(PARSER_RUNTIME, &class_name, "class is undefined");
168: r.write_no_lang(*class_value);
169: }
1.1 misha 170:
1.2 misha 171: static void _base(Request& r, MethodParams& params) {
1.3 misha 172: if(VStateless_class* lclass=params[0].get_class())
173: if(Value* base=lclass->base()){
174: r.write_no_lang(*get_class(base));
175: return;
176: }
177:
178: // classes with fields only, like env & console or without base
179: r.write_no_lang(*VVoid::get());
1.2 misha 180: }
1.1 misha 181:
182:
1.2 misha 183: static void _base_name(Request& r, MethodParams& params) {
1.3 misha 184: if(VStateless_class* lclass=params[0].get_class())
1.2 misha 185: if(Value* base=lclass->base())
1.3 misha 186: r.write_no_lang(*get_class_name(base));
1.2 misha 187: }
1.1 misha 188:
1.2 misha 189: static void store_method_info(
1.7 misha 190: HashStringMethod::key_type key,
191: HashStringMethod::value_type method,
1.8 misha 192: HashStringValue* result
1.2 misha 193: ) {
1.8 misha 194: result->put(key, new VString(method->native_code?method_type_native:method_type_parser));
1.1 misha 195: }
196:
1.30 misha 197: static void _def(Request& r, MethodParams& params) {
198: const String& type=params.as_string(0, "type must be string");
199: if(type == def_class) {
200: const String& name=params.as_string(1, "name must be string");
201: r.write_no_lang(VBool::get(r.get_class(name)!=0));
202: } else {
1.31 misha 203: throw Exception(PARSER_RUNTIME, &type, "is invalid type, must be '%s'", def_class.cstr());
1.30 misha 204: }
205: }
206:
1.1 misha 207: static void _methods(Request& r, MethodParams& params) {
208: const String& class_name=params.as_string(0, "class_name must be string");
1.11 misha 209: Value* class_value=r.get_class(class_name);
1.1 misha 210: if(!class_value)
211: throw Exception(PARSER_RUNTIME,
212: &class_name,
213: "class is undefined");
214:
215: VHash& result=*new VHash;
1.28 misha 216: if(VStateless_class* lclass=class_value->get_class()) {
1.7 misha 217: HashStringMethod methods=lclass->get_methods();
1.8 misha 218: methods.for_each(store_method_info, result.get_hash());
1.1 misha 219: } else {
1.3 misha 220: // class which does not have methods (env, console, etc)
1.1 misha 221: }
222: r.write_no_lang(result);
223: }
224:
1.28 misha 225: static void _method(Request& r, MethodParams& params) {
226: Value& o=params.as_no_junction(0, "first param must be object or class, not junction");
227: const String& name=params.as_string(1, "method name must be string");
228:
229: if(VStateless_class* lclass=o.get_class()) {
230: if(Method* method=lclass->get_method(name))
231: r.write_no_lang(*method->get_vjunction(o));
232: } else {
233: // class which does not have methods (env, console, etc)
234: }
235: }
236:
1.13 misha 237: static void _fields(Request& r, MethodParams& params) {
1.28 misha 238: Value& o=params.as_no_junction(0, "param must be object or class, not junction");
239:
240: if(HashStringValue* fields=o.get_fields()) {
1.13 misha 241: VHash& result=*new VHash(*fields);
242: r.write_no_lang(result);
243: } else
244: r.write_no_lang(*new VHash());
245: }
1.2 misha 246:
1.28 misha 247: static void _field(Request& r, MethodParams& params) {
248: Value& o=params.as_no_junction(0, "first param must be object or class, not junction");
249: const String& name=params.as_string(1, "field name must be string");
250:
251: if(HashStringValue* fields=o.get_fields())
252: if(Value* value=fields->get(name))
253: r.write_no_lang(*value);
254: }
255:
1.8 misha 256: static void _method_info(Request& r, MethodParams& params) {
1.2 misha 257: const String& class_name=params.as_string(0, "class_name must be string");
1.11 misha 258: Value* class_value=r.get_class(class_name);
1.2 misha 259: if(!class_value)
260: throw Exception(PARSER_RUNTIME,
261: &class_name,
262: "class is undefined");
263:
264: VStateless_class* lclass=class_value->get_class();
265: if(!lclass)
266: throw Exception(PARSER_RUNTIME,
267: &class_name,
268: "class does not have methods");
269:
270: const String& method_name=params.as_string(1, "method_name must be string");
271: Method* method=lclass->get_method(method_name);
272: if(!method)
273: throw Exception(PARSER_RUNTIME,
274: &method_name,
275: "method not found in class %s",
276: class_name.cstr());
277:
278: VHash& result=*new VHash;
279: HashStringValue* hash=result.get_hash();
1.8 misha 280:
281: VStateless_class* c=lclass;
1.23 misha 282: Method* base_method;
283: if(c->base() && (base_method=c->base()->get_method(method_name))){
1.8 misha 284: c=c->base()->get_class();
1.23 misha 285: while(c->base() && base_method==c->base()->get_method(method_name))
286: c=c->base()->get_class();
287: hash->put((base_method==method) ? method_inherited : method_overridden, new VString(c->name()));
288: }
1.8 misha 289:
1.29 misha 290: Value* call_type=0;
291: switch(method->call_type){
292: case Method::CT_DYNAMIC:
293: call_type=new VString(method_call_type_dynamic);
294: break;
295: case Method::CT_STATIC:
296: call_type=new VString(method_call_type_static);
297: break;
1.32 moko 298: case Method::CT_ANY:
299: break;
1.29 misha 300: }
301: if(call_type)
302: hash->put(method_call_type, call_type);
303:
1.2 misha 304: if(method->native_code){
305: // native code
306: hash->put(method_min_params, new VInt(method->min_numbered_params_count));
307: hash->put(method_max_params, new VInt(method->max_numbered_params_count));
308: } else {
309: // parser code
1.16 misha 310: const String* filespec = r.get_method_filename(method);
311: if( filespec )
312: hash->put("file", new VString(*filespec));
1.29 misha 313:
314: hash->put(method_max_params, new VInt(method->params_names ? method->params_names->count() : 0));
315:
1.2 misha 316: if(method->params_names)
317: for(size_t i=0; i<method->params_names->count(); i++)
318: hash->put(String::Body::Format(i), new VString(*method->params_names->get(i)));
1.29 misha 319:
320: if(method->extra_params)
321: hash->put(method_extra_param, new VString(*method->extra_params));
1.2 misha 322: }
323:
324: r.write_no_lang(result);
325: }
326:
1.9 misha 327: static void _dynamical(Request& r, MethodParams& params) {
328: if(params.count()){
329: r.write_no_lang(VBool::get(params[0].get_class() != ¶ms[0]));
330: } else {
331: VMethodFrame* caller=r.get_method_frame()->caller();
332: r.write_no_lang(VBool::get(caller && caller->get_class() != &caller->self()));
333: }
334: }
335:
1.35 moko 336: static void _is(Request& r, MethodParams& params) {
337: const String& type=params.as_string(0, "class name must be string");
338: const String& name=params.as_string(params.count()-1, "element name must be string");
339: Value &context=params.count()==3 ? params.as_no_junction(1, "context must not be code") : *(r.get_method_frame()->caller());
340: Value *value=context.get_element(name);
341:
342: if(value) {
343: if(type == "code" || type == "method") {
344: Junction *junction=value->get_junction();
345: r.write_no_lang(VBool::get(junction && ((junction->code==0) ^ (type == "code"))) );
346: } else {
347: r.write_no_lang(VBool::get( value->is(type.cstr()) ));
348: }
349: } else
1.36 ! moko 350: r.write_no_lang(VBool::get(type == "void"));
1.35 moko 351: }
352:
1.19 moko 353: static void _copy(Request& r, MethodParams& params) {
354: HashStringValue* src=params.as_no_junction(0, "source must not be code").get_hash();
355:
356: if(src==NULL)
357: throw Exception(PARSER_RUNTIME, 0, "source must have hash representation");
358:
359: Value& dst=params.as_no_junction(1, "destination must not be code");
360:
361: for(HashStringValue::Iterator i(*src); i; i.next())
1.20 moko 362: r.put_element(dst, *new String(i.key(), String::L_TAINTED), i.value());
1.19 moko 363: }
364:
1.25 moko 365: static void _uid(Request& r, MethodParams& params) {
366: Value& obj=params.as_no_junction(0, "object must not be code");
367:
368: char local_buf[MAX_NUMBER];
369: int size=snprintf(local_buf, sizeof(local_buf), "%p", &obj);
370:
1.33 moko 371: r.write_pass_lang(*new String(String::C(pa_strdup(local_buf, (size_t)size), size)));
1.25 moko 372: }
373:
1.27 moko 374: static void _delete(Request&, MethodParams& params) {
1.26 misha 375: const String& key=params.as_string(1, "field name must be string");
376: if(HashStringValue* fields=params[0].get_fields()){
377: fields->remove(key);
378: }
379: }
380:
381:
1.1 misha 382: // constructor
383: MReflection::MReflection(): Methoded("reflection") {
1.2 misha 384: // ^reflection:create[class_name;constructor_name[;param1[;param2[;...]]]]
385: add_native_method("create", Method::CT_STATIC, _create, 2, 102);
1.1 misha 386:
1.3 misha 387: // ^reflection:classes[]
388: add_native_method("classes", Method::CT_STATIC, _classes, 0, 0);
389:
1.1 misha 390: // ^reflection:class[object]
391: add_native_method("class", Method::CT_STATIC, _class, 1, 1);
392:
393: // ^reflection:class_name[object]
394: add_native_method("class_name", Method::CT_STATIC, _class_name, 1, 1);
395:
1.34 moko 396: // ^reflection:class_by_name[class_name]
397: add_native_method("class_by_name", Method::CT_STATIC, _class_by_name, 1, 1);
398:
1.2 misha 399: // ^reflection:base_class[object]
400: add_native_method("base", Method::CT_STATIC, _base, 1, 1);
401:
402: // ^reflection:base_class_name[object]
403: add_native_method("base_name", Method::CT_STATIC, _base_name, 1, 1);
404:
1.30 misha 405: // ^reflection:def[class|...;name]
406: add_native_method("def", Method::CT_STATIC, _def, 2, 2);
407:
1.2 misha 408: // ^reflection:methods[class_name]
1.1 misha 409: add_native_method("methods", Method::CT_STATIC, _methods, 1, 1);
1.2 misha 410:
1.28 misha 411: // ^reflection:method[object or class;method_name]
412: add_native_method("method", Method::CT_STATIC, _method, 2, 2);
413:
414: // ^reflection:method_info[class_name;method_name]
415: add_native_method("method_info", Method::CT_STATIC, _method_info, 2, 2);
416:
1.13 misha 417: // ^reflection:fields[object or class]
418: add_native_method("fields", Method::CT_STATIC, _fields, 1, 1);
419:
1.28 misha 420: // ^reflection:field[object or class;field_name]
421: add_native_method("field", Method::CT_STATIC, _field, 2, 2);
1.9 misha 422:
423: // ^reflection:dynamical[[object or class, caller if absent]]
424: add_native_method("dynamical", Method::CT_STATIC, _dynamical, 0, 1);
1.19 moko 425:
1.35 moko 426: // ^reflection:is[class_name|code|method;[context;]element_name]
427: add_native_method("is", Method::CT_STATIC, _is, 2, 3);
428:
1.19 moko 429: // ^reflection:copy[src;dst]
430: add_native_method("copy", Method::CT_STATIC, _copy, 2, 2);
1.25 moko 431:
432: // ^reflection:uid[object or class]
433: add_native_method("uid", Method::CT_STATIC, _uid, 1, 1);
1.26 misha 434:
435: // ^reflection:delete[object or class;field_name]
436: add_native_method("delete", Method::CT_STATIC, _delete, 2, 2);
1.1 misha 437: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reflection.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes