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