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