removed some warnings
[dyninst.git] / paradyn / src / met / mdl.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #ifndef MDL_EXTRA_H
43 #define MDL_EXTRA_H
44
45 /*
46  * Parse.h - define the classes that are used in parsing an interface.
47  */
48
49 #include "util/h/String.h"
50 // trace data streams
51 #include "util/h/ByteArray.h"
52 #include "util/h/Vector.h"
53 #include "util/h/Dictionary.h"
54 #include <iostream.h>
55 #include <fstream.h>
56 #include "util/h/aggregation.h"
57 #include "paradynd/src/blizzard_memory.h" //class memory and struct memory::bounds
58
59 #define MDL_FOLD_SUM 0
60 #define MDL_FOLD_AVG 1
61
62 #define MDL_AGG_SUM aggSum
63 #define MDL_AGG_AVG aggAvg
64 #define MDL_AGG_MIN aggMin
65 #define MDL_AGG_MAX aggMax
66
67 // MDL_T_POINT_RETURN is a kludge to check that we do not have 
68 // postInsn in a function return point. Once this is checked,
69 // the type should be set to MDL_T_POINT
70 #define MDL_T_POINT_RETURN 29
71
72 #define MDL_T_SCALAR_BASE 30
73 #define MDL_T_INT 30
74 #define MDL_T_FLOAT 31
75 #define MDL_T_STRING 32
76 #define MDL_T_BOOL 33
77 #define MDL_T_POINT 34
78 #define MDL_T_PROCEDURE 35
79 #define MDL_T_MODULE 36
80 #define MDL_T_CALLSITE 37
81 #define MDL_T_COUNTER 38
82 #define MDL_T_PROC_TIMER 39
83 #define MDL_T_WALL_TIMER 40
84 #define MDL_T_PROCESS 41
85 #define MDL_T_DRN     42
86 #define MDL_T_COUNTER_PTR 43
87 #define MDL_T_PROCEDURE_NAME 44
88 #define MDL_T_SCALAR_END 44
89
90 #define MDL_T_LIST_BASE 52
91 #define MDL_T_LIST_PROCEDURE_NAME 52
92 #define MDL_T_LIST_INT 53
93 #define MDL_T_LIST_FLOAT 54
94 #define MDL_T_LIST_STRING 55
95 #define MDL_T_LIST_PROCEDURE 56
96 #define MDL_T_LIST_MODULE 57
97 #define MDL_T_LIST_POINT 58
98 #define MDL_T_LIST_END 58
99
100 #define MDL_T_NONE 59
101
102 #define MDL_PREPEND 60
103 #define MDL_APPEND  61
104
105 #define MDL_RETURN 110
106 #define MDL_ENTER 111
107 #define MDL_SELF 112
108 #define MDL_CALLSITE 113
109 #define MDL_ARG 114
110
111 #define MDL_PLUS 120
112 #define MDL_MINUS 121
113 #define MDL_DIV 122
114 #define MDL_MULT 123
115 #define MDL_LT 124
116 #define MDL_GT 125
117 #define MDL_LE 126
118 #define MDL_GE 127
119 #define MDL_EQ 128
120 #define MDL_NE 129
121 #define MDL_AND 130
122 #define MDL_OR 131
123 #define MDL_NOT 132
124
125 #define MDL_SET_COUNTER 200
126 #define MDL_ADD_COUNTER 201
127 #define MDL_SUB_COUNTER 202
128 #define MDL_START_WALL_TIMER 203
129 #define MDL_STOP_WALL_TIMER 204
130 #define MDL_START_PROC_TIMER 205
131 #define MDL_STOP_PROC_TIMER 206
132 #define MDL_READ_ADDRESS 207
133 #define MDL_READ_SYMBOL 208
134 #define MDL_CALL_FUNC 209
135 #define MDL_CALL_FUNC_COUNTER 210
136
137 #define MDL_PRE_INSN   300
138 #define MDL_POST_INSN  301
139
140 #define MDL_RVAL_INT 400
141 #define MDL_RVAL_STRING 401
142 #define MDL_RVAL_ARRAY 402
143 #define MDL_RVAL_EXPR 403
144 #define MDL_RVAL_FUNC 404
145 #define MDL_RVAL_DEREF 405
146
147 #define MDL_RES_SYNCOBJECT 500
148 #define MDL_RES_CODE       501
149 #define MDL_RES_PROCESS    502
150 #define MDL_RES_MACHINE    503
151 #define MDL_RES_MEMORY    504
152
153 #define MDL_T_CONSTRAINT   600
154
155 #define MDL_T_MEMORY       700
156 #define MDL_T_VARIABLE     701
157 #define MDL_T_RECORD       702 //for $constraint[x].XXX
158
159 typedef struct {
160   unsigned type;
161   string name;
162   bool end_allowed;
163 } mdl_type_desc;
164
165 typedef struct {
166   mdl_type_desc self;
167   vector<mdl_type_desc> kids;
168 } mdl_focus_element;
169
170 inline string instr_req_to_string(unsigned type, string obj) {
171
172   switch(type) {
173   case MDL_SET_COUNTER:
174     return (string("setCounter(") + obj + ", "); 
175   case MDL_ADD_COUNTER:
176     return (string("addCounter(") + obj + ", ");
177   case MDL_SUB_COUNTER:
178     return (string("subCounter(") + obj + ", ");
179   case MDL_START_WALL_TIMER:
180     return (string("startWallTimer(") + obj + "); ");
181   case MDL_STOP_WALL_TIMER:
182     return (string("stopWallTimer(") + obj + "); ");
183   case MDL_START_PROC_TIMER:
184     return (string("startProcTimer(") + obj + "); ");
185   case MDL_STOP_PROC_TIMER:
186     return (string("stopProcTimer(") + obj + "); ");
187   }
188   assert(0);
189   return(NULL);
190 }
191
192 inline string op_to_string(unsigned op) {
193   switch(op) {
194   case MDL_PLUS:
195     return " + ";
196   case MDL_MINUS:
197     return " - ";
198   case MDL_DIV:
199     return " / ";
200   case MDL_MULT:
201     return " * ";
202   case MDL_LT:
203     return " < n";
204   case MDL_GT:
205     return " > ";
206   case MDL_LE:
207     return " <= ";
208   case MDL_GE:
209     return " >= ";
210   case MDL_EQ:
211     return " == ";
212   case MDL_NE:
213     return " != ";
214   case MDL_AND:
215     return " && ";
216   case MDL_OR:
217     return " || ";
218   case MDL_NOT:
219     return " ! ";
220   default:
221     assert(false);
222     return ""; // placate compiler
223   }
224 }
225
226 inline string agg_to_string(unsigned f) {
227   switch (f) {
228   case MDL_AGG_AVG: return ("avg");
229   case MDL_AGG_SUM: return ("sum");
230   case MDL_AGG_MAX: return ("max");
231   case MDL_AGG_MIN: return ("min");
232   default: return ("error");
233   }
234 }
235
236 #if defined(PARADYN)
237 class process { };
238 class function_base { };
239 class module { };
240 class instPoint { };
241 class dataReqNode { };
242 class metricDefinitionNode { };
243 class AstNode { };
244 #else
245 // #include "paradynd/src/symtab.h"
246 // #include "paradynd/src/ast.h"
247 class process;
248 class function_base;
249 class module;
250 class instPoint;
251 class dataReqNode;
252 class metricDefinitionNode;
253 class AstNode;
254 #endif
255
256 class functionName {
257  public:
258   functionName(const string &nm) { name = nm; }
259   string get() const { return name; }
260  private:
261   string name;
262 };
263
264 class mdl_var {
265 public:
266
267   inline mdl_var(bool is_remote=false);
268   mdl_var(const string &, bool is_remote);
269   inline ~mdl_var();
270   void destroy();
271
272   void dump();
273
274   mdl_var(const string& nm, int i, bool is_remote);
275   mdl_var(const string& nm, float f, bool is_remote);
276   mdl_var(const string& nm, instPoint *p, bool is_remote);
277   mdl_var(const string& nm, function_base *pr, bool is_remote);
278   mdl_var(const string& nm, functionName *pr, bool is_remote);
279   mdl_var(const string& nm, module *mod, bool is_remote);
280   mdl_var(const string& nm, const string& s, bool is_remote);
281   mdl_var(const string& nm, process *pr, bool is_remote);
282   mdl_var(const string& nm, vector<function_base*> *vp, bool is_remote);
283   mdl_var(const string& nm, vector<functionName*> *vp, bool is_remote);
284   mdl_var(const string& nm, vector<module*> *vm, bool is_remote);
285   mdl_var(const string& nm, vector<int> *vi, bool is_remote);
286   mdl_var(const string& nm, vector<float> *vf, bool is_remote);
287   mdl_var(const string& nm, vector<string> *vs, bool is_remote);
288   mdl_var(const string& nm, dataReqNode *drn, bool is_remote);
289   mdl_var(const string& nm, vector<instPoint*> *ipl, bool is_remote);
290
291   bool get(memory::bounds &b);
292   bool get(int &i);
293   bool get(float &f);
294   bool get(instPoint *&p);
295   bool get(function_base *&pr);
296   bool get(functionName *&fn);
297   bool get(module *&mod);
298   bool get(string& s);
299   bool get(process *&pr);
300   bool get(vector<function_base*> *&vp);
301   bool get(vector<functionName*> *&vp);
302   bool get(vector<module*> *&vm);
303   bool get(vector<int> *&vi);
304   bool get(vector<float> *&vf);
305   bool get(vector<string> *&vs);
306   bool get(dataReqNode *&drn);
307   bool get(vector<instPoint*> *&vip);
308
309   bool set(memory::bounds b) ;
310   bool set(int i);
311   bool set(float f);
312   bool set(instPoint *p);
313   bool set(function_base *pr);
314   bool set(functionName *f);
315   bool set(module *mod);
316   bool set(const string& s);
317   bool set(process *pr);
318   bool set(vector<function_base*> *vp);
319   bool set(vector<functionName*> *vp);
320   bool set(vector<module*> *vm);
321   bool set(vector<int> *vi);
322   bool set(vector<float> *vf);
323   bool set(vector<string> *vs);
324   bool set(vector<bool> *vb);
325   bool set(dataReqNode *drn);
326   bool set(vector<instPoint*> *ipl);
327
328   unsigned get_type(void) ;
329   void set_type(unsigned type);
330   bool is_list() const;
331   unsigned element_type() const;
332   unsigned list_size() const;
333   bool get_ith_element(mdl_var &ret, unsigned ith) const;
334   unsigned as_list();
335   bool make_list(unsigned type);
336   bool add_to_list(mdl_var& add_me);
337   
338   const string &name() const {return name_;}
339
340   unsigned type() const {return type_;}
341   bool remote() const {return remote_;}
342
343 private:
344   union mdl_types {
345     int i;
346     float f;
347     instPoint *point_;
348     function_base *pr;
349     functionName *fn;
350     process *the_process;
351     module *mod;
352     vector<function_base*>  *list_pr;
353     vector<functionName*> *list_fn;
354     vector<int>          *list_int;
355     vector<float>        *list_float;
356     vector<string>       *list_string;
357     vector<module*>      *list_module;
358     vector<instPoint*>   *list_pts;
359     dataReqNode          *drn;
360     void *ptr;
361     memory::bounds b;
362   };
363
364   string name_;
365   unsigned type_;
366   mdl_types vals; // the union
367   string string_val;
368   bool remote_;
369 };
370
371 class mdl_env {
372 public:
373   static void dump();
374   static void push();
375   static bool pop();
376   static bool add(mdl_var& value);
377
378   static bool add(const string& var_name, bool is_remote, unsigned type=MDL_T_NONE);
379   static bool get(mdl_var& ret, const string& var_name);
380   static bool set(mdl_var& value, const string& var_name);
381
382   static bool set(memory::bounds b, string&var_name) ;
383   static bool set(int i, const string& var_name);
384   static bool set(float f, const string& var_name);
385   static bool set(instPoint *p, const string& var_name);
386   static bool set(function_base *pr, const string& var_name);
387   static bool set(functionName *pr, const string& var_name);
388   static bool set(module *mod, const string& var_name);
389   static bool set(const string& s, const string& var_name);
390   static bool set(process *pr, const string& var_name);
391   static bool set(vector<function_base*> *vp, const string& var_name);
392   static bool set(vector<functionName*> *vp, const string& var_name);
393   static bool set(vector<module*> *vm, const string& var_name);
394   static bool set(vector<int> *vi, const string& var_name);
395   static bool set(vector<float> *vf, const string& var_name);
396   static bool set(vector<string> *vs, const string& var_name);
397   static bool set(vector<instPoint*> *vip, const string& var_name);
398   static bool set(dataReqNode *drn, const string& var_name);
399
400   static unsigned get_type(string var_name) ;
401   static bool set_type(unsigned type, const string& var_name);
402   static bool type(unsigned &ret, const string& var_name);
403   static bool is_remote(bool &is_rem, const string& var_name);
404
405 private:
406   static bool find(unsigned &index, const string& var_name);
407   static vector<unsigned> frames;
408   static vector<mdl_var> all_vars;
409 };
410
411 inline void mdl_var::dump() {
412   cout << name_ << " ";
413   switch (type_) {
414   case MDL_T_NONE:
415     cout << " MDL_T_NONE\n";
416     break;
417   case MDL_T_INT:
418     cout << " MDL_T_INT\n";
419     break;
420   case MDL_T_STRING:
421     cout << "MDL_T_STRING\n";
422     break;
423   case MDL_T_FLOAT:
424     cout << "MDL_T_FLOAT\n";
425     break;
426     // case MDL_T_BOOL:
427     // cout << "MDL_T_BOOL\n";
428     // break;
429   case MDL_T_POINT:
430     cout << "MDL_T_POINT\n";
431     break;
432   case MDL_T_PROCEDURE:
433     cout << "MDL_T_PROCEDURE\n";
434     break;
435   case MDL_T_PROCEDURE_NAME:
436     cout << "MDL_T_PROCEDURE_NAME\n";
437     break;
438   case MDL_T_MODULE:
439     cout << "MDL_T_MODULE\n";
440     break;
441   case MDL_T_CALLSITE:
442     cout << "MDL_T_CALLSITE\n";
443     break;
444   case MDL_T_COUNTER:
445     cout << "MDL_T_COUNTER\n";
446     break;
447   case MDL_T_WALL_TIMER:
448     cout << "MDL_T_WALL_TIMER\n";
449     break;
450   case MDL_T_PROC_TIMER:
451     cout << "MDL_T_PROC_TIMER\n";
452     break;
453   case MDL_T_DRN:
454     cout << "MDL_T_DRN\n";
455     break;
456   case MDL_T_LIST_PROCEDURE:
457     cout << "MDL_T_LIST_PROCEDURE\n";
458     break;
459   case MDL_T_LIST_PROCEDURE_NAME:
460     cout << "MDL_T_LIST_PROCEDURE_NAME\n";
461     break;
462   case MDL_T_LIST_MODULE:
463     cout << "MDL_T_LIST_MODULE\n";
464     break;
465   case MDL_T_LIST_POINT:
466     cout << "MDL_T_LIST_POINT\n";
467     break;
468   case MDL_T_PROCESS:
469     cout << "MDL_T_PROCESS\n";
470     break;
471   default:
472     cout << " No type\n";
473   }
474 }
475
476 inline void mdl_var::destroy() { type_ = MDL_T_NONE; vals.ptr = NULL; }
477
478 inline mdl_var::~mdl_var() {
479   destroy();
480 }
481
482 inline mdl_var::mdl_var(bool is_remote) : type_(MDL_T_NONE), remote_(is_remote) {
483   vals.ptr = NULL;
484 }
485
486 inline mdl_var::mdl_var(const string& nm, bool is_rem)
487 : name_(nm), type_(MDL_T_NONE), remote_(is_rem) { vals.ptr = NULL; }
488
489 inline mdl_var::mdl_var(const string& nm, int i, bool is_rem)
490 : name_(nm), type_(MDL_T_INT), remote_(is_rem) { vals.i = i;}
491
492 inline mdl_var::mdl_var(const string& nm, float f, bool is_rem)
493 : name_(nm), type_(MDL_T_FLOAT), remote_(is_rem) { vals.f = f;}
494
495 inline mdl_var::mdl_var(const string& nm, instPoint *p, bool is_rem)
496 : name_(nm), type_(MDL_T_POINT), remote_(is_rem) { vals.point_ = p;}
497
498 inline mdl_var::mdl_var(const string& nm, function_base *pr, bool is_rem)
499 : name_(nm), type_(MDL_T_PROCEDURE), remote_(is_rem) { vals.pr = pr;}
500
501 inline mdl_var::mdl_var(const string& nm, functionName *fn, bool is_rem)
502 : name_(nm), type_(MDL_T_PROCEDURE_NAME), remote_(is_rem) { vals.fn = fn;}
503
504 inline mdl_var::mdl_var(const string& nm, module *md, bool is_rem)
505 : name_(nm), type_(MDL_T_MODULE), remote_(is_rem) { vals.mod = md;}
506
507 inline mdl_var::mdl_var(const string& nm, const string& s, bool is_rem)
508 : name_(nm), type_(MDL_T_STRING), remote_(is_rem) { string_val = s;}
509
510 inline mdl_var::mdl_var(const string& nm, process *p, bool is_rem) 
511 : name_(nm), type_(MDL_T_PROCESS), remote_(is_rem) { vals.the_process = p; }
512
513 inline mdl_var::mdl_var(const string& nm, vector<function_base*> *vp, bool is_remote) 
514 : name_(nm), type_(MDL_T_LIST_PROCEDURE), remote_(is_remote) { vals.list_pr = vp; }
515      
516 inline mdl_var::mdl_var(const string& nm, vector<functionName*> *vf, bool is_remote) 
517 : name_(nm), type_(MDL_T_LIST_PROCEDURE_NAME), remote_(is_remote) { vals.list_fn = vf; }
518
519 inline mdl_var::mdl_var(const string& nm, vector<module*> *vm, bool is_remote) 
520 : name_(nm), type_(MDL_T_LIST_MODULE), remote_(is_remote) { vals.list_module = vm; }
521
522 inline mdl_var::mdl_var(const string& nm, vector<int> *vi, bool is_remote)
523 : name_(nm), type_(MDL_T_LIST_INT), remote_(is_remote) {
524   vals.list_int = vi;
525 }
526
527 inline mdl_var::mdl_var(const string& nm, vector<float> *vf, bool is_remote)
528 : name_(nm), type_(MDL_T_LIST_FLOAT), remote_(is_remote) {
529   vals.list_float = vf;
530 }
531
532 inline mdl_var::mdl_var(const string& nm, vector<string> *vs, bool is_remote)
533 : name_(nm), type_(MDL_T_LIST_STRING), remote_(is_remote) {
534   vals.list_string = vs;
535 }
536
537 inline mdl_var::mdl_var(const string& nm, vector<instPoint*> *vip, bool is_remote)
538 : name_(nm), type_(MDL_T_LIST_POINT), remote_(is_remote) { vals.list_pts = vip; }
539
540 inline mdl_var::mdl_var(const string& nm, dataReqNode *drn, bool is_remote) 
541 : name_(nm), type_(MDL_T_DRN), remote_(is_remote) { vals.drn = drn; }
542
543 inline bool mdl_var::get(memory::bounds &b) {
544   if (type_ != MDL_T_VARIABLE) return false;
545   b = vals.b ;
546   return true ;
547 }
548
549 inline bool mdl_var::get(int &i) {
550   if (type_ != MDL_T_INT) return false;
551   i = vals.i;
552   return true;
553 }
554 inline bool mdl_var::get(float &f) {
555   if (type_ != MDL_T_FLOAT) return false;
556   f = vals.f;
557   return true;
558 }
559
560 inline bool mdl_var::get(instPoint *&pt) {
561   if (type_ != MDL_T_POINT) return false;
562   pt = vals.point_;
563   return true;
564 }
565 inline bool mdl_var::get(function_base *&pr) {
566   if (type_ != MDL_T_PROCEDURE) return false;
567   pr = vals.pr;
568   return true;
569 }
570 inline bool mdl_var::get(functionName *&fn) {
571   if (type_ != MDL_T_PROCEDURE_NAME) return false;
572   fn = vals.fn;
573   return true;
574 }
575 inline bool mdl_var::get(module *&md) {
576   if (type_ != MDL_T_MODULE) return false;
577   md = vals.mod;
578   return true;
579 }
580 inline bool mdl_var::get(string& s) {
581   if (type_ != MDL_T_STRING) return false;
582   s = string_val;
583   return true;
584 }
585 inline bool mdl_var::get(process *&pr) {
586   if (type_ != MDL_T_PROCESS) return false;
587   pr = vals.the_process;
588   return true;
589 }
590 inline bool mdl_var::get(dataReqNode *&drn) {
591   if (type_ != MDL_T_DRN) return false;
592   drn = vals.drn; 
593   return true;
594 }
595
596 inline bool mdl_var::get(vector<function_base*> *&vp) {
597   if (type_ != MDL_T_LIST_PROCEDURE) return false;
598   vp = vals.list_pr;
599   return true;
600 }
601 inline bool mdl_var::get(vector<functionName*> *&vp) {
602   if (type_ != MDL_T_LIST_PROCEDURE_NAME) return false;
603   vp = vals.list_fn;
604   return true;
605 }
606 inline bool mdl_var::get(vector<module*> *&vm) {
607   if (type_ != MDL_T_LIST_MODULE) return false;
608   vm = vals.list_module;
609   return true;
610 }
611 inline bool mdl_var::get(vector<int> *&vi) {
612   if (type_ != MDL_T_LIST_INT) return false;
613   vi = vals.list_int;
614   return true;
615 }
616 inline bool mdl_var::get(vector<float> *&vf) {
617   if (type_ != MDL_T_LIST_FLOAT) return false;
618   vf = vals.list_float;
619   return true;
620 }
621 inline bool mdl_var::get(vector<string> *&vs) {
622   if (type_ != MDL_T_LIST_STRING) return false;
623   vs = vals.list_string;
624   return true;
625 }
626 inline bool mdl_var::get(vector<instPoint*> *&vip) {
627   if (type_ != MDL_T_LIST_POINT) return false;
628   vip = vals.list_pts;
629   return true;
630 }
631 inline bool mdl_var::set(memory::bounds b) {
632         destroy() ;
633         type_ = MDL_T_VARIABLE ;
634         vals.b = b ;
635         return true ;
636 }
637 inline bool mdl_var::set(int i) {
638   destroy();
639   type_ = MDL_T_INT;
640   vals.i = i;
641   return true;
642 }
643 inline bool mdl_var::set(float f) {
644   destroy();
645   type_ = MDL_T_FLOAT;
646   vals.f = f;
647   return true;
648 }
649
650 inline bool mdl_var::set(instPoint *pt) {
651   destroy();
652   type_ = MDL_T_POINT;
653    vals.point_ = pt;
654   return true;
655 }
656 inline bool mdl_var::set(function_base *pr) {
657   destroy();
658   type_ = MDL_T_PROCEDURE;
659   vals.pr = pr;
660   return true;
661 }
662 inline bool mdl_var::set(functionName *fn) {
663   destroy();
664   type_ = MDL_T_PROCEDURE_NAME;
665   vals.fn = fn;
666   return true;
667 }
668 inline bool mdl_var::set(module *md) {
669   destroy();
670   type_ = MDL_T_MODULE;
671   vals.mod = md;
672   return true;
673 }
674 inline bool mdl_var::set(const string& s) {
675   destroy();
676   type_ = MDL_T_STRING;
677   string_val = s;
678   return true;
679 }
680 inline bool mdl_var::set(process *pr) {
681   destroy();
682   type_ = MDL_T_PROCESS;
683   vals.the_process = pr;
684   return true;
685 }
686 inline bool mdl_var::set(dataReqNode *drn) {
687   destroy();
688   type_ = MDL_T_DRN;
689   vals.drn = drn;
690   return true;
691 }
692
693 inline bool mdl_var::set(vector<function_base*> *vp) {
694   destroy();
695   type_ = MDL_T_LIST_PROCEDURE;
696   vals.list_pr = vp;
697   return true;
698 }
699 inline bool mdl_var::set(vector<functionName*> *vp) {
700   destroy();
701   type_ = MDL_T_LIST_PROCEDURE_NAME;
702   vals.list_fn = vp;
703   return true;
704 }
705 inline bool mdl_var::set(vector<module*> *vm) {
706   destroy();
707   type_ = MDL_T_LIST_MODULE;
708   vals.list_module = vm;
709   return true;
710 }
711 inline bool mdl_var::set(vector<int> *vi) {
712   destroy();
713   type_ = MDL_T_LIST_INT;
714   vals.list_int = vi;
715   return true;
716 }
717 inline bool mdl_var::set(vector<float> *vf) {
718   destroy();
719   type_ = MDL_T_LIST_FLOAT;
720   vals.list_float = vf;
721   return true;
722 }
723 inline bool mdl_var::set(vector<string> *vs) {
724   destroy();
725   type_ = MDL_T_LIST_STRING;
726   vals.list_string = vs;
727   return true;
728 }
729 inline bool mdl_var::set(vector<instPoint*> *vip) {
730   destroy();
731   type_ = MDL_T_LIST_POINT;
732   vals.list_pts = vip;
733   return true;
734 }
735
736 inline bool mdl_var::is_list() const {
737   if ((type_ >= MDL_T_LIST_BASE) && (type_ <= MDL_T_LIST_END))
738     return true;
739   else
740     return false;
741 }
742
743 inline unsigned mdl_var::list_size() const {
744   switch (type_) {
745   case MDL_T_LIST_INT:
746     return (vals.list_int->size());    
747   case MDL_T_LIST_FLOAT:
748     return (vals.list_float->size());
749   case MDL_T_LIST_STRING:
750     return (vals.list_string->size()); 
751   case MDL_T_LIST_PROCEDURE:
752     return (vals.list_pr->size());
753   case MDL_T_LIST_PROCEDURE_NAME:
754     return (vals.list_fn->size());
755   case MDL_T_LIST_MODULE:
756     return (vals.list_module->size());
757   default:
758     return 0;
759   }
760 }
761
762 inline bool mdl_var::get_ith_element(mdl_var &ret, unsigned ith) const {
763   if (ith >= list_size()) return false;
764
765   switch (type_) {
766   case MDL_T_LIST_INT:
767     return (ret.set((*vals.list_int)[ith]));
768   case MDL_T_LIST_FLOAT:
769     return (ret.set((*vals.list_float)[ith]));
770   case MDL_T_LIST_STRING:
771     return (ret.set((*vals.list_string)[ith]));
772   case MDL_T_LIST_PROCEDURE:
773     assert(0); return false;
774   case MDL_T_LIST_PROCEDURE_NAME:
775     assert(0); return false;
776   case MDL_T_LIST_MODULE:
777     assert(0); return false;
778   default:
779     return false;
780   }
781   return true;
782 }
783
784 inline bool mdl_var::add_to_list(mdl_var& add_me) {
785   int i; float f; string s;
786   if (!vals.ptr) return false;
787   switch (type_) {
788   case MDL_T_LIST_INT:
789     if (!add_me.get(i)) return false;
790     (*vals.list_int) += i;
791     break;
792   case MDL_T_LIST_FLOAT:
793     if (!add_me.get(f)) return false;
794     (*vals.list_float) += f;
795     break;
796   case MDL_T_LIST_STRING: 
797     if (!add_me.get(s)) return false;
798     (*vals.list_string) += s;
799     break;
800   default:
801     return false;
802   }
803   return true;
804 }
805
806 inline bool mdl_var::make_list(unsigned element_type) {
807   vector<string> *vs;
808   vector<int> *vi;
809   vector<float> *vf;
810   vector<module*> *vm;
811   vector<function_base*> *vp;
812   vector<functionName*> *fn;
813
814   switch (element_type) {
815   case MDL_T_INT:
816     vi = new vector<int>;
817     if (!set(vi)) return false;
818     break;
819   case MDL_T_FLOAT:
820     vf = new vector<float>;
821     if (!set(vf)) return false;
822     break;
823   case MDL_T_STRING:
824     vs = new vector<string>;
825     if (!set(vs)) return false;
826     break;
827   case MDL_T_PROCEDURE:
828     vp = new vector<function_base*>;
829     if (!set(vp)) return false;
830     break;
831   case MDL_T_PROCEDURE_NAME:
832     fn = new vector<functionName*>;
833     if (!set(fn)) return false;
834     break;
835   case MDL_T_MODULE:
836     vm = new vector<module*>;
837     if (!set(vm)) return false;
838     break;
839   default:
840     return false;
841   }
842   return true;
843 }
844
845 inline unsigned mdl_var::as_list() {
846   switch (type_) {
847   case MDL_T_INT:
848     return MDL_T_LIST_INT;
849   case MDL_T_FLOAT:
850     return MDL_T_LIST_FLOAT;
851   case MDL_T_STRING:
852     return MDL_T_LIST_STRING;
853   case MDL_T_PROCEDURE:
854     return MDL_T_LIST_PROCEDURE;
855   case MDL_T_PROCEDURE_NAME:
856     return MDL_T_LIST_PROCEDURE_NAME;
857   case MDL_T_MODULE:
858     return MDL_T_LIST_MODULE;
859   default:
860     return MDL_T_NONE;
861   }
862 }
863
864 inline unsigned mdl_var::get_type(void) {
865   return type_ ;
866 }
867
868 inline void mdl_var::set_type(unsigned type) {
869   destroy();
870   type_ = type;
871   vals.i = 0;
872 }
873
874 //inline string mdl_var::name() const { return name_;}
875 //inline unsigned mdl_var::type() const { return type_; }
876 //inline bool mdl_var::remote() const {return remote_; }
877
878 inline unsigned mdl_var::element_type() const {
879   switch (type_) {
880   case MDL_T_LIST_INT:        return MDL_T_INT;
881   case MDL_T_LIST_FLOAT:      return MDL_T_FLOAT;
882   case MDL_T_LIST_STRING:     return MDL_T_STRING;
883   case MDL_T_LIST_PROCEDURE:  return MDL_T_PROCEDURE;
884   case MDL_T_LIST_PROCEDURE_NAME:  return MDL_T_PROCEDURE_NAME;
885   case MDL_T_LIST_MODULE:     return MDL_T_MODULE;
886   case MDL_T_LIST_POINT:      return MDL_T_POINT;
887   default:                    return MDL_T_NONE;
888   }
889 }
890
891 inline void mdl_env::dump() {
892   for (unsigned u=0; u<mdl_env::all_vars.size(); u++)
893     mdl_env::all_vars[u].dump();
894 }
895
896 inline void mdl_env::push() {
897   mdl_env::frames += mdl_env::all_vars.size();
898 }
899
900 inline bool mdl_env::pop() {
901   unsigned frame_size = mdl_env::frames.size();
902   unsigned index = mdl_env::frames[frame_size - 1];
903   mdl_env::frames.resize(frame_size-1);
904   mdl_env::all_vars.resize(index);
905   return true;
906 }
907
908 inline bool mdl_env::add(mdl_var& value) {
909   mdl_env::all_vars += value;
910   return true;
911 }
912
913 inline bool mdl_env::add(const string& var_name, bool is_remote, unsigned type) {
914   mdl_var temp(var_name, is_remote);
915   if (((type >= MDL_T_SCALAR_BASE) && (type <= MDL_T_SCALAR_END)) ||
916       ((type >= MDL_T_LIST_BASE) && (type <= MDL_T_LIST_END)))
917     temp.set_type(type);
918   mdl_env::all_vars += temp;
919   return true;
920 }
921
922 inline bool mdl_env::find(unsigned &index, const string& var_name) {
923   unsigned size = mdl_env::all_vars.size();
924   if (!size)
925     return false;
926
927   do {
928     size--;
929     if (mdl_env::all_vars[size].name() == var_name) {
930       index = size;
931       return true;
932     }
933   } while (size);
934   return false;
935 }
936
937 inline bool mdl_env::type(unsigned &ret, const string& var_name) {
938   unsigned index;
939   if (!mdl_env::find(index, var_name))
940     return false;
941   ret = mdl_env::all_vars[index].type();
942   return true;
943 }
944
945 inline bool mdl_env::is_remote(bool &is_rem, const string& var_name) {
946   unsigned index;
947   if (!mdl_env::find(index, var_name))
948     return false;
949   is_rem = mdl_env::all_vars[index].remote();
950   return true;
951 }
952
953 inline bool mdl_env::set(memory::bounds b, string& var_name) {
954   unsigned index;
955   if (!mdl_env::find(index, var_name))
956     return false;
957   mdl_env::all_vars[index].set(b);
958   return true;
959 }
960 inline unsigned mdl_env::get_type(string var_name) {
961   unsigned index;
962   if (!mdl_env::find(index, var_name))
963     return false; //TO DO
964   return mdl_env::all_vars[index].get_type();
965 }
966
967 inline bool mdl_env::set_type(unsigned type, const string& var_name) {
968   unsigned index;
969   if (!mdl_env::find(index, var_name))
970     return false;
971   mdl_env::all_vars[index].set_type(type);
972   return true;
973 }
974
975 inline bool mdl_env::get(mdl_var &ret, const string& var_name) {
976   unsigned index;
977   if (!mdl_env::find(index, var_name))
978     return false;
979   
980   ret = mdl_env::all_vars[index];
981   return true;
982 }
983
984 inline bool mdl_env::set(int i, const string& var_name) {
985   unsigned index;
986   if (!mdl_env::find(index, var_name))
987     return false;
988   mdl_env::all_vars[index].set(i);
989   return true;
990 }
991
992 inline bool mdl_env::set(float f, const string& var_name) {
993   unsigned index;
994   if (!mdl_env::find(index, var_name))
995     return false;
996   mdl_env::all_vars[index].set(f);
997   return true;
998 }
999
1000 inline bool mdl_env::set(instPoint *p, const string& var_name) {
1001   unsigned index;
1002   if (!mdl_env::find(index, var_name))
1003     return false;
1004   mdl_env::all_vars[index].set(p);
1005   return true;
1006 }
1007
1008 inline bool mdl_env::set(function_base *pr, const string& var_name) {
1009   unsigned index;
1010   if (!mdl_env::find(index, var_name))
1011     return false;
1012   mdl_env::all_vars[index].set(pr);
1013   return true;
1014 }
1015
1016 inline bool mdl_env::set(functionName *fn, const string& var_name) {
1017   unsigned index;
1018   if (!mdl_env::find(index, var_name))
1019     return false;
1020   mdl_env::all_vars[index].set(fn);
1021   return true;
1022 }
1023
1024 inline bool mdl_env::set(module *mod, const string& var_name) {
1025   unsigned index;
1026   if (!mdl_env::find(index, var_name))
1027     return false;
1028   mdl_env::all_vars[index].set(mod);
1029   return true;
1030 }
1031
1032 inline bool mdl_env::set(const string& s, const string& var_name) {
1033   unsigned index;
1034   if (!mdl_env::find(index, var_name))
1035     return false;
1036   mdl_env::all_vars[index].set(s);
1037   return true;
1038 }
1039
1040 inline bool mdl_env::set(process *pr, const string& var_name) {
1041   unsigned index;
1042   if (!mdl_env::find(index, var_name))
1043     return false;
1044   mdl_env::all_vars[index].set(pr);
1045   return true;
1046 }
1047
1048 inline bool mdl_env::set(dataReqNode *drn, const string& var_name) {
1049   unsigned index;
1050   if (!mdl_env::find(index, var_name))
1051     return false;
1052   mdl_env::all_vars[index].set(drn);
1053   return true;
1054 }
1055
1056 inline bool mdl_env::set(vector<function_base*> *vp, const string& var_name) {
1057   unsigned index;
1058   if (!mdl_env::find(index, var_name))
1059     return false;
1060   mdl_env::all_vars[index].set(vp);
1061   return true;
1062 }
1063 inline bool mdl_env::set(vector<functionName*> *vp, const string& var_name) {
1064   unsigned index;
1065   if (!mdl_env::find(index, var_name))
1066     return false;
1067   mdl_env::all_vars[index].set(vp);
1068   return true;
1069 }
1070 inline bool mdl_env::set(vector<module*> *vm, const string& var_name) {
1071   unsigned index;
1072   if (!mdl_env::find(index, var_name))
1073     return false;
1074   mdl_env::all_vars[index].set(vm);
1075   return true;
1076 }
1077 inline bool mdl_env::set(vector<int> *vi, const string& var_name) {
1078   unsigned index;
1079   if (!mdl_env::find(index, var_name))
1080     return false;
1081   mdl_env::all_vars[index].set(vi);
1082   return true;
1083 }
1084 inline bool mdl_env::set(vector<float> *vf, const string& var_name) {
1085   unsigned index;
1086   if (!mdl_env::find(index, var_name))
1087     return false;
1088   mdl_env::all_vars[index].set(vf);
1089   return true;
1090 }
1091 inline bool mdl_env::set(vector<string> *vs, const string& var_name) {
1092   unsigned index;
1093   if (!mdl_env::find(index, var_name))
1094     return false;
1095   mdl_env::all_vars[index].set(vs);
1096   return true;
1097 }
1098 inline bool mdl_env::set(vector<instPoint*> *vip, const string& var_name) {
1099   unsigned index;
1100   if (!mdl_env::find(index, var_name))
1101     return false;
1102   mdl_env::all_vars[index].set(vip);
1103   return true;
1104 }
1105
1106 #endif