1 martin 1.18 /*
2 //%LICENSE////////////////////////////////////////////////////////////////
|
3 martin 1.19 //
|
4 martin 1.18 // Licensed to The Open Group (TOG) under one or more contributor license
5 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
6 // this work for additional information regarding copyright ownership.
7 // Each contributor licenses this file to you under the OpenPegasus Open
8 // Source License; you may not use this file except in compliance with the
9 // License.
|
10 martin 1.19 //
|
11 martin 1.18 // Permission is hereby granted, free of charge, to any person obtaining a
12 // copy of this software and associated documentation files (the "Software"),
13 // to deal in the Software without restriction, including without limitation
14 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 // and/or sell copies of the Software, and to permit persons to whom the
16 // Software is furnished to do so, subject to the following conditions:
|
17 martin 1.19 //
|
18 martin 1.18 // The above copyright notice and this permission notice shall be included
19 // in all copies or substantial portions of the Software.
|
20 martin 1.19 //
|
21 martin 1.18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
22 martin 1.19 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
23 martin 1.18 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
25 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
28 martin 1.19 //
|
29 martin 1.18 //////////////////////////////////////////////////////////////////////////
30 */
|
31 karl 1.10
|
32 bob 1.1 %option never-interactive
|
33 e.boden 1.7 %option stack
34 %option yylineno
|
35 karl 1.14 %{
|
36 bob 1.1
|
37 karl 1.20
|
38 bob 1.1 #include "cimmofParser.h"
39 #include "memobjs.h"
40 #include "cimmof_tab.h"
41
|
42 kumpf 1.16 /* Avoid warn_unused_result warnings in Linux RPM build */
|
43 kumpf 1.17 #ifndef ECHO
|
44 karl 1.22 # define ECHO do { fwrite(yytext, yyleng, 1, yyout); } while(0)
|
45 kumpf 1.17 #endif
|
46 kumpf 1.16
|
47 bob 1.1 /*---------------------------------------------------------------*/
48 /* These routines wrap certain flex functions, keeping down the */
49 /* number of external dependencies */
50 /*---------------------------------------------------------------*/
51 int get_yy_buf_size_wrapper() { return YY_BUF_SIZE; }
52
|
53 karl 1.14 void * get_cimmof__current_buffer_wrapper() {
54 return (void *)YY_CURRENT_BUFFER;
|
55 bob 1.1 }
56
57 void * create_cimmof_buffer_wrapper(const FILE *f, int size) {
58 return (void *)yy_create_buffer((FILE *)f, size);
59 }
60
|
61 kumpf 1.5 int switch_to_buffer_wrapper(void *buffstate, Boolean closeCurrent) {
62 if (closeCurrent)
63 {
64 if (yyin != NULL)
65 {
66 fflush(yyin);
67 fclose(yyin);
68 yyin = NULL;
69 }
70 yy_delete_buffer(YY_CURRENT_BUFFER);
71 }
|
72 bob 1.1 yy_switch_to_buffer((YY_BUFFER_STATE)buffstate);
73 return 0;
74 }
75
|
76 e.boden 1.7 char strbuf[1024], *strbuf_p, slashx[2];
|
77 bob 1.1
|
78 karl 1.21 /* Pointer to name for metaQualifiers communicated between lexer and parser */
79 char * metaQualifierName;
80
|
81 bob 1.1
82 %}
83
84
|
85 gs.keenan 1.9 %x myStr myHex
|
86 bob 1.1 %%
87
88
|
89 karl 1.14 \n { cimmofParser::Instance()->increment_lineno(); }
90 \/\/.*[\r\n]? { cimmofParser::Instance()->increment_lineno(); }
91 [ \t\r] { /* skip white space */ }
92 class { return(TOK_CLASS); }
93 \{ { return(TOK_LEFTCURLYBRACE); }
94 \} { return(TOK_RIGHTCURLYBRACE); }
95 \[ { return(TOK_LEFTSQUAREBRACKET); }
96 \] { return(TOK_RIGHTSQUAREBRACKET); }
97 \( { return(TOK_LEFTPAREN); }
98 \) { return(TOK_RIGHTPAREN); }
99 \: { return(TOK_COLON); }
100 ; { return(TOK_SEMICOLON); }
|
101 kumpf 1.15 [+-]?[0-9]*\.[0-9]+([eE][+-]?[0-9]+)? {
|
102 karl 1.14 cimmof_lval.strval = new String(yytext);
103 return(TOK_REAL_VALUE); }
|
104 kumpf 1.15 [+-]?0[0-7]+ { cimmof_lval.strval = new String(yytext);
|
105 karl 1.14 return(TOK_OCTAL_VALUE); }
|
106 kumpf 1.15 [+-]?0x[0-9A-Fa-f]+ { cimmof_lval.strval = new String(yytext);
|
107 karl 1.14 return(TOK_HEX_VALUE); }
|
108 kumpf 1.15 [+-]?[01]+[Bb] { cimmof_lval.strval = new String(yytext);
|
109 karl 1.14 return(TOK_BINARY_VALUE); }
|
110 kumpf 1.15 [1-9][0-9]* { cimmof_lval.strval = new String(yytext);
|
111 karl 1.14 return(TOK_POSITIVE_DECIMAL_VALUE); }
|
112 kumpf 1.15 [+-]?[0-9]+ { /* Note: All non-zero unsigned integers are handled above */
113 cimmof_lval.strval = new String(yytext);
|
114 karl 1.14 return(TOK_SIGNED_DECIMAL_VALUE); }
115 \= { return(TOK_EQUAL); }
116 , { return(TOK_COMMA); }
117 \'.+\' { cimmof_lval.strval = new String(yytext);
118 return(TOK_CHAR_VALUE); }
119
120 /*--- bugzilla 544 fix; handle string escapes ---
121
122 an impl. decision: invalid escape sequences
123 are simply ignored, and left in the string.
124
125 an impl. decision: yyleng is set to the len
126 of resulting string, not the len of the matched
127 token(s), since they are different, with escapes.
128 (but note; cimmof.y does not use yyleng!)
129
130 an impl. req't: strings are returned to parser
|
131 karl 1.21 with enclosing "s.
|
132 karl 1.14 */
133
134 \" { BEGIN(myStr); strbuf_p = strbuf;
135 /**strbuf_p++ = '"';*/ }
136 <myStr>\" { BEGIN(INITIAL);
137 /**strbuf_p++ = '"';*/ *strbuf_p = '\0';
138 cimmof_leng = strbuf_p - strbuf;
139 cimmof_lval.strval = new String(strbuf);
140 return TOK_STRING_VALUE; }
141 <myStr><<EOF>> |
142 <myStr>\n { BEGIN(INITIAL);
143 /**strbuf_p++ = '"';*/ *strbuf_p = '\0';
144 cimmof_leng = strbuf_p - strbuf;
145 cimmof_lval.strval = new String(strbuf);
146 return TOK_UNEXPECTED_CHAR; }
147 <myStr>\\b { /* backspace */ *strbuf_p++ = '\b'; }
148 <myStr>\\f { /* form feed */ *strbuf_p++ = '\f'; }
149 <myStr>\\n { /* line feed */ *strbuf_p++ = '\n'; }
150 <myStr>\\r { /* carriage return */ *strbuf_p++ = '\r'; }
151 <myStr>\\t { /* horizontal tab */ *strbuf_p++ = '\t'; }
152 <myStr>\\' { /* single quote */ *strbuf_p++ = '\''; }
153 karl 1.14 <myStr>\\\" { /* double quote */ *strbuf_p++ = '"'; }
154 <myStr>\\\\ { /* backslash */ *strbuf_p++ = '\\'; }
155 <myStr>\\[xX] { yy_push_state(myHex);
156 memcpy(slashx,yytext,2);
157 }
158 <myStr>\\(.|\n) { *strbuf_p++ = '\\';
159 *strbuf_p++ = yytext[1]; }
160 <myStr>[^\\\n\"]+ { char *t = yytext;
161 while( *t ) *strbuf_p++ = *t++;
162 *strbuf_p = '\0'; }
163 <myHex>[0-9A-Fa-f]{1,4} { /* get escaped hex digits */
164 char hexfmt[4]; unsigned int n;
165 sprintf( hexfmt, "%%%dx", yyleng );
166 sscanf(yytext, hexfmt, &n);
167 if (n>255) {
168 memcpy(strbuf_p,slashx,2);
169 strbuf_p += 2;
170 char *t = yytext;
171 while( *t ) *strbuf_p++ = *t++;
172 }
173 else *strbuf_p++ = (char)n;
174 karl 1.14 yy_pop_state();
175 }
176 <myHex>. { memcpy(strbuf_p,slashx,2);
177 strbuf_p += 2;
178 *strbuf_p++ = *yytext;
179 yy_pop_state();
180 }
181 /* --- end of bugzilla 544 fix --- */
182
183
184 \/\* { int c1=0, c2=yyinput();
185 for(;;) {
186 if (c2==EOF) break;
187 if (c1=='*' && c2=='/') break;
188 c1=c2;
189 c2=yyinput();
190 }
191 }
192 <<EOF>> { yyterminate(); }
193 [Nn][Uu][Ll][Ll] { return(TOK_NULL_VALUE); }
194 [Tt][Rr][Uu][Ee] { return(TOK_TRUE); }
195 karl 1.14 [Ff][Aa][Ll][Ss][Ee] { return(TOK_FALSE); }
196 \. { return(TOK_PERIOD); }
197 \#[Pp][Rr][Aa][Gg][Mm][Aa] { return(TOK_PRAGMA); }
198 [Ii][Nn][Ss][Tt][Aa][Nn][Cc][Ee] { return(TOK_INSTANCE); }
199 [Oo][Ff] { return(TOK_OF); }
|
200 bob 1.1 [Qq][Uu][Aa][Ll][Ii][Ff][Ii][Ee][Rr] {return(TOK_QUALIFIER); }
|
201 karl 1.14 [Ss][Cc][Oo][Pp][Ee] { return(TOK_SCOPE); }
|
202 karl 1.21
203 [Aa][Ss][Ss][Oo][Cc][Ii][Aa][Tt][Ii][Oo][Nn] {
204 metaQualifierName = strdup(yytext);
205 return(TOK_ASSOCIATION); }
|
206 karl 1.22 [Ii][Nn][Dd][Ii][Cc][Aa][Tt][Ii][Oo][Nn] {
|
207 karl 1.21 metaQualifierName = strdup(yytext);
208 return(TOK_INDICATION); }
209
|
210 karl 1.14 [Pp][Rr][Oo][Pp][Ee][Rr][Tt][Yy] { return(TOK_PROPERTY); }
|
211 bob 1.1 [Rr][Ee][Ff][Ee][Rr][Ee][Nn][Cc][Ee] { return(TOK_REFERENCE); }
|
212 karl 1.14 [Mm][Ee][Tt][Hh][Oo][Dd] { return(TOK_METHOD); }
|
213 bob 1.1 [Pp][Aa][Rr][Aa][Mm][Ee][Tt][Ee][Rr] {return(TOK_PARAMETER); }
|
214 karl 1.14 [Aa][Nn][Yy] { return(TOK_ANY); }
|
215 karl 1.21
|
216 karl 1.14 [Rr][Ee][Ff] { return(TOK_REF); }
217 [Ff][Ll][Aa][Vv][Oo][Rr] { return(TOK_FLAVOR); }
|
218 bob 1.1 [Ee][Nn][Aa][Bb][Ll][Ee][Oo][Vv][Ee][Rr][Rr][Ii][Dd][Ee] {
|
219 karl 1.14 return(TOK_ENABLEOVERRIDE); }
|
220 bob 1.1 [Dd][Ii][Ss][Aa][Bb][Ll][Ee][Oo][Vv][Ee][Rr][Rr][Ii][Dd][Ee] {
|
221 karl 1.14 return(TOK_DISABLEOVERRIDE); }
222 [Rr][Ee][Ss][Tt][Rr][Ii][Cc][Tt][Ee][Dd] { return(TOK_RESTRICTED); }
223 [Tt][Oo][Ss][Uu][Bb][Cc][Ll][Aa][Ss][Ss] { return(TOK_TOSUBCLASS); }
224 [Tt][Rr][Aa][Nn][Ss][Ll][Aa][Tt][Aa][Bb][Ll][Ee] { return(TOK_TRANSLATABLE); }
225 [Ii][Nn][Cc][Ll][Uu][Dd][Ee] { return(TOK_INCLUDE); }
226 $[_$0-9a-zA-Z]+ { cimmof_lval.strval = new String(yytext);
227 return TOK_ALIAS_IDENTIFIER; }
228 [Aa][Ss] { return TOK_AS; }
229 [Ss][Tt][Rr][Ii][Nn][Gg] { return(TOK_DT_STR); }
230 [Bb][Oo][Oo][Ll][Ee][Aa][Nn] { return(TOK_DT_BOOL); }
231 [Dd][Aa][Tt][Ee][Tt][Ii][Mm][Ee] { return(TOK_DT_DATETIME); }
232 [Uu][Ii][Nn][Tt]8 { return(TOK_DT_UINT8); }
233 [Uu][Ii][Nn][Tt]16 { return(TOK_DT_UINT16); }
234 [Uu][Ii][Nn][Tt]32 { return(TOK_DT_UINT32); }
235 [Uu][Ii][Nn][Tt]64 { return(TOK_DT_UINT64); }
236 [Ss][Ii][Nn][Tt]8 { return(TOK_DT_SINT8); }
237 [Ss][Ii][Nn][Tt]16 { return(TOK_DT_SINT16); }
238 [Ss][Ii][Nn][Tt]32 { return(TOK_DT_SINT32); }
239 [Ss][Ii][Nn][Tt]64 { return(TOK_DT_SINT64); }
240 [Rr][Ee][Aa][Ll]32 { return(TOK_DT_REAL32); }
241 [Rr][Ee][Aa][Ll]64 { return(TOK_DT_REAL64); }
242 karl 1.14 [Cc][Hh][Aa][Rr]8 { return(TOK_DT_CHAR8); }
243 [Cc][Hh][Aa][Rr]16 { return(TOK_DT_CHAR16); }
244 [_a-zA-Z][_$0-9a-zA-Z]* { cimmof_lval.strval = new String(yytext);
245 return(TOK_SIMPLE_IDENTIFIER); }
246 . { cimmof_lval.strval = new String(yytext);
247 return(TOK_UNEXPECTED_CHAR); }
|
248 bob 1.1
249 %%
250
|
251 karl 1.23 void cimmof_yy_less(int n) { yyless(n); }
252
253 // Implemented to hide bison functions that are defined but not used
254 // so compiler unused warnings can be enabled. The functions defined in ths
255 // dummy function are those current defined by Flex but never called by
256 // Pegasus lex definitions. Since each compiler has different rules for
257 // hiding unused functions, we implement each that we know.
258 // CLANG can use the pragma below.
259 // GCC hides the unused function through the recursive call
260 // NOT tested with other compilers.
261 #ifdef __clang__
262 #pragma clang diagnostic push
263 #pragma clang diagnostic ignored "-Wunused-function"
264 #endif
265 static void UNUSED_LEX_FUNCTIONS()
266 {
267 UNUSED_LEX_FUNCTIONS(); // call itself to avoid unused function warning
268 yyunput(3, (char *)""); // call unused lex functions
269 yy_top_state();
270 }
271 #ifdef __clang__
272 karl 1.23 #pragma clang diagnostic pop
273 #endif
|
Return to
cimmof.l
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Compiler