Annotation of parser3/src/types/pa_vmethod_frame.h, revision 1.94
1.3 paf 1: /** @file
1.5 paf 2: Parser: @b method_frame write context
1.3 paf 3:
1.90 moko 4: Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
1.22 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.1 paf 6: */
7:
8: #ifndef PA_VMETHOD_FRAME_H
9: #define PA_VMETHOD_FRAME_H
1.28 paf 10:
1.94 ! moko 11: #define IDENT_PA_VMETHOD_FRAME_H "$Id: pa_vmethod_frame.h,v 1.93 2012/06/08 11:44:02 misha Exp $"
1.1 paf 12:
13: #include "pa_wcontext.h"
1.12 parser 14: #include "pa_vvoid.h"
1.1 paf 15: #include "pa_vjunction.h"
16:
1.40 paf 17: // defines
18:
1.42 paf 19: #define CALLER_ELEMENT_NAME "caller"
20: #define SELF_ELEMENT_NAME "self"
1.50 paf 21: #define RESULT_VAR_NAME "result"
1.81 misha 22: extern const String result_var_name, caller_element_name, self_element_name;
1.40 paf 23:
1.46 paf 24: // forwards
25:
26: class Request;
27:
28: /**
29: @b method parameters passed in this array.
30: contains handy typecast ad junction/not junction ensurers
31:
32: */
1.78 misha 33: class MethodParams {
1.46 paf 34: public:
1.78 misha 35: MethodParams() : felements(0), fused(0){}
36:
1.82 misha 37: #ifdef USE_DESTRUCTORS
38: ~MethodParams(){
39: Value **flast=felements+count();
40: for(Value **current=felements;current<flast;current++)
41: if ((*current)->get_junction()!=0)
42: delete *current;
43: }
44: #endif
45:
1.77 misha 46: void store_params(Value **params, size_t count){
1.78 misha 47: felements=params;
1.77 misha 48: fused=count;
49: }
50:
1.78 misha 51: inline size_t count() const { return fused; }
52:
53: inline Value *get(size_t index) const {
54: assert(index<count());
55: return felements[index];
56: }
57:
1.77 misha 58: inline Value& operator[] (size_t index) { return *get(index); }
1.46 paf 59:
60: Value& last() { return *get(count()-1); }
61:
62: /// handy is-value-a-junction ensurer
63: Value& as_junction(int index, const char* msg) {
1.56 paf 64: Value* value=get(index);
65: return as_junction(value, msg, index);
66: }
67: /// handy is-value-a-junction ensurer
68: Value& as_junction(Value* value, const char* msg, int index) {
69: return get_as(value, true, msg, index);
1.46 paf 70: }
71: /// handy value-is-not-a-junction ensurer
72: Value& as_no_junction(int index, const char* msg) {
1.56 paf 73: Value* value=get(index);
74: return as_no_junction(value, msg, index);
75: }
76: /// handy value-is-not-a-junction ensurer
77: Value& as_no_junction(Value* value, const char* msg, int index) {
78: return get_as(value, false, msg, index);
1.46 paf 79: }
1.62 misha 80: /// handy is-value-a-junction ensurer or can be auto-processed
81: Value& as_expression(int index, const char* msg) {
82: Value* value=get(index);
83: if(value->is_evaluated_expr()){
84: return *value;
85: } else {
86: return get_as(value, true, msg, index);
87: }
88: }
1.46 paf 89: /// handy expression auto-processing to double
90: double as_double(int index, const char* msg, Request& r) {
1.56 paf 91: Value* value=get(index);
1.60 paf 92: if(!value->is_evaluated_expr())
1.57 paf 93: value=&get_processed(value, msg, index, r);
94: return value->as_double();
1.46 paf 95: }
96: /// handy expression auto-processing to int
97: int as_int(int index, const char* msg, Request& r) {
1.56 paf 98: Value* value=get(index);
1.60 paf 99: if(!value->is_evaluated_expr())
1.57 paf 100: value=&get_processed(value, msg, index, r);
101: return value->as_int();
1.46 paf 102: }
103: /// handy expression auto-processing to bool
104: bool as_bool(int index, const char* msg, Request& r) {
1.56 paf 105: Value* value=get(index);
1.60 paf 106: if(!value->is_evaluated_expr())
1.59 paf 107: value=&get_processed(value, msg, index, r);
108: return value->as_bool();
1.46 paf 109: }
110: /// handy string ensurer
111: const String& as_string(int index, const char* msg) {
112: return as_no_junction(index, msg).as_string();
113: }
1.93 misha 114: /// handy hash ensurers
115: HashStringValue* as_hash(int index, const char* name=0);
116: /// handy table ensurer
117: Table* as_table(int index, const char* name=0);
118:
1.46 paf 119: private:
120:
1.78 misha 121: Value **felements;
122: size_t fused;
123:
1.46 paf 124: /// handy value-is/not-a-junction ensurer
1.56 paf 125: Value& get_as(Value* value, bool as_junction, const char* msg, int index) {
126: if((value->get_junction()!=0) ^ as_junction)
1.61 misha 127: throw Exception(PARSER_RUNTIME,
1.46 paf 128: 0,
129: "%s (parameter #%d)", msg, 1+index);
130:
1.56 paf 131: return *value;
1.46 paf 132: }
133:
1.56 paf 134: Value& get_processed(Value* value, const char* msg, int index, Request& r);
1.46 paf 135:
136: };
137:
1.4 paf 138: /** Method frame write context
139: accepts values written by method code
140: also handles method parameters and local variables
1.3 paf 141: */
1.46 paf 142: class VMethodFrame: public WContext {
1.63 misha 143: protected:
1.46 paf 144: VMethodFrame *fcaller;
145:
1.83 misha 146: HashString<Value*>* my; /*OR*/ MethodParams fnumbered_params;
1.87 moko 147: Value& fself;
1.46 paf 148:
1.64 misha 149: typedef const VJunction* (VMethodFrame::*put_element_t)(const String& aname, Value* avalue);
150: put_element_t put_element_impl;
1.46 paf 151:
1.1 paf 152: public: // Value
153:
1.46 paf 154: override const char* type() const { return "method_frame"; }
1.20 paf 155:
156: /// VMethodFrame: $result | parent get_string(=accumulated fstring)
1.46 paf 157: override const String* get_string() {
1.20 paf 158: // check the $result value
1.46 paf 159: Value* result=get_result_variable();
1.20 paf 160: // if we have one, return it's string value, else return as usual: accumulated fstring or fvalue
161: return result ? result->get_string() : WContext::get_string();
162: }
163:
1.40 paf 164: /// VMethodFrame: my or self_transparent or $caller
1.84 misha 165: override Value* get_element(const String& aname) {
1.81 misha 166: if(aname==caller_element_name)
1.40 paf 167: return caller();
1.42 paf 168:
1.81 misha 169: if(aname==self_element_name)
1.67 misha 170: return &self();
171:
1.66 misha 172: Value* result;
173: if(my && (result=my->get(aname)))
174: return result;
175:
1.84 misha 176: if(result=self().get_element(aname))
1.66 misha 177: return result;
1.40 paf 178:
179: return 0;
1.1 paf 180: }
181:
1.4 paf 182: /// VMethodFrame: self_transparent
1.46 paf 183: override VStateless_class* get_class() { return self().get_class(); }
1.44 paf 184:
185: /// VMethodFrame: self_transparent
1.85 misha 186: override VStateless_class* base() { return self().base(); }
1.1 paf 187:
1.64 misha 188: /// VMethodFrame: my or self_transparent
1.94 ! moko 189: override const VJunction* put_element(const String& aname, Value* avalue) {
1.64 misha 190: return (this->*put_element_impl)(aname, avalue);
191: }
192:
1.69 misha 193: /// VMethodFrame: appends a fstring to result
194: override void write(const String& astring, String::Language alang) {
1.79 misha 195: #ifdef OPTIMIZE_RESULT
1.87 moko 196: switch (method.result_optimization){
1.79 misha 197: case Method::RO_USE_RESULT:
198: return;
199: case Method::RO_UNKNOWN:
200: if(get_result_variable()){
1.87 moko 201: ((Method *)&method)->result_optimization=Method::RO_USE_RESULT;
1.79 misha 202: return;
203: }
1.69 misha 204: }
1.79 misha 205: #endif
206: WContext::write(astring, alang);
1.69 misha 207: }
208:
1.64 misha 209: private:
210:
211: const VJunction* put_element_local(const String& aname, Value* avalue){
212: set_my_variable(aname, *avalue);
213: return PUT_ELEMENT_REPLACED_ELEMENT;
214: }
215:
216: const VJunction* put_element_global(const String& aname, Value* avalue){
217: if(my && my->put_replaced(aname, avalue))
218: return PUT_ELEMENT_REPLACED_ELEMENT;
1.94 ! moko 219: return self().put_element(aname, avalue);
1.64 misha 220: }
221:
1.30 paf 222: public: // WContext
1.1 paf 223:
1.46 paf 224: override StringOrValue result() {
1.80 misha 225: if(my){
226: // check the $result value
227: Value* result_value=get_result_variable();
228: // if we have one, return it, else return as usual: accumulated fstring or fvalue
229: if(result_value)
230: return StringOrValue(*result_value);
1.79 misha 231: #ifdef OPTIMIZE_RESULT
1.87 moko 232: if(method.result_optimization==Method::RO_USE_RESULT)
1.80 misha 233: return StringOrValue(*VVoid::get());
1.87 moko 234: ((Method *)&method)->result_optimization=Method::RO_USE_WCONTEXT;
1.79 misha 235: #ifdef OPTIMIZE_CALL // nested as CO_WITHOUT_WCONTEXT assumes that $result not used
1.87 moko 236: ((Method *)&method)->call_optimization=Method::CO_WITHOUT_WCONTEXT;
1.79 misha 237: #endif
238: #endif
1.80 misha 239: }
1.79 misha 240: return WContext::result();
1.1 paf 241: }
242:
1.85 misha 243: override void write(Value& avalue) {
244: WContext::write(avalue);
1.46 paf 245: }
246:
1.1 paf 247: public: // usage
248:
1.87 moko 249: VMethodFrame(const Method& amethod, VMethodFrame *acaller, Value& aself);
1.1 paf 250:
1.40 paf 251: VMethodFrame *caller() { return fcaller; }
1.25 paf 252:
1.76 misha 253: #ifdef USE_DESTRUCTORS
1.75 misha 254: ~VMethodFrame(){
255: if(my){
256: delete my;
257: }
258: }
1.76 misha 259: #endif
1.75 misha 260:
1.87 moko 261: Value& self() { return fself; }
1.1 paf 262:
1.77 misha 263: size_t method_params_count() {
264: return method.params_names ? method.params_names->count():0;
1.27 paf 265: }
1.77 misha 266:
267: void store_params(Value **params, size_t count) {
1.92 moko 268: if(my) {
269: size_t param_count=method.params_names ? method.params_names->count():0;
1.89 moko 270: size_t i=0;
271:
272: if(count>param_count){
273: if(method.extra_params){
274: for(; i<param_count; i++) {
275: const String& fname=*(*method.params_names)[i];
276: set_my_variable(fname, *params[i]);
277: }
278:
279: VHash& vargs=*new VHash();
280: HashStringValue& args = vargs.hash();
281:
282: for(; i<count; i++) {
283: args.put(format(args.count(), 0), params[i]);
284: }
1.86 misha 285:
1.89 moko 286: set_my_variable(*method.extra_params, vargs);
287: return;
288: } else
1.86 misha 289: throw Exception(PARSER_RUNTIME,
290: 0, //&name(),
291: "method of %s (%s) accepts maximum %d parameter(s) (%d present)",
1.87 moko 292: self().get_class()->name_cstr(),
293: self().type(),
1.86 misha 294: param_count,
295: count);
1.89 moko 296: }
1.78 misha 297:
1.86 misha 298: for(; i<count; i++) {
1.77 misha 299: const String& fname=*(*method.params_names)[i];
300: set_my_variable(fname, *params[i]);
301: }
302:
303: for(; i<param_count; i++) {
304: const String& fname=*(*method.params_names)[i];
1.68 misha 305: my->put(fname, VVoid::get());
1.1 paf 306: }
1.86 misha 307: } else
1.77 misha 308: fnumbered_params.store_params(params,count);
1.1 paf 309: }
310:
1.78 misha 311: void empty_params(){
312: if(method.params_names){
313: size_t param_count=method.params_names->count();
1.91 moko 314: if(param_count>0){
315: const String& fname=*(*method.params_names)[0];
316: my->put(fname, VString::empty());
317: for(size_t i=1; i<param_count; i++) {
318: const String& fname=*(*method.params_names)[i];
319: my->put(fname, VVoid::get());
320: }
1.78 misha 321: }
322: }
323: }
324:
1.72 misha 325: MethodParams* numbered_params() { return &fnumbered_params; }
1.18 paf 326:
1.63 misha 327: protected:
1.18 paf 328:
1.46 paf 329: void set_my_variable(const String& fname, Value& value) {
330: my->put(fname, &value); // remember param
1.25 paf 331: }
332:
1.46 paf 333: Value* get_result_variable();
1.1 paf 334:
335: public:
336:
1.87 moko 337: const Method& method;
1.1 paf 338:
1.41 paf 339: };
340:
1.85 misha 341: class VConstructorFrame: public VMethodFrame {
342: public:
1.87 moko 343: VConstructorFrame(const Method& amethod, VMethodFrame *acaller, Value& aself) : VMethodFrame(amethod, acaller, aself) {
344: // prevent non-string writes for better error reporting [constructors are not expected to return anything]
345: VMethodFrame::write(aself);
346: }
1.85 misha 347:
348: override void write(const String& /*astring*/, String::Language /*alang*/) {}
349: };
350:
1.1 paf 351: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_vmethod_frame.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / types