1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #ifndef lint
26 static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
27 #endif
28
29 #define YYBYACC 1
30 #define YYMAJOR 1
31 #define YYMINOR 9
32 #define YYPATCH 20110908
33
34 #define YYEMPTY (-1)
35 #define yyclearin (yychar = YYEMPTY)
36 #define yyerrok (yyerrflag = 0)
37 #define YYRECOVERING() (yyerrflag != 0)
38
39 #define YYPREFIX "yy"
40
41 #define YYPURE 0
42
43 mike 1.1 #line 2 "mof.y"
44
45 #include "config.h"
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include "config.h"
50 #include "buffer.h"
51 #include "types.h"
52 #include "state.h"
53 #include "ptrarray.h"
54
55 #define ARRAYOF(TYPE) ((MI_Uint32)TYPE | (MI_Uint32)MI_ARRAY_BIT)
56
57 extern int yylex();
58 extern int openIncludeFile(const char* path);
59
60 #line 20 "mof.y"
61 #ifdef YYSTYPE
62 #undef YYSTYPE_IS_DECLARED
63 #define YYSTYPE_IS_DECLARED 1
64 mike 1.1 #endif
65 #ifndef YYSTYPE_IS_DECLARED
66 #define YYSTYPE_IS_DECLARED 1
67 typedef union
68 {
69 MI_Boolean boolean;
70 MI_Sint64 integer;
71 MI_Real64 real;
72 MI_Char16 character;
73 char* string;
74 char* identifier;
75 char* dollarIdentifier;
76 MI_Type type;
77 MI_PropertyDecl* property;
78 MI_MethodDecl* methodDecl;
79 MI_ParameterDecl* parameter;
80 MOF_ParameterList parameterList;
81 MOF_FeatureList featureList;
82 MI_QualifierDecl* qualifierDeclaration;
83 MOF_ConstantValue constantValue;
84 MOF_Initializer initializer;
85 mike 1.1 MI_Uint32 flags;
86 MI_Qualifier* qualifier;
87 MOF_QualifierList qualifierList;
88 MI_ClassDecl* classDeclaration;
89 MI_InstanceDecl* instanceDeclaration;
90 } YYSTYPE;
91 #endif /* !YYSTYPE_IS_DECLARED */
92 #line 68 "y.tab.c"
93
94 /* compatibility with bison */
95 #ifdef YYPARSE_PARAM
96 /* compatibility with FreeBSD */
97 # ifdef YYPARSE_PARAM_TYPE
98 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
99 # else
100 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
101 # endif
102 #else
103 # define YYPARSE_DECL() yyparse(void)
104 #endif
105
106 mike 1.1 /* Parameters sent to lex. */
107 #ifdef YYLEX_PARAM
108 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
109 # define YYLEX yylex(YYLEX_PARAM)
110 #else
111 # define YYLEX_DECL() yylex(void)
112 # define YYLEX yylex()
113 #endif
114
115 /* Parameters sent to yyerror. */
116 #define YYERROR_DECL() yyerror(const char *s)
117 #define YYERROR_CALL(msg) yyerror(msg)
118
119 extern int YYPARSE_DECL();
120
121 #define TOK_ERROR 257
122 #define TOK_BOOLEAN 258
123 #define TOK_SINT8 259
124 #define TOK_UINT8 260
125 #define TOK_SINT16 261
126 #define TOK_UINT16 262
127 mike 1.1 #define TOK_SINT32 263
128 #define TOK_UINT32 264
129 #define TOK_SINT64 265
130 #define TOK_UINT64 266
131 #define TOK_REAL32 267
132 #define TOK_REAL64 268
133 #define TOK_DATETIME 269
134 #define TOK_CHAR16 270
135 #define TOK_STRING 271
136 #define TOK_BOOLEAN_VALUE 272
137 #define TOK_REF 273
138 #define TOK_SCOPE 274
139 #define TOK_CLASS 275
140 #define TOK_ASSOCIATION 276
141 #define TOK_INDICATION 277
142 #define TOK_QUALIFIER 278
143 #define TOK_PROPERTY 279
144 #define TOK_REFERENCE 280
145 #define TOK_METHOD 281
146 #define TOK_PARAMETER 282
147 #define TOK_ANY 283
148 mike 1.1 #define TOK_FLAVOR 284
149 #define TOK_ENABLEOVERRIDE 285
150 #define TOK_DISABLEOVERRIDE 286
151 #define TOK_RESTRICTED 287
152 #define TOK_TOSUBCLASS 288
153 #define TOK_TRANSLATABLE 289
154 #define TOK_INSTANCE 290
155 #define TOK_OF 291
156 #define TOK_AS 292
157 #define TOK_PRAGMA 293
158 #define TOK_SCHEMA 294
159 #define TOK_INTEGER_VALUE 295
160 #define TOK_REAL_VALUE 296
161 #define TOK_STRING_VALUE 297
162 #define TOK_CHAR_VALUE 298
163 #define TOK_IDENT 299
164 #define TOK_ALIAS_IDENTIFIER 300
165 #define TOK_NULL 301
166 #define YYERRCODE 256
167 static const short yylhs[] = { -1,
168 0, 0, 0, 35, 35, 35, 35, 36, 31, 31,
169 mike 1.1 31, 31, 13, 13, 12, 12, 12, 12, 12, 12,
170 29, 28, 28, 27, 27, 27, 27, 30, 30, 25,
171 25, 24, 24, 24, 24, 24, 7, 7, 7, 7,
172 7, 7, 7, 7, 10, 10, 10, 10, 11, 11,
173 11, 11, 6, 6, 6, 6, 6, 6, 6, 6,
174 6, 6, 6, 6, 6, 6, 3, 9, 9, 8,
175 8, 8, 8, 8, 8, 8, 8, 17, 17, 18,
176 18, 18, 19, 20, 20, 5, 5, 5, 5, 5,
177 5, 1, 1, 15, 15, 16, 16, 16, 16, 23,
178 22, 22, 21, 21, 21, 21, 21, 21, 21, 21,
179 26, 32, 32, 32, 32, 14, 4, 34, 34, 33,
180 33, 2, 2, 2, 2, 2,
181 };
182 static const short yylen[] = { 2,
183 1, 2, 1, 1, 1, 1, 1, 5, 3, 5,
184 4, 6, 4, 3, 1, 1, 1, 2, 2, 2,
185 3, 1, 3, 1, 2, 3, 4, 3, 1, 1,
186 3, 1, 1, 1, 1, 1, 3, 4, 4, 5,
187 5, 6, 6, 7, 3, 4, 4, 5, 6, 7,
188 5, 6, 1, 1, 1, 1, 1, 1, 1, 1,
189 1, 1, 1, 1, 1, 1, 2, 1, 3, 2,
190 mike 1.1 2, 3, 3, 3, 3, 4, 4, 3, 2, 1,
191 1, 1, 3, 1, 3, 1, 1, 1, 1, 1,
192 1, 1, 2, 5, 6, 2, 4, 3, 5, 5,
193 1, 3, 1, 1, 1, 1, 1, 1, 1, 1,
194 5, 4, 5, 5, 6, 4, 2, 1, 2, 4,
195 5, 1, 1, 1, 1, 1,
196 };
197 static const short yydefred[] = { 0,
198 3, 0, 0, 0, 0, 0, 0, 6, 0, 5,
199 7, 1, 4, 123, 124, 126, 125, 122, 0, 0,
200 0, 0, 0, 22, 0, 2, 0, 0, 0, 0,
201 9, 0, 0, 0, 0, 0, 0, 0, 29, 0,
202 21, 0, 0, 0, 0, 53, 54, 55, 56, 57,
203 58, 59, 60, 61, 62, 63, 65, 64, 66, 0,
204 0, 0, 0, 15, 17, 16, 0, 0, 0, 0,
205 0, 0, 0, 0, 112, 92, 0, 90, 86, 87,
206 88, 91, 0, 0, 32, 33, 34, 35, 36, 26,
207 84, 0, 0, 23, 0, 11, 0, 10, 14, 67,
208 0, 0, 0, 18, 20, 19, 0, 0, 0, 0,
209 0, 0, 94, 0, 0, 117, 0, 0, 118, 0,
210 114, 93, 8, 28, 83, 0, 27, 0, 0, 113,
211 mike 1.1 82, 45, 80, 0, 81, 0, 37, 0, 0, 13,
212 0, 0, 0, 79, 97, 0, 0, 0, 95, 0,
213 0, 0, 119, 85, 12, 115, 47, 0, 0, 0,
214 68, 0, 0, 0, 39, 0, 46, 0, 0, 38,
215 0, 0, 78, 99, 103, 104, 105, 106, 107, 108,
216 109, 110, 101, 0, 0, 0, 0, 116, 51, 0,
217 0, 0, 0, 0, 0, 41, 0, 48, 0, 0,
218 0, 40, 0, 100, 0, 30, 0, 120, 0, 75,
219 74, 49, 69, 0, 0, 43, 52, 0, 42, 0,
220 102, 111, 0, 121, 77, 76, 50, 44, 31,
221 };
222 static const short yydgoto[] = { 7,
223 83, 61, 159, 74, 133, 160, 64, 161, 162, 65,
224 66, 67, 31, 75, 8, 33, 111, 134, 135, 92,
225 183, 184, 71, 90, 207, 115, 24, 25, 163, 40,
226 10, 11, 119, 120, 12, 13,
227 };
228 static const short yysindex[] = { 55,
229 0, -138, -138, -273, -278, -138, 53, 0, -223, 0,
230 0, 0, 0, 0, 0, 0, 0, 0, -39, 33,
231 -138, -13, -27, 0, -16, 0, -138, -258, -138, -89,
232 mike 1.1 0, 210, 2, -108, -239, -187, -123, -187, 0, 34,
233 0, -138, -35, -138, -30, 0, 0, 0, 0, 0,
234 0, 0, 0, 0, 0, 0, 0, 0, 0, 47,
235 -168, -138, -138, 0, 0, 0, -65, 135, -21, -167,
236 -12, -185, 45, 4, 0, 0, -40, 0, 0, 0,
237 0, 0, -176, 85, 0, 0, 0, 0, 0, 0,
238 0, -22, -123, 0, -138, 0, -108, 0, 0, 0,
239 -11, -2, 71, 0, 0, 0, -138, -138, -88, 69,
240 67, 92, 0, -150, 84, 0, 74, -138, 0, 58,
241 0, 0, 0, 0, 0, -187, 0, -30, 4, 0,
242 0, 0, 0, 86, 0, -41, 0, 69, 8, 0,
243 -4, 3, 54, 0, 0, 69, -125, 108, 0, 69,
244 98, 94, 0, 0, 0, 0, 0, 101, -138, -138,
245 0, -7, 135, 109, 0, 69, 0, 126, -17, 0,
246 69, 14, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 22, -123, 127, 69, 0, 0, 117,
248 117, 130, 40, -138, -138, 0, 150, 0, 154, 27,
249 157, 0, 69, 0, -125, 0, 39, 0, 172, 0,
250 0, 0, 0, 117, 117, 0, 0, 173, 0, 174,
251 0, 0, -123, 0, 0, 0, 0, 0, 0,
252 };
253 mike 1.1 static const short yyrindex[] = { 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, -15, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0, 0, -14,
258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0, 123, 0,
261 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
262 0, 0, -24, 0, 0, 0, 0, 0, 0, 0,
263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265 193, 0, 0, 0, 0, 0, 0, 0, 0, 0,
266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
270 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
271 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
272 0, 0, 0, 0, 0, 0, 0, 0, 0, 46,
273 72, 0, 0, 0, 0, 0, 0, 0, 0, 0,
274 mike 1.1 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
275 0, 0, 0, 76, 81, 0, 0, 0, 0, 0,
276 0, 0, 0, 0, 0, 0, 0, 0, 0,
277 };
278 static const short yygindex[] = { 0,
279 205, 347, -23, 158, -28, -26, 189, 73, 95, 198,
280 200, 0, -31, -25, 0, 0, -91, -85, 246, 0,
281 65, 0, 0, -90, 0, 0, 229, 0, 9, 0,
282 0, 0, 152, 0, 266, 0,
283 };
284 #define YYTABLESIZE 542
285 static const short yytable[] = { 158,
286 123, 6, 127, 63, 144, 69, 62, 84, 9, 91,
287 139, 96, 36, 98, 73, 9, 89, 21, 29, 89,
288 22, 126, 95, 199, 145, 6, 35, 42, 24, 25,
289 37, 114, 44, 192, 89, 60, 193, 136, 68, 110,
290 63, 108, 169, 62, 107, 70, 113, 132, 121, 6,
291 172, 27, 164, 28, 167, 168, 137, 76, 138, 103,
292 174, 170, 204, 171, 186, 205, 165, 218, 166, 109,
293 193, 130, 202, 6, 203, 68, 41, 24, 25, 222,
294 197, 118, 223, 30, 78, 201, 71, 30, 109, 71,
295 mike 1.1 32, 93, 30, 109, 206, 38, 155, 154, 210, 211,
296 89, 209, 125, 156, 100, 99, 112, 79, 80, 76,
297 81, 38, 70, 82, 116, 70, 73, 220, 38, 73,
298 122, 72, 225, 226, 72, 124, 73, 146, 118, 140,
299 6, 147, 229, 148, 150, 6, 195, 14, 15, 194,
300 16, 17, 149, 6, 157, 6, 173, 185, 6, 175,
301 176, 177, 188, 178, 179, 180, 181, 182, 187, 189,
302 18, 85, 86, 87, 88, 89, 96, 196, 46, 47,
303 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
304 58, 59, 152, 72, 198, 208, 14, 15, 212, 16,
305 17, 38, 46, 47, 48, 49, 50, 51, 52, 53,
306 54, 55, 56, 57, 58, 59, 143, 109, 216, 18,
307 14, 15, 217, 16, 17, 219, 46, 47, 48, 49,
308 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
309 224, 227, 228, 18, 14, 15, 98, 16, 17, 77,
310 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
311 56, 57, 58, 59, 129, 104, 122, 18, 14, 15,
312 78, 16, 17, 200, 105, 213, 106, 78, 39, 221,
313 94, 153, 26, 0, 0, 0, 0, 0, 0, 0,
314 0, 18, 0, 79, 80, 76, 81, 0, 131, 82,
315 79, 80, 76, 81, 0, 131, 82, 46, 47, 48,
316 mike 1.1 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
317 59, 1, 0, 0, 0, 14, 15, 0, 16, 17,
318 14, 15, 0, 16, 17, 0, 0, 2, 0, 2,
319 3, 0, 3, 14, 15, 0, 16, 17, 18, 0,
320 78, 0, 4, 18, 4, 5, 0, 5, 19, 20,
321 0, 0, 23, 0, 0, 0, 18, 0, 0, 0,
322 0, 0, 0, 79, 80, 76, 81, 34, 131, 82,
323 0, 0, 0, 43, 0, 45, 0, 0, 0, 0,
324 0, 0, 0, 0, 0, 0, 0, 0, 23, 0,
325 97, 0, 46, 47, 48, 49, 50, 51, 52, 53,
326 54, 55, 56, 57, 58, 59, 0, 0, 101, 102,
327 14, 15, 0, 16, 17, 0, 0, 0, 0, 117,
328 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
329 0, 0, 0, 18, 0, 0, 0, 0, 0, 0,
330 0, 128, 0, 0, 0, 0, 0, 0, 0, 0,
331 0, 0, 0, 141, 142, 0, 0, 0, 0, 0,
332 0, 0, 0, 0, 151, 0, 117, 46, 47, 48,
333 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
334 59, 0, 0, 0, 0, 0, 0, 0, 0, 0,
335 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
336 0, 0, 0, 0, 0, 190, 191, 0, 0, 0,
337 mike 1.1 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
338 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
339 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
340 214, 215,
341 };
342 static const short yycheck[] = { 41,
343 41, 91, 93, 30, 93, 32, 30, 36, 0, 38,
344 102, 43, 40, 45, 123, 7, 41, 291, 58, 44,
345 299, 44, 58, 41, 110, 91, 40, 44, 44, 44,
346 58, 44, 291, 41, 59, 125, 44, 40, 30, 61,
347 67, 68, 40, 67, 68, 44, 59, 59, 74, 91,
348 142, 275, 138, 277, 59, 141, 59, 297, 61, 125,
349 146, 59, 41, 61, 150, 44, 59, 41, 61, 91,
350 44, 97, 59, 91, 61, 67, 93, 93, 93, 41,
351 166, 73, 44, 123, 272, 171, 41, 123, 91, 44,
352 58, 58, 123, 91, 185, 123, 128, 126, 190, 191,
353 125, 187, 125, 129, 273, 59, 274, 295, 296, 297,
354 298, 123, 41, 301, 300, 44, 41, 203, 123, 44,
355 297, 41, 214, 215, 44, 41, 123, 61, 120, 59,
356 91, 40, 223, 284, 61, 91, 163, 276, 277, 163,
357 279, 280, 59, 91, 59, 91, 93, 40, 91, 275,
358 mike 1.1 276, 277, 59, 279, 280, 281, 282, 283, 61, 59,
359 299, 285, 286, 287, 288, 289, 44, 59, 258, 259,
360 260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
361 270, 271, 125, 292, 59, 59, 276, 277, 59, 279,
362 280, 123, 258, 259, 260, 261, 262, 263, 264, 265,
363 266, 267, 268, 269, 270, 271, 295, 91, 59, 299,
364 276, 277, 59, 279, 280, 59, 258, 259, 260, 261,
365 262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
366 59, 59, 59, 299, 276, 277, 44, 279, 280, 35,
367 258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
368 268, 269, 270, 271, 97, 67, 297, 299, 276, 277,
369 272, 279, 280, 169, 67, 193, 67, 272, 23, 205,
370 42, 120, 7, -1, -1, -1, -1, -1, -1, -1,
371 -1, 299, -1, 295, 296, 297, 298, -1, 300, 301,
372 295, 296, 297, 298, -1, 300, 301, 258, 259, 260,
373 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
374 271, 257, -1, -1, -1, 276, 277, -1, 279, 280,
375 276, 277, -1, 279, 280, -1, -1, 275, -1, 275,
376 278, -1, 278, 276, 277, -1, 279, 280, 299, -1,
377 272, -1, 290, 299, 290, 293, -1, 293, 2, 3,
378 -1, -1, 6, -1, -1, -1, 299, -1, -1, -1,
379 mike 1.1 -1, -1, -1, 295, 296, 297, 298, 21, 300, 301,
380 -1, -1, -1, 27, -1, 29, -1, -1, -1, -1,
381 -1, -1, -1, -1, -1, -1, -1, -1, 42, -1,
382 44, -1, 258, 259, 260, 261, 262, 263, 264, 265,
383 266, 267, 268, 269, 270, 271, -1, -1, 62, 63,
384 276, 277, -1, 279, 280, -1, -1, -1, -1, 73,
385 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
386 -1, -1, -1, 299, -1, -1, -1, -1, -1, -1,
387 -1, 95, -1, -1, -1, -1, -1, -1, -1, -1,
388 -1, -1, -1, 107, 108, -1, -1, -1, -1, -1,
389 -1, -1, -1, -1, 118, -1, 120, 258, 259, 260,
390 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
391 271, -1, -1, -1, -1, -1, -1, -1, -1, -1,
392 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
393 -1, -1, -1, -1, -1, 159, 160, -1, -1, -1,
394 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
395 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
396 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
397 194, 195,
398 };
399 #define YYFINAL 7
400 mike 1.1 #ifndef YYDEBUG
401 #define YYDEBUG 0
402 #endif
403 #define YYMAXTOKEN 301
404 #if YYDEBUG
405 static const char *yyname[] = {
406
407 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
408 0,0,0,0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,"':'","';'",0,"'='",
409 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0,"']'",0,0,0,0,
410 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,
411 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
412 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
413 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
414 0,0,0,"TOK_ERROR","TOK_BOOLEAN","TOK_SINT8","TOK_UINT8","TOK_SINT16",
415 "TOK_UINT16","TOK_SINT32","TOK_UINT32","TOK_SINT64","TOK_UINT64","TOK_REAL32",
416 "TOK_REAL64","TOK_DATETIME","TOK_CHAR16","TOK_STRING","TOK_BOOLEAN_VALUE",
417 "TOK_REF","TOK_SCOPE","TOK_CLASS","TOK_ASSOCIATION","TOK_INDICATION",
418 "TOK_QUALIFIER","TOK_PROPERTY","TOK_REFERENCE","TOK_METHOD","TOK_PARAMETER",
419 "TOK_ANY","TOK_FLAVOR","TOK_ENABLEOVERRIDE","TOK_DISABLEOVERRIDE",
420 "TOK_RESTRICTED","TOK_TOSUBCLASS","TOK_TRANSLATABLE","TOK_INSTANCE","TOK_OF",
421 mike 1.1 "TOK_AS","TOK_PRAGMA","TOK_SCHEMA","TOK_INTEGER_VALUE","TOK_REAL_VALUE",
422 "TOK_STRING_VALUE","TOK_CHAR_VALUE","TOK_IDENT","TOK_ALIAS_IDENTIFIER",
423 "TOK_NULL",
424 };
425 static const char *yyrule[] = {
426 "$accept : mofSpecification",
427 "mofSpecification : mofProduction",
428 "mofSpecification : mofSpecification mofProduction",
429 "mofSpecification : TOK_ERROR",
430 "mofProduction : compilerDirective",
431 "mofProduction : classDeclaration",
432 "mofProduction : qualifierDeclaration",
433 "mofProduction : instanceDeclaration",
434 "compilerDirective : TOK_PRAGMA TOK_IDENT '(' stringValue ')'",
435 "classDeclaration : TOK_CLASS identifier classBody",
436 "classDeclaration : TOK_CLASS identifier ':' identifier classBody",
437 "classDeclaration : qualifierExpr TOK_CLASS identifier classBody",
438 "classDeclaration : qualifierExpr TOK_CLASS identifier ':' identifier classBody",
439 "classBody : '{' classFeatureList '}' ';'",
440 "classBody : '{' '}' ';'",
441 "classFeatureList : propertyDeclaration",
442 mike 1.1 "classFeatureList : methodDeclaration",
443 "classFeatureList : referenceDeclaration",
444 "classFeatureList : classFeatureList propertyDeclaration",
445 "classFeatureList : classFeatureList methodDeclaration",
446 "classFeatureList : classFeatureList referenceDeclaration",
447 "qualifierExpr : '[' qualifierList ']'",
448 "qualifierList : qualifier",
449 "qualifierList : qualifierList ',' qualifier",
450 "qualifier : identifier",
451 "qualifier : identifier qualifierParameter",
452 "qualifier : identifier ':' flavor",
453 "qualifier : identifier qualifierParameter ':' flavor",
454 "qualifierParameter : '(' constantValue ')'",
455 "qualifierParameter : arrayInitializer",
456 "flavorList : flavor",
457 "flavorList : flavorList ',' flavor",
458 "flavor : TOK_ENABLEOVERRIDE",
459 "flavor : TOK_DISABLEOVERRIDE",
460 "flavor : TOK_RESTRICTED",
461 "flavor : TOK_TOSUBCLASS",
462 "flavor : TOK_TRANSLATABLE",
463 mike 1.1 "propertyDeclaration : dataType identifier ';'",
464 "propertyDeclaration : qualifierExpr dataType identifier ';'",
465 "propertyDeclaration : dataType identifier subscript ';'",
466 "propertyDeclaration : qualifierExpr dataType identifier subscript ';'",
467 "propertyDeclaration : dataType identifier '=' initializer ';'",
468 "propertyDeclaration : qualifierExpr dataType identifier '=' initializer ';'",
469 "propertyDeclaration : dataType identifier subscript '=' initializer ';'",
470 "propertyDeclaration : qualifierExpr dataType identifier subscript '=' initializer ';'",
471 "referenceDeclaration : objectRef identifier ';'",
472 "referenceDeclaration : qualifierExpr objectRef identifier ';'",
473 "referenceDeclaration : objectRef identifier initializer ';'",
474 "referenceDeclaration : qualifierExpr objectRef identifier initializer ';'",
475 "methodDeclaration : dataType identifier '(' parameterList ')' ';'",
476 "methodDeclaration : qualifierExpr dataType identifier '(' parameterList ')' ';'",
477 "methodDeclaration : dataType identifier '(' ')' ';'",
478 "methodDeclaration : qualifierExpr dataType identifier '(' ')' ';'",
479 "dataType : TOK_BOOLEAN",
480 "dataType : TOK_SINT8",
481 "dataType : TOK_UINT8",
482 "dataType : TOK_SINT16",
483 "dataType : TOK_UINT16",
484 mike 1.1 "dataType : TOK_SINT32",
485 "dataType : TOK_UINT32",
486 "dataType : TOK_SINT64",
487 "dataType : TOK_UINT64",
488 "dataType : TOK_REAL32",
489 "dataType : TOK_REAL64",
490 "dataType : TOK_CHAR16",
491 "dataType : TOK_DATETIME",
492 "dataType : TOK_STRING",
493 "objectRef : identifier TOK_REF",
494 "parameterList : parameter",
495 "parameterList : parameterList ',' parameter",
496 "parameter : dataType identifier",
497 "parameter : objectRef identifier",
498 "parameter : qualifierExpr dataType identifier",
499 "parameter : qualifierExpr objectRef identifier",
500 "parameter : dataType identifier subscript",
501 "parameter : objectRef identifier subscript",
502 "parameter : qualifierExpr dataType identifier subscript",
503 "parameter : qualifierExpr objectRef identifier subscript",
504 "subscript : '[' TOK_INTEGER_VALUE ']'",
505 mike 1.1 "subscript : '[' ']'",
506 "initializer : constantValue",
507 "initializer : arrayInitializer",
508 "initializer : TOK_ALIAS_IDENTIFIER",
509 "arrayInitializer : '{' arrayInitializerList '}'",
510 "arrayInitializerList : constantValue",
511 "arrayInitializerList : arrayInitializerList ',' constantValue",
512 "constantValue : TOK_INTEGER_VALUE",
513 "constantValue : TOK_REAL_VALUE",
514 "constantValue : TOK_CHAR_VALUE",
515 "constantValue : stringValue",
516 "constantValue : TOK_BOOLEAN_VALUE",
517 "constantValue : TOK_NULL",
518 "stringValue : TOK_STRING_VALUE",
519 "stringValue : stringValue TOK_STRING_VALUE",
520 "qualifierDeclaration : TOK_QUALIFIER identifier qualifierType scopeExpr ';'",
521 "qualifierDeclaration : TOK_QUALIFIER identifier qualifierType scopeExpr flavorExpr ';'",
522 "qualifierType : ':' dataType",
523 "qualifierType : ':' dataType '=' initializer",
524 "qualifierType : ':' dataType subscript",
525 "qualifierType : ':' dataType subscript '=' initializer",
526 mike 1.1 "scopeExpr : ',' TOK_SCOPE '(' scopeList ')'",
527 "scopeList : scope",
528 "scopeList : scopeList ',' scope",
529 "scope : TOK_CLASS",
530 "scope : TOK_ASSOCIATION",
531 "scope : TOK_INDICATION",
532 "scope : TOK_PROPERTY",
533 "scope : TOK_REFERENCE",
534 "scope : TOK_METHOD",
535 "scope : TOK_PARAMETER",
536 "scope : TOK_ANY",
537 "flavorExpr : ',' TOK_FLAVOR '(' flavorList ')'",
538 "instanceDeclaration : TOK_INSTANCE TOK_OF identifier instanceBody",
539 "instanceDeclaration : qualifierExpr TOK_INDICATION TOK_OF identifier instanceBody",
540 "instanceDeclaration : TOK_INSTANCE TOK_OF identifier alias instanceBody",
541 "instanceDeclaration : qualifierExpr TOK_INDICATION TOK_OF identifier alias instanceBody",
542 "instanceBody : '{' valueInitializerList '}' ';'",
543 "alias : TOK_AS TOK_ALIAS_IDENTIFIER",
544 "valueInitializerList : valueInitializer",
545 "valueInitializerList : valueInitializerList valueInitializer",
546 "valueInitializer : identifier '=' initializer ';'",
547 mike 1.1 "valueInitializer : qualifierExpr identifier '=' initializer ';'",
548 "identifier : TOK_IDENT",
549 "identifier : TOK_ASSOCIATION",
550 "identifier : TOK_INDICATION",
551 "identifier : TOK_REFERENCE",
552 "identifier : TOK_PROPERTY",
553
554 };
555 #endif
556
557 int yydebug;
558 int yynerrs;
559
560 int yyerrflag;
561 int yychar;
562 YYSTYPE yyval;
563 YYSTYPE yylval;
564
565 /* define the initial stack-sizes */
566 #ifdef YYSTACKSIZE
567 #undef YYMAXDEPTH
568 mike 1.1 #define YYMAXDEPTH YYSTACKSIZE
569 #else
570 #ifdef YYMAXDEPTH
571 #define YYSTACKSIZE YYMAXDEPTH
572 #else
573 #define YYSTACKSIZE 500
574 #define YYMAXDEPTH 500
575 #endif
576 #endif
577
578 #define YYINITSTACKSIZE 500
579
580 typedef struct {
581 unsigned stacksize;
582 short *s_base;
583 short *s_mark;
584 short *s_last;
585 YYSTYPE *l_base;
586 YYSTYPE *l_mark;
587 } YYSTACKDATA;
588 /* variables for the parser stack */
589 mike 1.1 static YYSTACKDATA yystack;
590
591 #if YYDEBUG
592 #include <stdio.h> /* needed for printf */
593 #endif
594
595 #include <stdlib.h> /* needed for malloc, etc */
596 #include <string.h> /* needed for memset */
597
598 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
599 static int yygrowstack(YYSTACKDATA *data)
600 {
601 int i;
602 unsigned newsize;
603 short *newss;
604 YYSTYPE *newvs;
605
606 if ((newsize = data->stacksize) == 0)
607 newsize = YYINITSTACKSIZE;
608 else if (newsize >= YYMAXDEPTH)
609 return -1;
610 mike 1.1 else if ((newsize *= 2) > YYMAXDEPTH)
611 newsize = YYMAXDEPTH;
612
613 i = data->s_mark - data->s_base;
614 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
615 if (newss == 0)
616 return -1;
617
618 data->s_base = newss;
619 data->s_mark = newss + i;
620
621 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
622 if (newvs == 0)
623 return -1;
624
625 data->l_base = newvs;
626 data->l_mark = newvs + i;
627
628 data->stacksize = newsize;
629 data->s_last = data->s_base + newsize - 1;
630 return 0;
631 mike 1.1 }
632
633 #if YYPURE || defined(YY_NO_LEAKS)
634 static void yyfreestack(YYSTACKDATA *data)
635 {
636 free(data->s_base);
637 free(data->l_base);
638 memset(data, 0, sizeof(*data));
639 }
640 #else
641 #define yyfreestack(data) /* nothing */
642 #endif
643
644 #define YYABORT goto yyabort
645 #define YYREJECT goto yyabort
646 #define YYACCEPT goto yyaccept
647 #define YYERROR goto yyerrlab
648
649 int
650 YYPARSE_DECL()
651 {
652 mike 1.1 int yym, yyn, yystate;
653 #if YYDEBUG
654 const char *yys;
655
656 if ((yys = getenv("YYDEBUG")) != 0)
657 {
658 yyn = *yys;
659 if (yyn >= '0' && yyn <= '9')
660 yydebug = yyn - '0';
661 }
662 #endif
663
664 yynerrs = 0;
665 yyerrflag = 0;
666 yychar = YYEMPTY;
667 yystate = 0;
668
669 #if YYPURE
670 memset(&yystack, 0, sizeof(yystack));
671 #endif
672
673 mike 1.1 if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
674 yystack.s_mark = yystack.s_base;
675 yystack.l_mark = yystack.l_base;
676 yystate = 0;
677 *yystack.s_mark = 0;
678
679 yyloop:
680 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
681 if (yychar < 0)
682 {
683 if ((yychar = YYLEX) < 0) yychar = 0;
684 #if YYDEBUG
685 if (yydebug)
686 {
687 yys = 0;
688 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
689 if (!yys) yys = "illegal-symbol";
690 printf("%sdebug: state %d, reading %d (%s)\n",
691 YYPREFIX, yystate, yychar, yys);
692 }
693 #endif
694 mike 1.1 }
695 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
696 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
697 {
698 #if YYDEBUG
699 if (yydebug)
700 printf("%sdebug: state %d, shifting to state %d\n",
701 YYPREFIX, yystate, yytable[yyn]);
702 #endif
703 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
704 {
705 goto yyoverflow;
706 }
707 yystate = yytable[yyn];
708 *++yystack.s_mark = yytable[yyn];
709 *++yystack.l_mark = yylval;
710 yychar = YYEMPTY;
711 if (yyerrflag > 0) --yyerrflag;
712 goto yyloop;
713 }
714 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
715 mike 1.1 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
716 {
717 yyn = yytable[yyn];
718 goto yyreduce;
719 }
720 if (yyerrflag) goto yyinrecovery;
721
722 yyerror("syntax error");
723
724 goto yyerrlab;
725
726 yyerrlab:
727 ++yynerrs;
728
729 yyinrecovery:
730 if (yyerrflag < 3)
731 {
732 yyerrflag = 3;
733 for (;;)
734 {
735 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
736 mike 1.1 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
737 {
738 #if YYDEBUG
739 if (yydebug)
740 printf("%sdebug: state %d, error recovery shifting\
741 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
742 #endif
743 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
744 {
745 goto yyoverflow;
746 }
747 yystate = yytable[yyn];
748 *++yystack.s_mark = yytable[yyn];
749 *++yystack.l_mark = yylval;
750 goto yyloop;
751 }
752 else
753 {
754 #if YYDEBUG
755 if (yydebug)
756 printf("%sdebug: error recovery discarding state %d\n",
757 mike 1.1 YYPREFIX, *yystack.s_mark);
758 #endif
759 if (yystack.s_mark <= yystack.s_base) goto yyabort;
760 --yystack.s_mark;
761 --yystack.l_mark;
762 }
763 }
764 }
765 else
766 {
767 if (yychar == 0) goto yyabort;
768 #if YYDEBUG
769 if (yydebug)
770 {
771 yys = 0;
772 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
773 if (!yys) yys = "illegal-symbol";
774 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
775 YYPREFIX, yystate, yychar, yys);
776 }
777 #endif
778 mike 1.1 yychar = YYEMPTY;
779 goto yyloop;
780 }
781
782 yyreduce:
783 #if YYDEBUG
784 if (yydebug)
785 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
786 YYPREFIX, yystate, yyn, yyrule[yyn]);
787 #endif
788 yym = yylen[yyn];
789 if (yym)
790 yyval = yystack.l_mark[1-yym];
791 else
792 memset(&yyval, 0, sizeof yyval);
793 switch (yyn)
794 {
795 case 1:
796 #line 139 "mof.y"
797 {
798 }
799 mike 1.1 break;
800 case 2:
801 #line 142 "mof.y"
802 {
803 }
804 break;
805 case 3:
806 #line 145 "mof.y"
807 {
808 YYABORT;
809 }
810 break;
811 case 4:
812 #line 151 "mof.y"
813 {
814 }
815 break;
816 case 5:
817 #line 154 "mof.y"
818 {
819 /* [TODO: validate the class here] */
820 mike 1.1 yystack.l_mark[0].classDeclaration->flags = MI_FLAG_CLASS;
821 yystack.l_mark[0].classDeclaration->flags |= GetQualFlags(yystack.l_mark[0].classDeclaration->qualifiers, yystack.l_mark[0].classDeclaration->numQualifiers);
822 if (FinalizeClass(yystack.l_mark[0].classDeclaration) != 0)
823 YYABORT;
824
825 AddClassDecl(yystack.l_mark[0].classDeclaration);
826
827 if (state.classDeclCallback)
828 (*state.classDeclCallback)(yystack.l_mark[0].classDeclaration, state.classDeclCallbackData);
829 }
830 break;
831 case 6:
832 #line 167 "mof.y"
833 {
834 AddQualifierDeclaration(yystack.l_mark[0].qualifierDeclaration);
835
836 if (state.qualifierDeclCallback)
837 (*state.qualifierDeclCallback)(yystack.l_mark[0].qualifierDeclaration, state.qualifierDeclCallbackData);
838 }
839 break;
840 case 7:
841 mike 1.1 #line 174 "mof.y"
842 {
843 if (FinalizeInstance(yystack.l_mark[0].instanceDeclaration) != 0)
844 YYABORT;
845
846 AddInstanceDecl(yystack.l_mark[0].instanceDeclaration);
847
848 if (state.instanceDeclCallback)
849 (*state.instanceDeclCallback)(yystack.l_mark[0].instanceDeclaration, state.instanceDeclCallbackData);
850 }
851 break;
852 case 8:
853 #line 186 "mof.y"
854 {
855 if (strcmp(yystack.l_mark[-3].string, "include") == 0)
856 {
857 if (openIncludeFile(yystack.l_mark[-1].string) != 0)
858 YYABORT;
859 }
860 else if (strcmp(yystack.l_mark[-3].string, "instancelocale") == 0)
861 {
862 mike 1.1 if (state.pragmaCallback)
863 (*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);
864 }
865 else if (strcmp(yystack.l_mark[-3].string, "locale") == 0)
866 {
867 if (state.pragmaCallback)
868 (*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);
869 }
870 else if (strcmp(yystack.l_mark[-3].string, "namespace") == 0)
871 {
872 if (state.pragmaCallback)
873 (*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);
874 }
875 else
876 {
877 yywarnf(ID_UNKNOWN_PRAGMA,
878 "warning: unknown pragma: %s=%s", yystack.l_mark[-3].string, yystack.l_mark[-1].string);
879
880 if (state.pragmaCallback)
881 (*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);
882 }
883 mike 1.1 }
884 break;
885 case 9:
886 #line 219 "mof.y"
887 {
888 /* Check whether class already exists */
889 if (FindClassDecl(yystack.l_mark[-1].string))
890 {
891 yyerrorf(ID_CLASS_ALREADY_DEFINED,
892 "class already defined: \"%s\"", yystack.l_mark[-1].string);
893 YYABORT;
894 }
895
896 yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);
897 yyval.classDeclaration->flags = MI_FLAG_CLASS;
898 yyval.classDeclaration->name = yystack.l_mark[-1].string;
899 yyval.classDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
900 yyval.classDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
901 yyval.classDeclaration->methods = yystack.l_mark[0].featureList.methodList.data;
902 yyval.classDeclaration->numMethods = yystack.l_mark[0].featureList.methodList.size;
903 }
904 mike 1.1 break;
905 case 10:
906 #line 237 "mof.y"
907 {
908 const MI_ClassDecl* scd;
909
910 /* Check whether class already exists */
911 if (FindClassDecl(yystack.l_mark[-3].string))
912 {
913 yyerrorf(ID_CLASS_ALREADY_DEFINED,
914 "class already defined: \"%s\"", yystack.l_mark[-3].string);
915 YYABORT;
916 }
917
918 /* Check whether superclass exists */
919 scd = FindClassDecl(yystack.l_mark[-1].string);
920
921 if (!scd)
922 {
923 yyerrorf(ID_UNDEFINED_SUPERCLASS,
924 "super class of \"%s\" is undefined: \"%s\"", yystack.l_mark[-3].string, yystack.l_mark[-1].string);
925 mike 1.1 YYABORT;
926 }
927
928 yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);
929 yyval.classDeclaration->flags = MI_FLAG_CLASS;
930 yyval.classDeclaration->name = yystack.l_mark[-3].string;
931 yyval.classDeclaration->superClass = yystack.l_mark[-1].string;
932 yyval.classDeclaration->superClassDecl = (MI_ClassDecl*)scd;
933 yyval.classDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
934 yyval.classDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
935 yyval.classDeclaration->methods = yystack.l_mark[0].featureList.methodList.data;
936 yyval.classDeclaration->numMethods = yystack.l_mark[0].featureList.methodList.size;
937 }
938 break;
939 case 11:
940 #line 269 "mof.y"
941 {
942 /* Check qualifier scope */
943 if (CheckScope(MI_FLAG_CLASS, &yystack.l_mark[-3].qualifierList) != 0)
944 YYABORT;
945
946 mike 1.1 /* Check whether class already exists */
947 if (FindClassDecl(yystack.l_mark[-1].string))
948 {
949 yyerrorf(ID_CLASS_ALREADY_DEFINED,
950 "class already defined: \"%s\"", yystack.l_mark[-1].string);
951 YYABORT;
952 }
953
954 yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);
955 yyval.classDeclaration->flags = MI_FLAG_CLASS;
956 yyval.classDeclaration->name = yystack.l_mark[-1].string;
957 yyval.classDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
958 yyval.classDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
959 yyval.classDeclaration->methods = yystack.l_mark[0].featureList.methodList.data;
960 yyval.classDeclaration->numMethods = yystack.l_mark[0].featureList.methodList.size;
961 yyval.classDeclaration->qualifiers = yystack.l_mark[-3].qualifierList.data;
962 yyval.classDeclaration->numQualifiers = yystack.l_mark[-3].qualifierList.size;
963 }
964 break;
965 case 12:
966 #line 293 "mof.y"
967 mike 1.1 {
968 const MI_ClassDecl* scd;
969
970 /* Check qualifier scope */
971 if (CheckScope(MI_FLAG_CLASS, &yystack.l_mark[-5].qualifierList) != 0)
972 YYABORT;
973
974 /* Check whether class already exists */
975 if (FindClassDecl(yystack.l_mark[-3].string))
976 {
977 yyerrorf(ID_CLASS_ALREADY_DEFINED,
978 "class already defined: \"%s\"", yystack.l_mark[-3].string);
979 YYABORT;
980 }
981
982 /* Check whether superclass exists */
983 scd = FindClassDecl(yystack.l_mark[-1].string);
984
985 if (!scd)
986 {
987 yyerrorf(ID_UNDEFINED_SUPERCLASS,
988 mike 1.1 "super class of \"%s\" is undefined: \"%s\"", yystack.l_mark[-3].string, yystack.l_mark[-1].string);
989 YYABORT;
990 }
991
992 yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);
993 yyval.classDeclaration->flags = MI_FLAG_CLASS;
994 yyval.classDeclaration->name = yystack.l_mark[-3].string;
995 yyval.classDeclaration->superClass = scd->name;
996 yyval.classDeclaration->superClassDecl = (MI_ClassDecl*)scd;
997 yyval.classDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
998 yyval.classDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
999 yyval.classDeclaration->methods = yystack.l_mark[0].featureList.methodList.data;
1000 yyval.classDeclaration->numMethods = yystack.l_mark[0].featureList.methodList.size;
1001 yyval.classDeclaration->qualifiers = yystack.l_mark[-5].qualifierList.data;
1002 yyval.classDeclaration->numQualifiers = yystack.l_mark[-5].qualifierList.size;
1003 }
1004 break;
1005 case 13:
1006 #line 333 "mof.y"
1007 {
1008 yyval.featureList = yystack.l_mark[-2].featureList;
1009 mike 1.1 }
1010 break;
1011 case 14:
1012 #line 337 "mof.y"
1013 {
1014 yyval.featureList.propertySet.data = NULL;
1015 yyval.featureList.propertySet.size = 0;
1016 yyval.featureList.methodList.data = NULL;
1017 yyval.featureList.methodList.size = 0;
1018 }
1019 break;
1020 case 15:
1021 #line 346 "mof.y"
1022 {
1023 if (CheckPropertyValueConstraints(yystack.l_mark[0].property) != 0)
1024 {
1025 YYABORT;
1026 }
1027 yyval.featureList.propertySet.data = NULL;
1028 yyval.featureList.propertySet.size = 0;
1029 yyval.featureList.methodList.data = NULL;
1030 mike 1.1 yyval.featureList.methodList.size = 0;
1031 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
1032 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
1033 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
1034 }
1035 break;
1036 case 16:
1037 #line 360 "mof.y"
1038 {
1039 yyval.featureList.propertySet.data = NULL;
1040 yyval.featureList.propertySet.size = 0;
1041 yyval.featureList.methodList.data = NULL;
1042 yyval.featureList.methodList.size = 0;
1043 yystack.l_mark[0].methodDecl->flags = MI_FLAG_METHOD;
1044 yystack.l_mark[0].methodDecl->flags |= GetQualFlags(yystack.l_mark[0].methodDecl->qualifiers, yystack.l_mark[0].methodDecl->numQualifiers);
1045 PtrArray_Append((PtrArray*)&yyval.featureList.methodList, yystack.l_mark[0].methodDecl);
1046 }
1047 break;
1048 case 17:
1049 #line 370 "mof.y"
1050 {
1051 mike 1.1 yyval.featureList.propertySet.data = NULL;
1052 yyval.featureList.propertySet.size = 0;
1053 yyval.featureList.methodList.data = NULL;
1054 yyval.featureList.methodList.size = 0;
1055 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
1056 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
1057 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
1058 }
1059 break;
1060 case 18:
1061 #line 380 "mof.y"
1062 {
1063 if (CheckPropertyValueConstraints(yystack.l_mark[0].property) != 0)
1064 {
1065 YYABORT;
1066 }
1067
1068 if (FindProperty(&yystack.l_mark[-1].featureList.propertySet, yystack.l_mark[0].property->name))
1069 {
1070 yyerrorf(ID_CLASS_FEATURE_ALREADY_DEFINED,
1071 "class feature already defined: \"%s\"", yystack.l_mark[0].property->name);
1072 mike 1.1 YYABORT;
1073 }
1074
1075 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
1076 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
1077 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
1078 }
1079 break;
1080 case 19:
1081 #line 398 "mof.y"
1082 {
1083 if (FindMethod(&yystack.l_mark[-1].featureList.methodList, yystack.l_mark[0].methodDecl->name))
1084 {
1085 yyerrorf(ID_CLASS_FEATURE_ALREADY_DEFINED,
1086 "class feature already defined: \"%s\"", yystack.l_mark[0].methodDecl->name);
1087 YYABORT;
1088 }
1089
1090 yystack.l_mark[0].methodDecl->flags = MI_FLAG_METHOD;
1091 yystack.l_mark[0].methodDecl->flags |= GetQualFlags(yystack.l_mark[0].methodDecl->qualifiers, yystack.l_mark[0].methodDecl->numQualifiers);
1092 PtrArray_Append((PtrArray*)&yyval.featureList.methodList, yystack.l_mark[0].methodDecl);
1093 mike 1.1 }
1094 break;
1095 case 20:
1096 #line 411 "mof.y"
1097 {
1098 if (FindProperty(&yystack.l_mark[-1].featureList.propertySet, yystack.l_mark[0].property->name))
1099 {
1100 yyerrorf(ID_CLASS_FEATURE_ALREADY_DEFINED,
1101 "class feature already defined: \"%s\"", yystack.l_mark[0].property->name);
1102 YYABORT;
1103 }
1104
1105 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
1106 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
1107 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
1108 }
1109 break;
1110 case 21:
1111 #line 426 "mof.y"
1112 {
1113 yyval.qualifierList = yystack.l_mark[-1].qualifierList;
1114 mike 1.1 }
1115 break;
1116 case 22:
1117 #line 432 "mof.y"
1118 {
1119 yyval.qualifierList.data = NULL;
1120 yyval.qualifierList.size = 0;
1121 PtrArray_Append((PtrArray*)&yyval.qualifierList, yystack.l_mark[0].qualifier);
1122 }
1123 break;
1124 case 23:
1125 #line 438 "mof.y"
1126 {
1127 if (FindQualifier(&yystack.l_mark[-2].qualifierList, yystack.l_mark[0].qualifier->name))
1128 {
1129 yyerrorf(ID_DUPLICATE_QUALIFIER,
1130 "duplicate qualifier: \"%s\"", yystack.l_mark[0].qualifier->name);
1131 YYABORT;
1132 }
1133
1134 PtrArray_Append((PtrArray*)&yyval.qualifierList, yystack.l_mark[0].qualifier);
1135 mike 1.1 }
1136 break;
1137 case 24:
1138 #line 451 "mof.y"
1139 {
1140 MI_Qualifier* q;
1141 const MI_QualifierDecl* qd;
1142
1143 qd = FindQualifierDeclaration(yystack.l_mark[0].string);
1144
1145 if (!qd)
1146 {
1147 yyerrorf(ID_UNDEFINED_QUALIFIER, "undefined qualifier: \"%s\"", yystack.l_mark[0].string);
1148 YYABORT;
1149 }
1150
1151 if (qd->type != MI_BOOLEAN)
1152 {
1153 yyerrorf(ID_MISSING_QUALIFIER_INITIALIZER,
1154 "qualifier is missing initializer: \"%s\"", yystack.l_mark[0].string);
1155 YYABORT;
1156 mike 1.1 }
1157
1158
1159 q = CALLOC_T(MI_Qualifier, 1);
1160 q->name = qd->name; /* use casing of qualifier declaration name */
1161 q->type = qd->type;
1162 q->flavor = qd->flavor;
1163 q->value = NewTrueValue();
1164 yyval.qualifier = q;
1165 }
1166 break;
1167 case 25:
1168 #line 479 "mof.y"
1169 {
1170 MI_Qualifier* q;
1171 const MI_QualifierDecl* qd;
1172 void* value;
1173
1174 qd = FindQualifierDeclaration(yystack.l_mark[-1].string);
1175
1176 if (!qd)
1177 mike 1.1 {
1178 yyerrorf(ID_UNDEFINED_QUALIFIER, "undefined qualifier: \"%s\"", yystack.l_mark[-1].string);
1179 YYABORT;
1180 }
1181
1182 if (InitializerToValue(&yystack.l_mark[0].initializer, qd->type, &value) != 0)
1183 {
1184 yyerrorf(ID_INVALID_QUALIFIER_INITIALIZER,
1185 "invalid initializer for qualifer: \"%s\"", yystack.l_mark[-1].string);
1186 YYABORT;
1187 }
1188
1189 q = CALLOC_T(MI_Qualifier, 1);
1190 q->name = qd->name; /* use casing of qualifier declaration name */
1191 q->type = qd->type;
1192 q->flavor = qd->flavor;
1193 q->value = value;
1194 yyval.qualifier = q;
1195 }
1196 break;
1197 case 26:
1198 mike 1.1 #line 507 "mof.y"
1199 {
1200 MI_Qualifier* q;
1201 const MI_QualifierDecl* qd;
1202
1203 qd = FindQualifierDeclaration(yystack.l_mark[-2].string);
1204
1205 if (!qd)
1206 {
1207 yyerrorf(ID_UNDEFINED_QUALIFIER, "undefined qualifier: \"%s\"", yystack.l_mark[-2].string);
1208 YYABORT;
1209 }
1210
1211 if (qd->type != MI_BOOLEAN)
1212 {
1213 yyerrorf(ID_MISSING_QUALIFIER_INITIALIZER,
1214 "qualifier is missing initializer: \"%s\"", yystack.l_mark[-2].string);
1215 YYABORT;
1216 }
1217
1218 q = CALLOC_T(MI_Qualifier, 1);
1219 mike 1.1 q->name = qd->name; /* use casing of qualifier declaration name */
1220 q->type = qd->type;
1221 q->flavor = PropagateFlavors(yystack.l_mark[0].flags, qd->flavor);
1222 q->value = NewTrueValue();
1223 yyval.qualifier = q;
1224 }
1225 break;
1226 case 27:
1227 #line 534 "mof.y"
1228 {
1229 MI_Qualifier* q;
1230 const MI_QualifierDecl* qd;
1231 void* value;
1232
1233 qd = FindQualifierDeclaration(yystack.l_mark[-3].string);
1234
1235 if (!qd)
1236 {
1237 yyerrorf(ID_UNDEFINED_QUALIFIER, "undefined qualifier: \"%s\"", yystack.l_mark[-3].string);
1238 YYABORT;
1239 }
1240 mike 1.1
1241 if (InitializerToValue(&yystack.l_mark[-2].initializer, qd->type, &value) != 0)
1242 {
1243 yyerrorf(ID_INVALID_QUALIFIER_INITIALIZER,
1244 "invalid initializer for qualifer: \"%s\"", yystack.l_mark[-3].string);
1245 YYABORT;
1246 }
1247
1248 q = CALLOC_T(MI_Qualifier, 1);
1249 q->name = qd->name; /* use casing of qualifier declaration name */
1250 q->type = qd->type;
1251 q->value = value;
1252 q->flavor = PropagateFlavors(yystack.l_mark[0].flags, qd->flavor);
1253 yyval.qualifier = q;
1254 }
1255 break;
1256 case 28:
1257 #line 564 "mof.y"
1258 {
1259 memset(&yyval.initializer, 0, sizeof(yyval.initializer));
1260 yyval.initializer.data = CALLOC_T(MOF_ConstantValue, 1);
1261 mike 1.1 yyval.initializer.data[0] = yystack.l_mark[-1].constantValue;
1262 yyval.initializer.size = 1;
1263 }
1264 break;
1265 case 29:
1266 #line 571 "mof.y"
1267 {
1268 yyval.initializer = yystack.l_mark[0].initializer;
1269 }
1270 break;
1271 case 30:
1272 #line 577 "mof.y"
1273 {
1274 yyval.flags = yystack.l_mark[0].flags;
1275 }
1276 break;
1277 case 31:
1278 #line 581 "mof.y"
1279 {
1280 yyval.flags |= yystack.l_mark[0].flags;
1281 }
1282 mike 1.1 break;
1283 case 32:
1284 #line 587 "mof.y"
1285 {
1286 yyval.flags = MI_FLAG_ENABLEOVERRIDE;
1287 }
1288 break;
1289 case 33:
1290 #line 591 "mof.y"
1291 {
1292 yyval.flags = MI_FLAG_DISABLEOVERRIDE;
1293 }
1294 break;
1295 case 34:
1296 #line 595 "mof.y"
1297 {
1298 yyval.flags = MI_FLAG_RESTRICTED;
1299 }
1300 break;
1301 case 35:
1302 #line 599 "mof.y"
1303 mike 1.1 {
1304 yyval.flags = MI_FLAG_TOSUBCLASS;
1305 }
1306 break;
1307 case 36:
1308 #line 603 "mof.y"
1309 {
1310 yyval.flags = MI_FLAG_TRANSLATABLE;
1311 }
1312 break;
1313 case 37:
1314 #line 609 "mof.y"
1315 {
1316 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1317 yyval.property->name = yystack.l_mark[-1].string;
1318 yyval.property->type = yystack.l_mark[-2].type;
1319 }
1320 break;
1321 case 38:
1322 #line 615 "mof.y"
1323 {
1324 mike 1.1 /* Check qualifier scope */
1325 if (CheckScope(MI_FLAG_PROPERTY, &yystack.l_mark[-3].qualifierList) != 0)
1326 YYABORT;
1327
1328 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1329 yyval.property->name = yystack.l_mark[-1].string;
1330 yyval.property->type = yystack.l_mark[-2].type;
1331 yyval.property->qualifiers = yystack.l_mark[-3].qualifierList.data;
1332 yyval.property->numQualifiers = yystack.l_mark[-3].qualifierList.size;
1333 }
1334 break;
1335 case 39:
1336 #line 627 "mof.y"
1337 {
1338 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1339 yyval.property->name = yystack.l_mark[-2].string;
1340 yyval.property->type = ARRAYOF(yystack.l_mark[-3].type);
1341 yyval.property->subscript = (MI_Uint32)yystack.l_mark[-1].integer;
1342 }
1343 break;
1344 case 40:
1345 mike 1.1 #line 634 "mof.y"
1346 {
1347 /* Check qualifier scope */
1348 if (CheckScope(MI_FLAG_PROPERTY, &yystack.l_mark[-4].qualifierList) != 0)
1349 YYABORT;
1350
1351 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1352 yyval.property->name = yystack.l_mark[-2].string;
1353 yyval.property->type = ARRAYOF(yystack.l_mark[-3].type);
1354 yyval.property->qualifiers = yystack.l_mark[-4].qualifierList.data;
1355 yyval.property->numQualifiers = yystack.l_mark[-4].qualifierList.size;
1356 yyval.property->subscript = (MI_Uint32)yystack.l_mark[-1].integer;
1357 }
1358 break;
1359 case 41:
1360 #line 647 "mof.y"
1361 {
1362 void* value;
1363
1364 if (InitializerToValue(&yystack.l_mark[-1].initializer, yystack.l_mark[-4].type, &value) != 0)
1365 {
1366 mike 1.1 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
1367 YYABORT;
1368 }
1369
1370 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1371 yyval.property->name = yystack.l_mark[-3].string;
1372 yyval.property->type = yystack.l_mark[-4].type;
1373 yyval.property->value = value;
1374 }
1375 break;
1376 case 42:
1377 #line 662 "mof.y"
1378 {
1379 void* value;
1380
1381 /* Check qualifier scope */
1382 if (CheckScope(MI_FLAG_PROPERTY, &yystack.l_mark[-5].qualifierList) != 0)
1383 YYABORT;
1384
1385 if (InitializerToValue(&yystack.l_mark[-1].initializer, yystack.l_mark[-4].type, &value) != 0)
1386 {
1387 mike 1.1 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
1388 YYABORT;
1389 }
1390
1391 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1392 yyval.property->name = yystack.l_mark[-3].string;
1393 yyval.property->type = yystack.l_mark[-4].type;
1394 yyval.property->qualifiers = yystack.l_mark[-5].qualifierList.data;
1395 yyval.property->numQualifiers = yystack.l_mark[-5].qualifierList.size;
1396 yyval.property->value = value;
1397 }
1398 break;
1399 case 43:
1400 #line 683 "mof.y"
1401 {
1402 void* value;
1403
1404 if (InitializerToValue(&yystack.l_mark[-1].initializer, ARRAYOF(yystack.l_mark[-5].type), &value) != 0)
1405 {
1406 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
1407 YYABORT;
1408 mike 1.1 }
1409
1410 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1411 yyval.property->name = yystack.l_mark[-4].string;
1412 yyval.property->type = ARRAYOF(yystack.l_mark[-5].type);
1413 yyval.property->subscript = (MI_Uint32)yystack.l_mark[-3].integer;
1414 yyval.property->value = value;
1415 }
1416 break;
1417 case 44:
1418 #line 699 "mof.y"
1419 {
1420 void* value;
1421
1422 /* Check qualifier scope */
1423 if (CheckScope(MI_FLAG_PROPERTY, &yystack.l_mark[-6].qualifierList) != 0)
1424 YYABORT;
1425
1426 if (InitializerToValue(&yystack.l_mark[-1].initializer, ARRAYOF(yystack.l_mark[-5].type), &value) != 0)
1427 {
1428 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
1429 mike 1.1 YYABORT;
1430 }
1431
1432 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1433 yyval.property->name = yystack.l_mark[-4].string;
1434 yyval.property->type = ARRAYOF(yystack.l_mark[-5].type);
1435 yyval.property->qualifiers = yystack.l_mark[-6].qualifierList.data;
1436 yyval.property->numQualifiers = yystack.l_mark[-6].qualifierList.size;
1437 yyval.property->subscript = (MI_Uint32)yystack.l_mark[-3].integer;
1438 yyval.property->value = value;
1439 }
1440 break;
1441 case 45:
1442 #line 723 "mof.y"
1443 {
1444 const MI_ClassDecl* cd;
1445
1446 /* Verify that class exists */
1447 cd = FindClassDecl(yystack.l_mark[-2].string);
1448 if (!cd)
1449 {
1450 mike 1.1 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-2].string);
1451 YYABORT;
1452 }
1453
1454 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1455 yyval.property->type = MI_REFERENCE;
1456 yyval.property->name = yystack.l_mark[-1].string;
1457 yyval.property->className = cd->name;
1458 }
1459 break;
1460 case 46:
1461 #line 740 "mof.y"
1462 {
1463 const MI_ClassDecl* cd;
1464
1465 /* Verify that class exists */
1466 cd = FindClassDecl(yystack.l_mark[-2].string);
1467 if (!cd)
1468 {
1469 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-2].string);
1470 YYABORT;
1471 mike 1.1 }
1472
1473 /* Check qualifier scope */
1474 if (CheckScope(MI_FLAG_REFERENCE, &yystack.l_mark[-3].qualifierList) != 0)
1475 YYABORT;
1476
1477 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1478 yyval.property->type = MI_REFERENCE;
1479 yyval.property->name = yystack.l_mark[-1].string;
1480 yyval.property->className = cd->name;
1481 yyval.property->qualifiers = yystack.l_mark[-3].qualifierList.data;
1482 yyval.property->numQualifiers = yystack.l_mark[-3].qualifierList.size;
1483 }
1484 break;
1485 case 47:
1486 #line 763 "mof.y"
1487 {
1488 const MI_ClassDecl* cd;
1489
1490 /* Verify that class exists */
1491 cd = FindClassDecl(yystack.l_mark[-3].string);
1492 mike 1.1 if (!cd)
1493 {
1494 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-3].string);
1495 YYABORT;
1496 }
1497
1498 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1499 yyval.property->type = MI_REFERENCE;
1500 yyval.property->name = yystack.l_mark[-2].string;
1501 yyval.property->className = cd->name;
1502 yywarnf(ID_IGNORED_INITIALIZER, "warning: ignored initializer");
1503 /* [TODO: use initializer */
1504 }
1505 break;
1506 case 48:
1507 #line 782 "mof.y"
1508 {
1509 const MI_ClassDecl* cd;
1510
1511 /* Verify that class exists */
1512 cd = FindClassDecl(yystack.l_mark[-3].string);
1513 mike 1.1 if (!cd)
1514 {
1515 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-3].string);
1516 YYABORT;
1517 }
1518
1519 /* Check qualifier scope */
1520 if (CheckScope(MI_FLAG_REFERENCE, &yystack.l_mark[-4].qualifierList) != 0)
1521 YYABORT;
1522
1523 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
1524 yyval.property->type = MI_REFERENCE;
1525 yyval.property->name = yystack.l_mark[-2].string;
1526 yyval.property->className = cd->name;
1527 yyval.property->qualifiers = yystack.l_mark[-4].qualifierList.data;
1528 yyval.property->numQualifiers = yystack.l_mark[-4].qualifierList.size;
1529 yywarnf(ID_IGNORED_INITIALIZER, "warning: ignored initializer");
1530 /* [TODO: use initializer */
1531 }
1532 break;
1533 case 49:
1534 mike 1.1 #line 809 "mof.y"
1535 {
1536 yyval.methodDecl = CALLOC_T(MI_MethodDecl, 1);
1537 yyval.methodDecl->name = yystack.l_mark[-4].string;
1538 yyval.methodDecl->parameters = yystack.l_mark[-2].parameterList.data;
1539 yyval.methodDecl->numParameters = yystack.l_mark[-2].parameterList.size;
1540 yyval.methodDecl->returnType = yystack.l_mark[-5].type;
1541 }
1542 break;
1543 case 50:
1544 #line 817 "mof.y"
1545 {
1546 /* Check qualifier scope */
1547 if (CheckScope(MI_FLAG_METHOD, &yystack.l_mark[-6].qualifierList) != 0)
1548 YYABORT;
1549
1550 yyval.methodDecl = CALLOC_T(MI_MethodDecl, 1);
1551 yyval.methodDecl->name = yystack.l_mark[-4].string;
1552 yyval.methodDecl->parameters = yystack.l_mark[-2].parameterList.data;
1553 yyval.methodDecl->numParameters = yystack.l_mark[-2].parameterList.size;
1554 yyval.methodDecl->qualifiers = yystack.l_mark[-6].qualifierList.data;
1555 mike 1.1 yyval.methodDecl->numQualifiers = yystack.l_mark[-6].qualifierList.size;
1556 yyval.methodDecl->returnType = yystack.l_mark[-5].type;
1557 }
1558 break;
1559 case 51:
1560 #line 831 "mof.y"
1561 {
1562 MOF_ParameterList parameterList = PTRARRAY_INITIALIZER;
1563
1564 yyval.methodDecl = CALLOC_T(MI_MethodDecl, 1);
1565 yyval.methodDecl->name = yystack.l_mark[-3].string;
1566 yyval.methodDecl->parameters = parameterList.data;
1567 yyval.methodDecl->numParameters = parameterList.size;
1568 yyval.methodDecl->returnType = yystack.l_mark[-4].type;
1569 }
1570 break;
1571 case 52:
1572 #line 841 "mof.y"
1573 {
1574 MOF_ParameterList parameterList = PTRARRAY_INITIALIZER;
1575
1576 mike 1.1 /* Check qualifier scope */
1577 if (CheckScope(MI_FLAG_METHOD, &yystack.l_mark[-5].qualifierList) != 0)
1578 YYABORT;
1579
1580 yyval.methodDecl = CALLOC_T(MI_MethodDecl, 1);
1581 yyval.methodDecl->name = yystack.l_mark[-3].string;
1582 yyval.methodDecl->parameters = parameterList.data;
1583 yyval.methodDecl->numParameters = parameterList.size;
1584 yyval.methodDecl->qualifiers = yystack.l_mark[-5].qualifierList.data;
1585 yyval.methodDecl->numQualifiers = yystack.l_mark[-5].qualifierList.size;
1586 yyval.methodDecl->returnType = yystack.l_mark[-4].type;
1587 }
1588 break;
1589 case 53:
1590 #line 859 "mof.y"
1591 {
1592 yyval.type = MI_BOOLEAN;
1593 }
1594 break;
1595 case 54:
1596 #line 863 "mof.y"
1597 mike 1.1 {
1598 yyval.type = MI_SINT8;
1599 }
1600 break;
1601 case 55:
1602 #line 867 "mof.y"
1603 {
1604 yyval.type = MI_UINT8;
1605 }
1606 break;
1607 case 56:
1608 #line 871 "mof.y"
1609 {
1610 yyval.type = MI_SINT16;
1611 }
1612 break;
1613 case 57:
1614 #line 875 "mof.y"
1615 {
1616 yyval.type = MI_UINT16;
1617 }
1618 mike 1.1 break;
1619 case 58:
1620 #line 879 "mof.y"
1621 {
1622 yyval.type = MI_SINT32;
1623 }
1624 break;
1625 case 59:
1626 #line 883 "mof.y"
1627 {
1628 yyval.type = MI_UINT32;
1629 }
1630 break;
1631 case 60:
1632 #line 887 "mof.y"
1633 {
1634 yyval.type = MI_SINT64;
1635 }
1636 break;
1637 case 61:
1638 #line 891 "mof.y"
1639 mike 1.1 {
1640 yyval.type = MI_UINT64;
1641 }
1642 break;
1643 case 62:
1644 #line 895 "mof.y"
1645 {
1646 yyval.type = MI_REAL32;
1647 }
1648 break;
1649 case 63:
1650 #line 899 "mof.y"
1651 {
1652 yyval.type = MI_REAL64;
1653 }
1654 break;
1655 case 64:
1656 #line 903 "mof.y"
1657 {
1658 yyval.type = MI_CHAR16;
1659 }
1660 mike 1.1 break;
1661 case 65:
1662 #line 907 "mof.y"
1663 {
1664 yyval.type = MI_DATETIME;
1665 }
1666 break;
1667 case 66:
1668 #line 911 "mof.y"
1669 {
1670 yyval.type = MI_STRING;
1671 }
1672 break;
1673 case 67:
1674 #line 917 "mof.y"
1675 {
1676 yyval.string = yystack.l_mark[-1].string;
1677 }
1678 break;
1679 case 68:
1680 #line 923 "mof.y"
1681 mike 1.1 {
1682 yystack.l_mark[0].parameter->flags = MI_FLAG_PARAMETER;
1683 yystack.l_mark[0].parameter->flags |= GetQualFlags(yystack.l_mark[0].parameter->qualifiers, yystack.l_mark[0].parameter->numQualifiers);
1684 yyval.parameterList.data = NULL;
1685 yyval.parameterList.size = 0;
1686 PtrArray_Append((PtrArray*)&yyval.parameterList, yystack.l_mark[0].parameter);
1687 }
1688 break;
1689 case 69:
1690 #line 931 "mof.y"
1691 {
1692 if (FindParameter(&yystack.l_mark[-2].parameterList, yystack.l_mark[0].parameter->name))
1693 {
1694 yyerrorf(ID_PARAMETER_ALREADY_DEFINED,
1695 "parameter already defined: \"%s\"", yystack.l_mark[0].parameter->name);
1696 YYABORT;
1697 }
1698
1699 yystack.l_mark[0].parameter->flags = MI_FLAG_PARAMETER;
1700 yystack.l_mark[0].parameter->flags |= GetQualFlags(yystack.l_mark[0].parameter->qualifiers, yystack.l_mark[0].parameter->numQualifiers);
1701 PtrArray_Append((PtrArray*)&yyval.parameterList, yystack.l_mark[0].parameter);
1702 mike 1.1 }
1703 break;
1704 case 70:
1705 #line 946 "mof.y"
1706 {
1707 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1708 yyval.parameter->name = yystack.l_mark[0].string;
1709 yyval.parameter->type = yystack.l_mark[-1].type;
1710 }
1711 break;
1712 case 71:
1713 #line 952 "mof.y"
1714 {
1715 const MI_ClassDecl* cd;
1716
1717 /* Verify that class exists */
1718 cd = FindClassDecl(yystack.l_mark[-1].string);
1719 if (!cd)
1720 {
1721 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-1].string);
1722 YYABORT;
1723 mike 1.1 }
1724
1725 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1726 yyval.parameter->name = yystack.l_mark[0].string;
1727 yyval.parameter->type = MI_REFERENCE;
1728 yyval.parameter->className = cd->name;
1729 }
1730 break;
1731 case 72:
1732 #line 969 "mof.y"
1733 {
1734 /* Check qualifier scope */
1735 if (CheckScope(MI_FLAG_PARAMETER, &yystack.l_mark[-2].qualifierList) != 0)
1736 YYABORT;
1737
1738 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1739 yyval.parameter->name = yystack.l_mark[0].string;
1740 yyval.parameter->type = yystack.l_mark[-1].type;
1741 yyval.parameter->qualifiers = yystack.l_mark[-2].qualifierList.data;
1742 yyval.parameter->numQualifiers = yystack.l_mark[-2].qualifierList.size;
1743 }
1744 mike 1.1 break;
1745 case 73:
1746 #line 981 "mof.y"
1747 {
1748 const MI_ClassDecl* cd;
1749
1750 /* Verify that class exists */
1751 cd = FindClassDecl(yystack.l_mark[-1].string);
1752 if (!cd)
1753 {
1754 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-1].string);
1755 YYABORT;
1756 }
1757
1758 /* Check qualifier scope */
1759 if (CheckScope(MI_FLAG_PARAMETER, &yystack.l_mark[-2].qualifierList) != 0)
1760 YYABORT;
1761
1762 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1763 yyval.parameter->name = yystack.l_mark[0].string;
1764 yyval.parameter->type = MI_REFERENCE;
1765 mike 1.1 yyval.parameter->className = cd->name;
1766 yyval.parameter->qualifiers = yystack.l_mark[-2].qualifierList.data;
1767 yyval.parameter->numQualifiers = yystack.l_mark[-2].qualifierList.size;
1768 }
1769 break;
1770 case 74:
1771 #line 1004 "mof.y"
1772 {
1773 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1774 yyval.parameter->name = yystack.l_mark[-1].string;
1775 yyval.parameter->type = ARRAYOF(yystack.l_mark[-2].type);
1776 yyval.parameter->subscript = (MI_Uint32)yystack.l_mark[0].integer;
1777 }
1778 break;
1779 case 75:
1780 #line 1011 "mof.y"
1781 {
1782 const MI_ClassDecl* cd;
1783
1784 /* Verify that class exists */
1785 cd = FindClassDecl(yystack.l_mark[-2].string);
1786 mike 1.1 if (!cd)
1787 {
1788 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-2].string);
1789 YYABORT;
1790 }
1791
1792 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1793 yyval.parameter->name = yystack.l_mark[-1].string;
1794 yyval.parameter->type = ARRAYOF(MI_REFERENCE);
1795 yyval.parameter->className = cd->name;
1796 yyval.parameter->subscript = (MI_Uint32)yystack.l_mark[0].integer;
1797 }
1798 break;
1799 case 76:
1800 #line 1029 "mof.y"
1801 {
1802 /* Check qualifier scope */
1803 if (CheckScope(MI_FLAG_PARAMETER, &yystack.l_mark[-3].qualifierList) != 0)
1804 YYABORT;
1805
1806 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1807 mike 1.1 yyval.parameter->name = yystack.l_mark[-1].string;
1808 yyval.parameter->type = ARRAYOF(yystack.l_mark[-2].type);
1809 yyval.parameter->subscript = (MI_Uint32)yystack.l_mark[0].integer;
1810 yyval.parameter->qualifiers = yystack.l_mark[-3].qualifierList.data;
1811 yyval.parameter->numQualifiers = yystack.l_mark[-3].qualifierList.size;
1812 }
1813 break;
1814 case 77:
1815 #line 1042 "mof.y"
1816 {
1817 const MI_ClassDecl* cd;
1818
1819 /* Verify that class exists */
1820 cd = FindClassDecl(yystack.l_mark[-2].string);
1821 if (!cd)
1822 {
1823 yyerrorf(ID_UNDEFINED_CLASS, "undefined class: \"%s\"", yystack.l_mark[-2].string);
1824 YYABORT;
1825 }
1826
1827 /* Check qualifier scope */
1828 mike 1.1 if (CheckScope(MI_FLAG_PARAMETER, &yystack.l_mark[-3].qualifierList) != 0)
1829 YYABORT;
1830
1831 yyval.parameter = CALLOC_T(MI_ParameterDecl, 1);
1832 yyval.parameter->name = yystack.l_mark[-1].string;
1833 yyval.parameter->type = ARRAYOF(MI_REFERENCE);
1834 yyval.parameter->className = cd->name;
1835 yyval.parameter->subscript = (MI_Uint32)yystack.l_mark[0].integer;
1836 yyval.parameter->qualifiers = yystack.l_mark[-3].qualifierList.data;
1837 yyval.parameter->numQualifiers = yystack.l_mark[-3].qualifierList.size;
1838 }
1839 break;
1840 case 78:
1841 #line 1068 "mof.y"
1842 {
1843 if (yystack.l_mark[-1].integer <= 0)
1844 {
1845 yyerrorf(ID_ILLEGAL_ARRAY_SUBSCRIPT,
1846 "illegal array subscript: " SINT64_FMT, yystack.l_mark[-1].integer);
1847 YYABORT;
1848 }
1849 mike 1.1
1850 yyval.integer = yystack.l_mark[-1].integer;
1851 }
1852 break;
1853 case 79:
1854 #line 1079 "mof.y"
1855 {
1856 /* 0 signifies a dynamic array */
1857 yyval.integer = 0;
1858 }
1859 break;
1860 case 80:
1861 #line 1086 "mof.y"
1862 {
1863 memset(&yyval.initializer, 0, sizeof(yyval.initializer));
1864 yyval.initializer.data = CALLOC_T(MOF_ConstantValue, 1);
1865 yyval.initializer.data[0] = yystack.l_mark[0].constantValue;
1866 yyval.initializer.size = 1;
1867 }
1868 break;
1869 case 81:
1870 mike 1.1 #line 1093 "mof.y"
1871 {
1872 yyval.initializer = yystack.l_mark[0].initializer;
1873 }
1874 break;
1875 case 82:
1876 #line 1097 "mof.y"
1877 {
1878 memset(&yyval.initializer, 0, sizeof(yyval.initializer));
1879 yyval.initializer.data = CALLOC_T(MOF_ConstantValue, 1);
1880 yyval.initializer.data[0].type = TOK_STRING_VALUE;
1881 yyval.initializer.data[0].value.string = yystack.l_mark[0].string;
1882 yyval.initializer.size = 0;
1883 }
1884 break;
1885 case 83:
1886 #line 1107 "mof.y"
1887 {
1888 yyval.initializer = yystack.l_mark[-1].initializer;
1889 }
1890 break;
1891 mike 1.1 case 84:
1892 #line 1113 "mof.y"
1893 {
1894 memset(&yyval.initializer, 0, sizeof(yyval.initializer));
1895 yyval.initializer.data = CALLOC_T(MOF_ConstantValue, 1);
1896 yyval.initializer.data[0] = yystack.l_mark[0].constantValue;
1897 yyval.initializer.size = 1;
1898 yyval.initializer.isArray = 1;
1899 }
1900 break;
1901 case 85:
1902 #line 1121 "mof.y"
1903 {
1904 yystack.l_mark[-2].initializer.data = REALLOC_T(MOF_ConstantValue, yystack.l_mark[-2].initializer.data, yystack.l_mark[-2].initializer.size + 1);
1905 yystack.l_mark[-2].initializer.data[yystack.l_mark[-2].initializer.size] = yystack.l_mark[0].constantValue;
1906 yystack.l_mark[-2].initializer.size++;
1907 yyval.initializer = yystack.l_mark[-2].initializer;
1908 }
1909 break;
1910 case 86:
1911 #line 1130 "mof.y"
1912 mike 1.1 {
1913 yyval.constantValue.type = TOK_INTEGER_VALUE;
1914 yyval.constantValue.value.integer = yystack.l_mark[0].integer;
1915 }
1916 break;
1917 case 87:
1918 #line 1135 "mof.y"
1919 {
1920 yyval.constantValue.type = TOK_REAL_VALUE;
1921 yyval.constantValue.value.real = yystack.l_mark[0].real;
1922 }
1923 break;
1924 case 88:
1925 #line 1140 "mof.y"
1926 {
1927 yyval.constantValue.type = TOK_CHAR_VALUE;
1928 yyval.constantValue.value.character = yystack.l_mark[0].character;
1929 }
1930 break;
1931 case 89:
1932 #line 1145 "mof.y"
1933 mike 1.1 {
1934 yyval.constantValue.type = TOK_STRING_VALUE;
1935 yyval.constantValue.value.string = yystack.l_mark[0].string;
1936 }
1937 break;
1938 case 90:
1939 #line 1150 "mof.y"
1940 {
1941 yyval.constantValue.type = TOK_BOOLEAN_VALUE;
1942 yyval.constantValue.value.boolean = yystack.l_mark[0].boolean;
1943 }
1944 break;
1945 case 91:
1946 #line 1155 "mof.y"
1947 {
1948 yyval.constantValue.type = TOK_NULL;
1949 }
1950 break;
1951 case 92:
1952 #line 1161 "mof.y"
1953 {
1954 mike 1.1 yyval.string = yystack.l_mark[0].string;
1955 }
1956 break;
1957 case 93:
1958 #line 1165 "mof.y"
1959 {
1960 size_t size = strlen(yystack.l_mark[-1].string) + strlen(yystack.l_mark[0].string) + 1;
1961 yyval.string = (char*)MOF_Realloc(&state.heap, yystack.l_mark[-1].string, size);
1962 Strcat(yyval.string, size, yystack.l_mark[0].string);
1963 MOF_Free(&state.heap, yystack.l_mark[0].string);
1964 }
1965 break;
1966 case 94:
1967 #line 1174 "mof.y"
1968 {
1969 yystack.l_mark[-2].qualifierDeclaration->name = yystack.l_mark[-3].string;
1970 yystack.l_mark[-2].qualifierDeclaration->scope = yystack.l_mark[-1].flags;
1971 yystack.l_mark[-2].qualifierDeclaration->flavor = 0;
1972 yyval.qualifierDeclaration = yystack.l_mark[-2].qualifierDeclaration;
1973 }
1974 break;
1975 mike 1.1 case 95:
1976 #line 1181 "mof.y"
1977 {
1978 yystack.l_mark[-3].qualifierDeclaration->name = yystack.l_mark[-4].string;
1979 yystack.l_mark[-3].qualifierDeclaration->scope = yystack.l_mark[-2].flags;
1980 yystack.l_mark[-3].qualifierDeclaration->flavor = yystack.l_mark[-1].flags;
1981 yyval.qualifierDeclaration = yystack.l_mark[-3].qualifierDeclaration;
1982 }
1983 break;
1984 case 96:
1985 #line 1190 "mof.y"
1986 {
1987 yyval.qualifierDeclaration = CALLOC_T(MI_QualifierDecl, 1);
1988 yyval.qualifierDeclaration->type = yystack.l_mark[0].type;
1989 }
1990 break;
1991 case 97:
1992 #line 1195 "mof.y"
1993 {
1994 void* value;
1995
1996 mike 1.1 if (InitializerToValue(&yystack.l_mark[0].initializer, yystack.l_mark[-2].type, &value) != 0)
1997 {
1998 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
1999 YYABORT;
2000 }
2001
2002 yyval.qualifierDeclaration = CALLOC_T(MI_QualifierDecl, 1);
2003 yyval.qualifierDeclaration->type = yystack.l_mark[-2].type;
2004 yyval.qualifierDeclaration->value = value;
2005 ReleaseInitializer(&yystack.l_mark[0].initializer);
2006 }
2007 break;
2008 case 98:
2009 #line 1210 "mof.y"
2010 {
2011 yyval.qualifierDeclaration = CALLOC_T(MI_QualifierDecl, 1);
2012 yyval.qualifierDeclaration->type = ARRAYOF(yystack.l_mark[-1].type);
2013 yyval.qualifierDeclaration->subscript = (MI_Uint32)yystack.l_mark[0].integer;
2014 }
2015 break;
2016 case 99:
2017 mike 1.1 #line 1216 "mof.y"
2018 {
2019 void* value = NULL;
2020
2021 if (InitializerToValue(&yystack.l_mark[0].initializer, ARRAYOF(yystack.l_mark[-3].type), &value) != 0)
2022 {
2023 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
2024 YYABORT;
2025 }
2026
2027 yyval.qualifierDeclaration = CALLOC_T(MI_QualifierDecl, 1);
2028 yyval.qualifierDeclaration->type = ARRAYOF(yystack.l_mark[-3].type);
2029 yyval.qualifierDeclaration->subscript = (MI_Uint32)yystack.l_mark[-2].integer;
2030 yyval.qualifierDeclaration->value = value;
2031 ReleaseInitializer(&yystack.l_mark[0].initializer);
2032 }
2033 break;
2034 case 100:
2035 #line 1234 "mof.y"
2036 {
2037 yyval.flags = yystack.l_mark[-1].flags;
2038 mike 1.1 }
2039 break;
2040 case 101:
2041 #line 1240 "mof.y"
2042 {
2043 yyval.flags = yystack.l_mark[0].flags;
2044 }
2045 break;
2046 case 102:
2047 #line 1244 "mof.y"
2048 {
2049 yyval.flags |= yystack.l_mark[0].flags;
2050 }
2051 break;
2052 case 103:
2053 #line 1250 "mof.y"
2054 {
2055 yyval.flags = MI_FLAG_CLASS;
2056 }
2057 break;
2058 case 104:
2059 mike 1.1 #line 1254 "mof.y"
2060 {
2061 yyval.flags = MI_FLAG_ASSOCIATION;
2062 }
2063 break;
2064 case 105:
2065 #line 1258 "mof.y"
2066 {
2067 yyval.flags = MI_FLAG_INDICATION;
2068 }
2069 break;
2070 case 106:
2071 #line 1262 "mof.y"
2072 {
2073 yyval.flags = MI_FLAG_PROPERTY;
2074 }
2075 break;
2076 case 107:
2077 #line 1266 "mof.y"
2078 {
2079 yyval.flags = MI_FLAG_REFERENCE;
2080 mike 1.1 }
2081 break;
2082 case 108:
2083 #line 1270 "mof.y"
2084 {
2085 yyval.flags = MI_FLAG_METHOD;
2086 }
2087 break;
2088 case 109:
2089 #line 1274 "mof.y"
2090 {
2091 yyval.flags = MI_FLAG_PARAMETER;
2092 }
2093 break;
2094 case 110:
2095 #line 1278 "mof.y"
2096 {
2097 yyval.flags = MI_FLAG_ANY;
2098 }
2099 break;
2100 case 111:
2101 mike 1.1 #line 1284 "mof.y"
2102 {
2103 /* Reject incompatiable ToSubclass and Restricted flavors */
2104 if (yystack.l_mark[-1].flags & MI_FLAG_TOSUBCLASS && yystack.l_mark[-1].flags & MI_FLAG_RESTRICTED)
2105 {
2106 yyerrorf(ID_INCOMPATIBLE_FLAVORS, "incompatible flavors: %s/%s",
2107 "ToSubclass", "Restricted");
2108 YYABORT;
2109 }
2110
2111 /* Reject incompatiable EnableOverride and DisableOverride flavors */
2112 if (yystack.l_mark[-1].flags & MI_FLAG_ENABLEOVERRIDE && yystack.l_mark[-1].flags & MI_FLAG_DISABLEOVERRIDE)
2113 {
2114 yyerrorf(ID_INCOMPATIBLE_FLAVORS, "incompatible flavors: %s/%s",
2115 "EnableOverride", "DisableOverride");
2116 YYABORT;
2117 }
2118
2119 yyval.flags = yystack.l_mark[-1].flags;
2120 }
2121 break;
2122 mike 1.1 case 112:
2123 #line 1306 "mof.y"
2124 {
2125 yyval.instanceDeclaration = CALLOC_T(MI_InstanceDecl, 1);
2126 yyval.instanceDeclaration->flags = 0;
2127 yyval.instanceDeclaration->name = yystack.l_mark[-1].string;
2128 yyval.instanceDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
2129 yyval.instanceDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
2130 }
2131 break;
2132 case 113:
2133 #line 1314 "mof.y"
2134 {
2135 yyval.instanceDeclaration = CALLOC_T(MI_InstanceDecl, 1);
2136 yyval.instanceDeclaration->flags = 0;
2137 yyval.instanceDeclaration->name = yystack.l_mark[-1].string;
2138 yyval.instanceDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
2139 yyval.instanceDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
2140 yyval.instanceDeclaration->qualifiers = yystack.l_mark[-4].qualifierList.data;
2141 yyval.instanceDeclaration->numQualifiers = yystack.l_mark[-4].qualifierList.size;
2142 }
2143 mike 1.1 break;
2144 case 114:
2145 #line 1324 "mof.y"
2146 {
2147 /* [TODO]: handle alias */
2148 yyval.instanceDeclaration = CALLOC_T(MI_InstanceDecl, 1);
2149 yyval.instanceDeclaration->flags = 0;
2150 yyval.instanceDeclaration->name = yystack.l_mark[-2].string;
2151 yyval.instanceDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
2152 yyval.instanceDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
2153 }
2154 break;
2155 case 115:
2156 #line 1333 "mof.y"
2157 {
2158 /* [TODO]: handle alias */
2159 yyval.instanceDeclaration = CALLOC_T(MI_InstanceDecl, 1);
2160 yyval.instanceDeclaration->flags = 0;
2161 yyval.instanceDeclaration->name = yystack.l_mark[-2].string;
2162 yyval.instanceDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;
2163 yyval.instanceDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;
2164 mike 1.1 yyval.instanceDeclaration->qualifiers = yystack.l_mark[-5].qualifierList.data;
2165 yyval.instanceDeclaration->numQualifiers = yystack.l_mark[-5].qualifierList.size;
2166 }
2167 break;
2168 case 116:
2169 #line 1346 "mof.y"
2170 {
2171 yyval.featureList = yystack.l_mark[-2].featureList;
2172 }
2173 break;
2174 case 117:
2175 #line 1352 "mof.y"
2176 {
2177 yyval.string = yystack.l_mark[0].string;
2178 }
2179 break;
2180 case 118:
2181 #line 1358 "mof.y"
2182 {
2183 yyval.featureList.propertySet.data = NULL;
2184 yyval.featureList.propertySet.size = 0;
2185 mike 1.1 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
2186 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
2187 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
2188 }
2189 break;
2190 case 119:
2191 #line 1366 "mof.y"
2192 {
2193 if (FindProperty(&yystack.l_mark[-1].featureList.propertySet, yystack.l_mark[0].property->name))
2194 {
2195 yyerrorf(ID_CLASS_FEATURE_ALREADY_DEFINED,
2196 "instance property already defined: \"%s\"", yystack.l_mark[0].property->name);
2197 YYABORT;
2198 }
2199
2200 yystack.l_mark[0].property->flags = MI_FLAG_PROPERTY;
2201 yystack.l_mark[0].property->flags |= GetQualFlags(yystack.l_mark[0].property->qualifiers, yystack.l_mark[0].property->numQualifiers);
2202 PtrArray_Append((PtrArray*)&yyval.featureList.propertySet, yystack.l_mark[0].property);
2203 }
2204 break;
2205 case 120:
2206 mike 1.1 #line 1381 "mof.y"
2207 {
2208 void* value;
2209 MI_Type type = InitializerToType(&yystack.l_mark[-1].initializer);
2210
2211 if (InitializerToValue(&yystack.l_mark[-1].initializer, type, &value) != 0)
2212 {
2213 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
2214 YYABORT;
2215 }
2216
2217 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
2218 yyval.property->name = yystack.l_mark[-3].string;
2219 yyval.property->type = type;
2220 yyval.property->value = value;
2221 }
2222 break;
2223 case 121:
2224 #line 1397 "mof.y"
2225 {
2226 void* value;
2227 mike 1.1 MI_Type type = InitializerToType(&yystack.l_mark[-1].initializer);
2228
2229 if (InitializerToValue(&yystack.l_mark[-1].initializer, type, &value) != 0)
2230 {
2231 yyerrorf(ID_INVALID_INITIALIZER, "invalid initializer");
2232 YYABORT;
2233 }
2234
2235 yyval.property = CALLOC_T(MI_PropertyDecl, 1);
2236 yyval.property->name = yystack.l_mark[-3].string;
2237 yyval.property->type = type;
2238 yyval.property->value = value;
2239 yyval.property->qualifiers = yystack.l_mark[-4].qualifierList.data;
2240 yyval.property->numQualifiers = yystack.l_mark[-4].qualifierList.size;
2241 }
2242 break;
2243 case 122:
2244 #line 1417 "mof.y"
2245 {
2246 yyval.string = yystack.l_mark[0].string;
2247 }
2248 mike 1.1 break;
2249 case 123:
2250 #line 1421 "mof.y"
2251 {
2252 yyval.string = MOF_Strdup(&state.heap, "Association");
2253 }
2254 break;
2255 case 124:
2256 #line 1425 "mof.y"
2257 {
2258 yyval.string = MOF_Strdup(&state.heap, "Indication");
2259 }
2260 break;
2261 case 125:
2262 #line 1429 "mof.y"
2263 {
2264 yyval.string = MOF_Strdup(&state.heap, "Reference");
2265 }
2266 break;
2267 case 126:
2268 #line 1433 "mof.y"
2269 mike 1.1 {
2270 yyval.string = MOF_Strdup(&state.heap, "Property");
2271 }
2272 break;
2273 #line 2249 "y.tab.c"
2274 }
2275 yystack.s_mark -= yym;
2276 yystate = *yystack.s_mark;
2277 yystack.l_mark -= yym;
2278 yym = yylhs[yyn];
2279 if (yystate == 0 && yym == 0)
2280 {
2281 #if YYDEBUG
2282 if (yydebug)
2283 printf("%sdebug: after reduction, shifting from state 0 to\
2284 state %d\n", YYPREFIX, YYFINAL);
2285 #endif
2286 yystate = YYFINAL;
2287 *++yystack.s_mark = YYFINAL;
2288 *++yystack.l_mark = yyval;
2289 if (yychar < 0)
2290 mike 1.1 {
2291 if ((yychar = YYLEX) < 0) yychar = 0;
2292 #if YYDEBUG
2293 if (yydebug)
2294 {
2295 yys = 0;
2296 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
2297 if (!yys) yys = "illegal-symbol";
2298 printf("%sdebug: state %d, reading %d (%s)\n",
2299 YYPREFIX, YYFINAL, yychar, yys);
2300 }
2301 #endif
2302 }
2303 if (yychar == 0) goto yyaccept;
2304 goto yyloop;
2305 }
2306 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
2307 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
2308 yystate = yytable[yyn];
2309 else
2310 yystate = yydgoto[yym];
2311 mike 1.1 #if YYDEBUG
2312 if (yydebug)
2313 printf("%sdebug: after reduction, shifting from state %d \
2314 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
2315 #endif
2316 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
2317 {
2318 goto yyoverflow;
2319 }
2320 *++yystack.s_mark = (short) yystate;
2321 *++yystack.l_mark = yyval;
2322 goto yyloop;
2323
2324 yyoverflow:
2325 yyerror("yacc stack overflow");
2326
2327 yyabort:
2328 yyfreestack(&yystack);
2329 return (1);
2330
2331 yyaccept:
2332 mike 1.1 yyfreestack(&yystack);
2333 return (0);
2334 }
|
Return to
mofyaccinc.c
CVS log
Up to [OMI] / omi / mof