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