removed some warnings
[dyninst.git] / paradyn / src / met / metClass.C
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 /*
43  * Implements classes used for metric description language
44  *
45  * $Log: metClass.C,v $
46  * Revision 1.8  1997/10/10 00:22:23  tamches
47  * removed some warnings
48  *
49  * Revision 1.7  1996/08/16 21:12:19  tamches
50  * updated copyright for release 1.1
51  *
52  * Revision 1.6  1996/04/04 21:55:23  newhall
53  * added limit option to visi definition
54  *
55  * Revision 1.5  1995/11/08  06:23:33  tamches
56  * removed some warnings
57  *
58  * Revision 1.4  1995/05/18 10:58:15  markc
59  * Added mdl hooks
60  *
61  * Revision 1.3  1995/02/07  21:59:50  newhall
62  * added a force option to the visualization definition, this specifies
63  * if the visi should be started before metric/focus menuing
64  * removed compiler warnings
65  *
66  * Revision 1.2  1994/08/31  22:21:01  markc
67  * Added log entries to metClass
68  *
69  */
70
71 #include "metParse.h"
72 #include <assert.h>
73
74
75 vector<daemonMet*> daemonMet::allDaemons;
76 vector<processMet*> processMet::allProcs;
77 vector<visiMet*> visiMet::allVisis;
78 vector<tunableMet*> tunableMet::allTunables;
79
80 static vector<string_list*> all_strings;
81
82 void add_string_list(string& name, vector<string>& elem) {
83   unsigned size = all_strings.size();
84   for (unsigned u=0; u<size; u++)
85     if (all_strings[u]->name == name) {
86       all_strings[u]->name = name; all_strings[u]->elements = elem; return;
87     }
88   string_list *sl = new string_list;
89   sl->name = name; sl->elements = elem;
90   all_strings += sl;
91 }
92
93 metError metParseError = ERR_NO_ERROR;
94 const char *metParseError_list[6] = {"No error",
95                                      "Name in use, by different type",
96                                      "Name in use, by same type",
97                                      "Name in use",
98                                      "Bad arguments",
99                                      "Malloc",
100                                    };
101
102 void handle_error() 
103 {
104   metParseError = ERR_NO_ERROR;
105 }
106
107 void tunableMet::dumpAll()
108 {
109   unsigned size = allTunables.size();
110   for (unsigned u=0; u<size; u++)
111     allTunables[u]->dump();
112 }
113
114 void tunableMet::dump() const
115 {
116   cout << "TUNABLE:  name " << name_;
117   if (useBvalue) {
118     cout << "   value: " << (Bvalue_ ? "TRUE" : "FALSE") << endl;
119   } else {
120     cout << "   value: " << Fvalue_ << endl;
121   }
122 }
123
124 void tunableMet::addHelper(tunableMet *add_me) {
125   unsigned size = allTunables.size();
126
127   for (unsigned u=0; u<size; u++) {
128     if (allTunables[u]->name() == add_me->name()) {
129       delete allTunables[u];
130       allTunables[u] = add_me;
131       return;
132     }
133   }
134   allTunables += add_me;
135 }
136
137 bool tunableMet::addTunable(string &c, float f)
138 {
139   tunableMet *tm = new tunableMet(f, c);
140   if (!tm) {
141     metParseError = ERR_MALLOC;
142     return false;
143   }
144   addHelper(tm);
145   return true;
146 }
147
148 bool tunableMet::addTunable(string &c, int b)
149 {
150   tunableMet *tm = new tunableMet(b, c);
151   if (!tm) {
152     metParseError = ERR_MALLOC;
153     return false;
154   }
155   addHelper(tm);
156   return true;
157 }
158
159 bool processMet::set_field (field &f)
160 {
161   switch (f.spec) {
162   case SET_COMMAND:
163     command_ = *f.val;
164     break;
165   case SET_DAEMON:
166     daemon_ = *f.val;
167     break;
168   case SET_HOST:
169     host_ = *f.val;
170     break;
171   case SET_USER:
172     user_ = *f.val;
173     break;
174   case SET_DIR:
175     execDir_ = *f.val;
176     break;
177   case SET_NAME:
178     name_ = *f.val;
179     break;
180   default:
181     return false;
182   }
183   return true;
184 }
185
186 bool daemonMet::set_field (field &f)
187 {
188   switch (f.spec) {
189   case SET_COMMAND:
190     command_ = *f.val;
191     break;
192   case SET_USER:
193     user_ = *f.val;
194     break;
195   case SET_DIR:
196     execDir_ = *f.val;
197     break;
198   case SET_FLAVOR:
199     flavor_ = *f.flav;
200     break;
201   case SET_NAME:
202     name_ = *f.val;
203     break;
204   case SET_HOST:
205     host_ = *f.val;
206     break;
207   default:
208     return false;
209   }
210   return true;
211 }
212
213 bool visiMet::set_field(field &f)
214 {
215   switch (f.spec) {
216   case SET_COMMAND:
217     command_ = *f.val;
218     break;
219   case SET_HOST:
220     host_ = *f.val;
221     break;
222   case SET_USER:
223     user_ = *f.val;
224     break;
225   case SET_DIR:
226     execDir_ = *f.val;
227     break;
228   case SET_NAME:
229     name_ = *f.val;
230     break;
231   case SET_FORCE:
232     force_ = f.force;
233     if((force_ < 0) || (force_ > 1)){
234       force_ = 0;
235     }
236     break;
237   case SET_LIMIT:
238     limit_ = f.limit;
239     break;
240   default:
241     return false;
242   }
243   return true;
244 }
245
246 daemonMet::daemonMet(string &nm, string &cmd, string &exec, string &u,
247                      string &h, string& flav)
248 : name_(nm), command_(cmd), execDir_(exec), user_(u), host_(h), flavor_(flav) { }
249
250 void daemonMet::dumpAll() {
251   unsigned size = allDaemons.size();
252   for (unsigned u=0; u<size; u++)
253     allDaemons[u]->dump();
254 }
255
256 void daemonMet::dump() const
257 {
258   cout << "DAEMONMET: " << name_ << endl;
259   cout << "     command: " << command_ << endl;
260   cout << "     execDir: " << execDir_ << endl;
261   cout << "     host: " << host_ << endl;
262   cout << "     flavor: " << flavor_ << endl;
263   cout << "     user: " << user_ << endl;
264 }
265
266 bool daemonMet::addDaemon(daemonMet *dm)
267 {
268   if (!dm || !dm->command_.length() || !dm->name_.length()) {
269     metParseError = ERR_BAD_ARGS;
270     if (dm) delete dm; dm = NULL;
271     return false;
272   }
273
274   unsigned size = allDaemons.size();
275   for (unsigned u=0; u<size; u++) {
276     if (dm->name() == allDaemons[u]->name()) {
277       delete allDaemons[u];
278       allDaemons[u] = dm;
279       return true;
280     }
281   }
282   allDaemons += dm;
283   return true;
284 }
285
286 processMet::processMet(string &nm, string &cmd, string &d, string &h,
287                        string &u, string &exec)
288 : name_(nm), command_(cmd), daemon_(d), host_(h), user_(u), execDir_(exec) { }
289
290 void processMet::dumpAll()
291 {
292   unsigned size = allProcs.size();
293   for (unsigned u=0; u<size; u++)
294     allProcs[u]->dump();
295 }
296
297 void processMet::dump() const
298 {
299   cout << "PROCESSMET: " << name_ << endl;
300   cout << "    command: " << command_ << endl;
301   cout << "    daemon: " << daemon_ << endl;
302   cout << "    host: " << host_ << endl;
303   cout << "    execDir: " << execDir_ << endl;
304   cout << "    user: " << user_ << endl;
305 }
306
307 bool processMet::addProcess(processMet *pm)
308 {
309   if (!pm || !pm->name || !pm->command) {
310     metParseError = ERR_BAD_ARGS;
311     if (pm) delete pm; pm = NULL;
312     return false;
313   }
314
315   unsigned size = allProcs.size();
316   for (unsigned u=0; u<size; u++) {
317     if (allProcs[u]->name() == pm->name()) {
318       delete allProcs[u]; 
319       allProcs[u] = pm;
320       return true;
321     }
322   }
323   allProcs += pm;
324   return true;
325 }
326
327 visiMet::visiMet(string &nm, string &u, string &h, string &e, string &, // c
328                  int &,int &) // f, l
329   : name_(nm), user_(u), host_(h), execDir_(e) { }
330
331 void visiMet::dumpAll()
332 {
333   unsigned size = allVisis.size();
334   for (unsigned u=0; u<size; u++)
335     allVisis[u]->dump();
336 }
337
338 void visiMet::dump() const
339 {
340   cout << "VISIMET: " << name_ << endl;
341   cout << "    command: " << command_ << endl;
342   cout << "    host: " << host_ << endl;
343   cout << "    execDir: " << execDir_ << endl;
344   cout << "    user: " << user_ << endl;
345 }
346
347 bool visiMet::addVisi(visiMet *vm)
348 {
349   if (!vm || !vm->name || !vm->command) {
350     metParseError = ERR_BAD_ARGS;
351     delete vm; vm = 0;
352     return false;
353   }
354   unsigned size = allVisis.size();
355   for (unsigned u=0; u<size; u++) {
356     if (allVisis[u]->name() == vm->name()) {
357       delete allVisis[u];
358       allVisis[u] = vm;
359       return true;
360     }
361   }
362   allVisis += vm;
363   return true;
364 }
365