replaced exclude_func and exclude_lib with exclude_node
[dyninst.git] / paradyn / src / met / metScanner.l
1 %{
2 /*
3  * Copyright (c) 1996 Barton P. Miller
4  * 
5  * We provide the Paradyn Parallel Performance Tools (below
6  * described as Paradyn") on an AS IS basis, and do not warrant its
7  * validity or performance.  We reserve the right to update, modify,
8  * or discontinue this software at any time.  We shall have no
9  * obligation to supply such updates or modifications or any other
10  * form of support to you.
11  * 
12  * This license is for research uses.  For such uses, there is no
13  * charge. We define "research use" to mean you may freely use it
14  * inside your organization for whatever purposes you see fit. But you
15  * may not re-distribute Paradyn or parts of Paradyn, in any form
16  * source or binary (including derivatives), electronic or otherwise,
17  * to any other organization or entity without our permission.
18  * 
19  * (for other uses, please contact us at paradyn@cs.wisc.edu)
20  * 
21  * All warranties, including without limitation, any warranty of
22  * merchantability or fitness for a particular purpose, are hereby
23  * excluded.
24  * 
25  * By your use of Paradyn, you understand and agree that we (or any
26  * other person or entity with proprietary rights in Paradyn) are
27  * under no obligation to provide either maintenance services,
28  * update services, notices of latent defects, or correction of
29  * defects for Paradyn.
30  * 
31  * Even if advised of the possibility of such damages, under no
32  * circumstances shall we (or any other person or entity with
33  * proprietary rights in the software licensed hereunder) be liable
34  * to you or any third party for direct, indirect, or consequential
35  * damages of any character regardless of type of action, including,
36  * without limitation, loss of profits, loss of use, loss of good
37  * will, or computer failure or malfunction.  You agree to indemnify
38  * us (and any other person or entity with proprietary rights in the
39  * software licensed hereunder) for any and all liability it may
40  * incur to third parties resulting from your use of Paradyn.
41  */
42 /*
43  * $Log: metScanner.l,v $
44  * Revision 1.16  1997/06/07 21:01:26  newhall
45  * replaced exclude_func and exclude_lib with exclude_node
46  *
47  * Revision 1.15  1997/06/05 04:29:47  newhall
48  * added exclude_func mdl option to exclude shared object functions
49  *
50  * Revision 1.14  1996/10/08 21:52:18  mjrg
51  * changed the evaluation of resource lists
52  * removed warnings
53  *
54  * Revision 1.13  1996/09/26 19:03:27  newhall
55  * added "exclude_lib" mdl option
56  *
57  * Revision 1.12  1996/04/04  21:55:28  newhall
58  * added limit option to visi definition
59  *
60  * Revision 1.11  1996/03/20  17:04:22  mjrg
61  * Changed mdl to support calls with multiple arguments.
62  *
63  * Revision 1.10  1995/12/18 23:22:14  newhall
64  * changed metric units type so that it can have one of 3 values (normalized,
65  * unnormalized or sampled)
66  *
67  * Revision 1.9  1995/12/15 22:30:09  mjrg
68  * Merged paradynd and paradyndPVM
69  * Get module name for functions from symbol table in solaris
70  * Fixed code generation for multiple instrumentation statements
71  * Change syntax of MDL resource lists
72  *
73  * Revision 1.8  1995/11/21 15:15:39  naim
74  * Changing the MDL grammar to allow more flexible metric definitions (i.e. we
75  * can specify all elements in any order). Additionally, the option "fold"
76  * has been removed - naim
77  *
78  * Revision 1.7  1995/11/17  17:22:16  newhall
79  * added "unitsType" option to MDL, can be "normalized" or "unnormalized"
80  *
81  * Revision 1.6  1995/11/13  14:54:06  naim
82  * Adding "mode" option to the Metric Description Language to allow specificacion
83  * of developer mode for metrics (default mode is "normal") - naim
84  *
85  * Revision 1.5  1995/08/24  15:02:48  hollings
86  * AIX/SP-2 port (including option for split instruction/data heaps)
87  * Tracing of rexec (correctly spawns a paradynd if needed)
88  * Added rtinst function to read getrusage stats (can now be used in metrics)
89  * Critical Path
90  * Improved Error reporting in MDL sematic checks
91  * Fixed MDL Function call statement
92  * Fixed bugs in TK usage (strings passed where UID expected)
93  *
94  * Revision 1.4  1995/05/18  10:58:35  markc
95  * mdl
96  *
97  * Revision 1.3  1995/02/07  21:59:56  newhall
98  * added a force option to the visualization definition, this specifies
99  * if the visi should be started before metric/focus menuing
100  * removed compiler warning * Revision 1.2  1994/08/22  15:53:30  markc
101  * Config language version 2.
102  *
103  * Revision 1.1  1994/07/07  03:25:28  markc
104  * Configuration language parser.
105  *
106  *
107  */
108
109 #include <stdio.h>
110 #include <stdlib.h>
111 #include <string.h>
112
113 #define YYSTYPE struct parseStack
114 #include "y.tab.h"
115 #include "paradyn/src/met/metParse.h"
116
117 int cur_line = 1;
118 char cur_file[80];
119
120 int yylook();
121 int yyback(int*,int);
122
123
124 extern void yyerror(const char *);
125
126 int curr;
127 int len;
128 int lineNo = 0;
129 #define MDL_MAX 255
130 char line[MDL_MAX];
131
132 #undef getc
133 int getScanChar(FILE *file)
134 {
135     char *ret;
136
137     if (curr == len) {
138         ret = fgets(line, MDL_MAX, file);
139         if (!ret) return(EOF);
140         lineNo++;
141         len = strlen(line);
142         curr = 0;
143     }
144     return(line[curr++]);
145 }
146
147 #ifdef FLEX_SCANNER
148 #undef YY_INPUT
149 #define YY_INPUT(buf,result,max_size)   \
150 {                                       \
151     int c = getScanChar(yyin);          \
152     result = (c == EOF) ? YY_NULL : (buf[0] = c, 1); \
153 }
154 #endif
155
156 %}
157 DIGIT   [0-9]
158 DOLLAR  \$
159 INT     {DIGIT}+
160 FIX     {INT}"."{INT}
161 ALPHA   [A-Za-z]
162 SLASH   \/
163 IDENT   {DOLLAR}?{ALPHA}({ALPHA}|{DIGIT}|_)*
164 COMMENT {SLASH}{SLASH}
165 %%
166 i
167 "&"             { return(tAMPERSAND);}
168 "$"             { return(tDOLLAR);}
169 "="             { return(tASSIGN);}
170 "+"             { return(tPLUS);}
171 "-"             { return(tMINUS);}
172 "/"             { return(tDIV);}
173 "*"             { return(tMULT);}
174 "<"             { return(tLT);}
175 ">"             { return(tGT);}
176 "<="            { return(tLE);}
177 ">="            { return(tGE);}
178 "=="            { return(tEQ);}
179 "!"             { return(tNOT);}
180 "!="            { return(tNE);}
181 "&&"            { return(tAND);}
182 "||"            { return(tOR);}
183 "("             { return(tLPAREN); }
184 ")"             { return(tRPAREN); }
185 "{"             { return(tLBLOCK); }
186 "}"             { return(tRBLOCK); }
187 "["             { return(tLSQUARE);}
188 "]"             { return(tRSQUARE);}
189 ","             { return(tCOMMA); }
190 ":"             { return(tCOLON); }
191 ";"             { return(tSEMI); }
192 "."             { return(tDOT); }
193 "(*"            { return(tLC); }
194 "*)"            { return(tRC); }
195 "true"          { return(tTRUE); }
196 "false"         { return(tFALSE); }
197 "functionCall"  { return(tFUNCTION_CALL); }
198 "resourceList"  { return(tRES_LIST); }
199 "procedure"     { return(tT_PROCEDURE); }
200 "module"        { return(tT_MODULE); }
201 "string"        { return(tT_STRING); }
202 "int"           { return(tT_INT); }
203 "float"         { return(tT_FLOAT); }
204 "flavor"        { return(tFLAVOR);}
205 "foreach"       { return(tFOREACH); }
206 "metric"        { return(tMETRIC); }
207 "avg"           { return(tAVG);}
208 "min"           { return(tMIN);}
209 "max"           { return(tMAX);}
210 "sum"           { return(tSUM);}
211 "name"          { return(tNAME);}
212 "units"         { return(tUNITS);}
213 "mode"          { return(tMODE);}
214 "developer"     { return(tDEVELOPER);}
215 "normal"        { return(tNORMAL);}
216 "unitsType"     { return(tUNITTYPE);}
217 "normalized"    { return(tNORMALIZE);}
218 "unnormalized"  { return(tUNNORMALIZE);}
219 "sampled"       { return(tSAMPLED);}
220 "base"          { return(tBASE);}
221 "is"            { return(tIS);}
222 "append"        { return(tAPPEND);}
223 "prepend"       { return(tPREPEND);}
224 "derived"       { return(tDERIVED);}
225 "if"            { return(tIF);}
226 "replace"       { return(tREPLACE);}
227 "constraint"    { return(tCONSTRAINT);}
228 "type"          { return(tTYPE);}
229 "at"            { return(tAT);}
230 "constrained"   { return(tCONSTRAINED);}
231 "in"            { return(tIN);}
232 "counter"       { return(tCOUNTER);}
233 "processTimer"          { return(tP_TIME);}
234 "wallTimer"             { return(tW_TIME);}
235 "aggregateOperator"     { return(tAGG);}
236 "style"                 { return(tSTYLE);}
237 "EventCounter"          { return(tEVENT_COUNTER); }
238 "SampledFunction"       { return(tSAMPLE_FUNC); }
239 "startProcessTimer"     { return(tSTART_PROC_TIMER);}
240 "stopProcessTimer"      { return(tSTOP_PROC_TIMER);}
241 "startWallTimer"        { return(tSTART_WALL_TIMER);}
242 "stopWallTimer"         { return(tSTOP_WALL_TIMER);}
243 "setCounter"            { return(tSET_COUNTER);}
244 "addCounter"            { return(tADD_COUNTER);}
245 "subCounter"            { return(tSUB_COUNTER);}
246 "preInsn"               { return(tPRE_INSN); }
247 "postInsn"              { return(tPOST_INSN); }
248 "readSymbol"            { return(tREAD_SYMBOL); }
249 "readAddress"           { return(tREAD_ADDRESS); }
250 \$return                { return(tRETURN);}
251 \$arg                   { return(tARG);}
252 "daemon"                { return(tDAEMON); }
253 "process"               { return(tPROCESS); }
254 "visi"          { return(tVISI); }
255 "exclude_node"          { return(tEXLIB); }
256 "tunable_constant"      { return(tTUNABLE_CONSTANT); }
257 "command"               { return(tCOMMAND); }
258 "host"          { return(tHOST); }
259 "dir"           { return(tDIR); }
260 "user"          { return(tUSER);}
261 "force"         { return(tFORCE);}
262 "limit"         { return(tLIMIT);}
263 "default"       { return(tDEFAULT); }
264 "void"          { return(tVOID); }
265 "items"         { return(tITEMS); }
266 "library"       { return(tLIBRARY); }
267 [Tt][Rr][Uu][Ee]        { return(tTRUE);}
268 [Ff][Aa][Ll][Ss][Ee]    { return(tFALSE);}
269 {FIX}           { 
270                   yylval.f = atof(yytext);
271                   return(tFLOAT);
272                 }
273 {COMMENT}       {
274                     char ch;
275                     while (1) {
276                         ch = getScanChar(yyin);
277                         if (ch == '\n') break;
278                     }
279                 }
280 {IDENT}         { /* it's an identifier */
281                   yylval.sp = new string(yytext);
282                   return(tIDENT);
283                 }
284 {INT}           {
285                   int i = atoi(yytext);
286                   assert(i >= 0);
287                   yylval.u = (unsigned) i;
288                   return(tUNS);
289                 }
290 [ \n\t]         { }
291 \"              {
292                           extern void doString();
293                           doString();
294                           yylval.sp = new string(yytext+1);
295                           return(tLITERAL);
296                 }
297 .               { yyerror("invalid character"); }
298 %%
299
300 void doString()
301 {
302     char ch;
303
304     while (1) {
305         ch = getScanChar(yyin);
306         switch (ch) {
307             case '"':
308                 yytext[yyleng] = '\0';
309                 return;
310                 break;
311             
312             case '\n':
313                 yyerror("Unterminated string literal");
314                 return;
315                 break;
316
317             default:
318                 yytext[yyleng] = ch;
319                 break;
320         }
321         yyleng++;
322     }
323 }
324
325 void yyerror(const char *message)
326 {
327     int i;
328     printf("line %d, col %d:%s\n", lineNo, curr, message);
329     printf(line);
330     for (i=0; i < curr; i++) {
331         printf(" ");
332     }
333     printf("^\n");
334 }