omi/mof/mofyaccinc.c - diff

Return to mofyaccinc.c CVS log

Up to [OMI] / omi / mof

Diff for /omi/mof/mofyaccinc.c between version 1.2 and 1.3

version 1.2, 2015/04/20 18:10:13

version 1.3, 2015/04/20 18:19:53

Line 1

**==============================================================================

** Open Management Infrastructure (OMI)

** Copyright (c) Microsoft Corporation

** Licensed under the Apache License, Version 2.0 (the "License"); you may not

** use this file except in compliance with the License. You may obtain a copy

** of the License at

** http://www.apache.org/licenses/LICENSE-2.0

** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,

** MERCHANTABLITY OR NON-INFRINGEMENT.

** See the Apache 2 License for the specific language governing permissions

** and limitations under the License.

**==============================================================================

#ifndef lint

static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";

#endif

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYPATCH 20110908

#define YYEMPTY (-1)

#define yyclearin (yychar = YYEMPTY)

#define yyerrok (yyerrflag = 0)

#define YYRECOVERING() (yyerrflag != 0)

#define YYPREFIX "yy"

#define YYPURE 0

#line 2 "mof.y"

Line 57

Line 16

extern int yylex();

extern int openIncludeFile(const char* path);

#line 20 "mof.y"

#ifdef YYSTYPE

#undef YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED 1

#endif

#ifndef YYSTYPE_IS_DECLARED

#define YYSTYPE_IS_DECLARED 1

typedef union

#ifdef __cplusplus

YYSTYPE

#endif

{

MI_Boolean boolean;

MI_Sint64 integer;

Line 88

Line 46

MI_ClassDecl* classDeclaration;

MI_InstanceDecl* instanceDeclaration;

} YYSTYPE;

#endif /* !YYSTYPE_IS_DECLARED */

#line 68 "y.tab.c"

/* compatibility with bison */

#ifdef YYPARSE_PARAM

/* compatibility with FreeBSD */

# ifdef YYPARSE_PARAM_TYPE

# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)

# else

# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)

# endif

#else

# define YYPARSE_DECL() yyparse(void)

#endif

/* Parameters sent to lex. */

#ifdef YYLEX_PARAM

# define YYLEX_DECL() yylex(void *YYLEX_PARAM)

# define YYLEX yylex(YYLEX_PARAM)

#else

# define YYLEX_DECL() yylex(void)

# define YYLEX yylex()

#endif

/* Parameters sent to yyerror. */

#define YYERROR_DECL() yyerror(const char *s)

#define YYERROR_CALL(msg) yyerror(msg)

extern int YYPARSE_DECL();

#define TOK_ERROR 257

#define TOK_BOOLEAN 258

#define TOK_SINT8 259

Line 133

Line 61

#define TOK_DATETIME 269

#define TOK_CHAR16 270

#define TOK_STRING 271

#define TOK_BOOLEAN_VALUE 272

# define TOK_OBJECT 272

#define TOK_REF 273

# define TOK_BOOLEAN_VALUE 273

#define TOK_SCOPE 274

# define TOK_REF 274

#define TOK_CLASS 275

# define TOK_SCOPE 275

#define TOK_ASSOCIATION 276

# define TOK_CLASS 276

#define TOK_INDICATION 277

# define TOK_ASSOCIATION 277

#define TOK_QUALIFIER 278

# define TOK_INDICATION 278

#define TOK_PROPERTY 279

# define TOK_QUALIFIER 279

#define TOK_REFERENCE 280

# define TOK_PROPERTY 280

#define TOK_METHOD 281

# define TOK_REFERENCE 281

#define TOK_PARAMETER 282

# define TOK_METHOD 282

#define TOK_ANY 283

# define TOK_PARAMETER 283

#define TOK_FLAVOR 284

# define TOK_ANY 284

#define TOK_ENABLEOVERRIDE 285

# define TOK_FLAVOR 285

#define TOK_DISABLEOVERRIDE 286

# define TOK_ENABLEOVERRIDE 286

#define TOK_RESTRICTED 287

# define TOK_DISABLEOVERRIDE 287

#define TOK_TOSUBCLASS 288

# define TOK_RESTRICTED 288

#define TOK_TRANSLATABLE 289

# define TOK_TOSUBCLASS 289

#define TOK_INSTANCE 290

# define TOK_TOINSTANCE 290

#define TOK_OF 291

# define TOK_TRANSLATABLE 291

#define TOK_AS 292

# define TOK_INSTANCE 292

#define TOK_PRAGMA 293

# define TOK_OF 293

#define TOK_SCHEMA 294

# define TOK_AS 294

#define TOK_INTEGER_VALUE 295

# define TOK_PRAGMA 295

#define TOK_REAL_VALUE 296

# define TOK_SCHEMA 296

#define TOK_STRING_VALUE 297

# define TOK_INTEGER_VALUE 297

#define TOK_CHAR_VALUE 298

# define TOK_REAL_VALUE 298

#define TOK_IDENT 299

# define TOK_STRING_VALUE 299

#define TOK_ALIAS_IDENTIFIER 300

# define TOK_CHAR_VALUE 300

#define TOK_NULL 301

# define TOK_IDENT 301

# define TOK_ALIAS_IDENTIFIER 302

# define TOK_NULL 303

#ifdef __STDC__

#include <stdlib.h>

#include <string.h>

#define YYCONST const

#else

#include <malloc.h>

#include <memory.h>

#define YYCONST

#endif

#if defined(__cplusplus) || defined(__STDC__)

#if defined(__cplusplus) && defined(__EXTERN_C__)

extern "C" {

#endif

#ifndef yyerror

#if defined(__cplusplus)

void yyerror(YYCONST char *);

#endif

#ifndef yylex

int yylex(void);

#endif

int yyparse(void);

#if defined(__cplusplus) && defined(__EXTERN_C__)

}

#endif

#define yyclearin yychar = -1

#define yyerrok yyerrflag = 0

extern int yychar;

extern int yyerrflag;

YYSTYPE yylval;

YYSTYPE yyval;

typedef int yytabelem;

#ifndef YYMAXDEPTH

#define YYMAXDEPTH 150

#endif

#if YYMAXDEPTH > 0

int yy_yys[YYMAXDEPTH], *yys = yy_yys;

YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv;

#else /* user does initial allocation */

int *yys;

YYSTYPE *yyv;

#endif

static int yymaxdepth = YYMAXDEPTH;

#define YYERRCODE 256

static const short yylhs[] = { -1,

static YYCONST yytabelem yyexca[] ={

0, 0, 0, 35, 35, 35, 35, 36, 31, 31,

-1, 1,

31, 31, 13, 13, 12, 12, 12, 12, 12, 12,

0, -1,

29, 28, 28, 27, 27, 27, 27, 30, 30, 25,

-2, 0,

25, 24, 24, 24, 24, 24, 7, 7, 7, 7,

7, 7, 7, 7, 10, 10, 10, 10, 11, 11,

11, 11, 6, 6, 6, 6, 6, 6, 6, 6,

6, 6, 6, 6, 6, 6, 3, 9, 9, 8,

8, 8, 8, 8, 8, 8, 8, 17, 17, 18,

18, 18, 19, 20, 20, 5, 5, 5, 5, 5,

5, 1, 1, 15, 15, 16, 16, 16, 16, 23,

22, 22, 21, 21, 21, 21, 21, 21, 21, 21,

26, 32, 32, 32, 32, 14, 4, 34, 34, 33,

33, 2, 2, 2, 2, 2,

};

static const short yylen[] = { 2,

1, 2, 1, 1, 1, 1, 1, 5, 3, 5,

4, 6, 4, 3, 1, 1, 1, 2, 2, 2,

3, 1, 3, 1, 2, 3, 4, 3, 1, 1,

3, 1, 1, 1, 1, 1, 3, 4, 4, 5,

5, 6, 6, 7, 3, 4, 4, 5, 6, 7,

5, 6, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 2, 1, 3, 2,

2, 3, 3, 3, 3, 4, 4, 3, 2, 1,

1, 1, 3, 1, 3, 1, 1, 1, 1, 1,

1, 1, 2, 5, 6, 2, 4, 3, 5, 5,

1, 3, 1, 1, 1, 1, 1, 1, 1, 1,

5, 4, 5, 5, 6, 4, 2, 1, 2, 4,

5, 1, 1, 1, 1, 1,

};

static const short yydefred[] = { 0,

3, 0, 0, 0, 0, 0, 0, 6, 0, 5,

7, 1, 4, 123, 124, 126, 125, 122, 0, 0,

0, 0, 0, 22, 0, 2, 0, 0, 0, 0,

9, 0, 0, 0, 0, 0, 0, 0, 29, 0,

21, 0, 0, 0, 0, 53, 54, 55, 56, 57,

58, 59, 60, 61, 62, 63, 65, 64, 66, 0,

0, 0, 0, 15, 17, 16, 0, 0, 0, 0,

0, 0, 0, 0, 112, 92, 0, 90, 86, 87,

88, 91, 0, 0, 32, 33, 34, 35, 36, 26,

84, 0, 0, 23, 0, 11, 0, 10, 14, 67,

0, 0, 0, 18, 20, 19, 0, 0, 0, 0,

0, 0, 94, 0, 0, 117, 0, 0, 118, 0,

114, 93, 8, 28, 83, 0, 27, 0, 0, 113,

82, 45, 80, 0, 81, 0, 37, 0, 0, 13,

0, 0, 0, 79, 97, 0, 0, 0, 95, 0,

0, 0, 119, 85, 12, 115, 47, 0, 0, 0,

68, 0, 0, 0, 39, 0, 46, 0, 0, 38,

0, 0, 78, 99, 103, 104, 105, 106, 107, 108,

109, 110, 101, 0, 0, 0, 0, 116, 51, 0,

0, 0, 0, 0, 0, 41, 0, 48, 0, 0,

0, 40, 0, 100, 0, 30, 0, 120, 0, 75,

74, 49, 69, 0, 0, 43, 52, 0, 42, 0,

102, 111, 0, 121, 77, 76, 50, 44, 31,

};

static const short yydgoto[] = { 7,

83, 61, 159, 74, 133, 160, 64, 161, 162, 65,

66, 67, 31, 75, 8, 33, 111, 134, 135, 92,

183, 184, 71, 90, 207, 115, 24, 25, 163, 40,

10, 11, 119, 120, 12, 13,

};

static const short yysindex[] = { 55,

# define YYNPROD 190

0, -138, -138, -273, -278, -138, 53, 0, -223, 0,

# define YYLAST 1108

0, 0, 0, 0, 0, 0, 0, 0, -39, 33,

static YYCONST yytabelem yyact[]={

-138, -13, -27, 0, -16, 0, -138, -258, -138, -89,

0, 210, 2, -108, -239, -187, -123, -187, 0, 34,

151, 147, 149, 201, 102, 155, 119, 15, 13, 120,

0, -138, -35, -138, -30, 0, 0, 0, 0, 0,

121, 61, 96, 190, 240, 13, 98, 202, 257, 48,

0, 0, 0, 0, 0, 0, 0, 0, 0, 47,

152, 103, 104, 105, 106, 107, 108, 39, 183, 145,

-168, -138, -138, 0, 0, 0, -65, 135, -21, -167,

310, 265, 33, 210, 42, 75, 76, 77, 78, 79,

-12, -185, 45, 4, 0, 0, -40, 0, 0, 0,

80, 81, 82, 83, 84, 85, 87, 86, 88, 134,

0, 0, -176, 85, 0, 0, 0, 0, 0, 0,

208, 185, 90, 19, 22, 23, 26, 25, 24, 304,

0, -22, -123, 0, -138, 0, -108, 0, 0, 0,

52, 21, 30, 31, 45, 44, 27, 28, 29, 335,

-11, -2, 71, 0, 0, 0, -138, -138, -88, 69,

20, 160, 18, 95, 96, 42, 46, 250, 17, 32,

67, 92, 0, -150, 84, 0, 74, -138, 0, 58,

241, 242, 243, 57, 244, 245, 246, 247, 248, 36,

0, 0, 0, 0, 0, -187, 0, -30, 4, 0,

101, 282, 131, 284, 135, 137, 148, 146, 54, 66,

0, 0, 0, 86, 0, -41, 0, 69, 8, 0,

37, 56, 38, 35, 100, 171, 157, 19, 22, 23,

-4, 3, 54, 0, 0, 69, -125, 108, 0, 69,

26, 25, 24, 89, 188, 21, 30, 46, 354, 114,

98, 94, 0, 0, 0, 0, 0, 101, -138, -138,

27, 28, 29, 148, 20, 207, 18, 148, 122, 46,

0, -7, 135, 109, 0, 69, 0, 126, -17, 0,

97, 353, 17, 164, 322, 349, 323, 173, 206, 177,

69, 14, 0, 0, 0, 0, 0, 0, 0, 0,

303, 161, 259, 110, 111, 61, 112, 53, 205, 115,

0, 0, 0, 22, -123, 127, 69, 0, 0, 117,

192, 348, 159, 167, 168, 170, 318, 175, 319, 179,

117, 130, 40, -138, -138, 0, 150, 0, 154, 27,

347, 157, 70, 125, 144, 140, 59, 345, 59, 215,

157, 0, 69, 0, -125, 0, 39, 0, 172, 0,

219, 154, 223, 343, 196, 36, 342, 231, 228, 142,

0, 0, 0, 117, 117, 0, 0, 173, 0, 174,

69, 236, 234, 98, 341, 340, 37, 13, 38, 35,

0, 0, -123, 0, 0, 0, 0, 0, 0,

221, 156, 225, 19, 22, 23, 26, 25, 24, 252,

};

9, 21, 30, 11, 255, 180, 27, 28, 29, 292,

static const short yyrindex[] = { 0,

20, 293, 18, 68, 334, 181, 12, 189, 17, 8,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

270, 123, 141, 278, 275, 260, 129, 283, 281, 272,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

330, 285, 264, 13, 287, 328, 288, 290, 289, 67,

0, 0, -15, 0, 0, 0, 0, 0, 0, 0,

249, 294, 65, 296, 128, 326, 19, 22, 23, 26,

0, 0, 0, 0, 0, 0, 0, 0, 0, -14,

25, 24, 325, 321, 21, 30, 316, 314, 300, 27,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

28, 29, 312, 20, 121, 18, 307, 64, 271, 305,

217, 17, 301, 311, 209, 114, 299, 127, 315, 13,

279, 317, 280, 273, 320, 274, 308, 309, 324, 214,

114, 216, 50, 327, 206, 291, 306, 329, 286, 110,

111, 61, 112, 126, 205, 115, 124, 263, 256, 206,

337, 338, 117, 333, 110, 111, 61, 112, 114, 205,

115, 148, 336, 344, 13, 251, 193, 346, 166, 182,

268, 339, 269, 253, 162, 254, 350, 332, 351, 130,

331, 352, 110, 111, 61, 112, 93, 163, 115, 165,

198, 276, 192, 277, 75, 76, 77, 78, 79, 80,

81, 82, 83, 84, 85, 87, 86, 88, 74, 13,

4, 158, 19, 22, 23, 26, 25, 24, 238, 148,

21, 30, 232, 148, 233, 27, 28, 29, 226, 20,

227, 18, 235, 229, 237, 230, 222, 17, 224, 184,

75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

85, 87, 86, 88, 74, 199, 41, 200, 19, 22,

23, 26, 25, 24, 148, 148, 21, 30, 148, 43,

7, 27, 28, 29, 194, 20, 195, 18, 218, 5,

220, 13, 176, 17, 178, 187, 75, 76, 77, 78,

79, 80, 81, 82, 83, 84, 85, 87, 86, 88,

114, 2, 113, 14, 19, 22, 23, 26, 25, 24,

148, 99, 21, 30, 148, 355, 55, 27, 28, 29,

40, 20, 13, 18, 110, 111, 61, 112, 58, 17,

115, 75, 76, 77, 78, 79, 80, 81, 82, 83,

84, 85, 87, 86, 88, 114, 60, 143, 295, 19,

22, 23, 26, 25, 24, 92, 191, 21, 30, 172,

239, 174, 27, 28, 29, 116, 20, 13, 18, 110,

111, 61, 112, 258, 17, 115, 75, 76, 77, 78,

79, 80, 81, 82, 83, 84, 85, 87, 86, 88,

313, 148, 203, 262, 19, 22, 23, 26, 25, 24,

49, 150, 21, 30, 6, 63, 1, 27, 28, 29,

0, 20, 297, 18, 261, 298, 0, 262, 0, 17,

75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

85, 87, 86, 88, 0, 0, 0, 0, 19, 22,

23, 26, 25, 24, 0, 0, 21, 30, 36, 0,

0, 27, 28, 29, 0, 20, 0, 18, 0, 37,

0, 38, 35, 17, 0, 0, 19, 22, 23, 26,

25, 24, 0, 0, 21, 30, 0, 0, 0, 27,

28, 29, 0, 20, 0, 18, 13, 0, 0, 36,

0, 17, 0, 0, 0, 34, 0, 0, 0, 0,

37, 0, 38, 35, 0, 16, 0, 19, 22, 23,

26, 25, 24, 0, 0, 21, 30, 0, 0, 0,

27, 28, 29, 211, 20, 0, 18, 47, 0, 0,

0, 0, 17, 0, 36, 51, 0, 0, 0, 0,

0, 62, 73, 0, 91, 37, 0, 38, 35, 0,

0, 0, 19, 22, 23, 26, 25, 24, 0, 73,

21, 30, 36, 0, 0, 27, 28, 29, 133, 20,

71, 18, 0, 37, 94, 38, 35, 17, 169, 0,

19, 22, 23, 26, 25, 24, 139, 71, 21, 30,

36, 0, 0, 27, 28, 29, 132, 20, 204, 18,

0, 37, 0, 38, 35, 17, 138, 0, 19, 22,

23, 26, 25, 24, 0, 0, 21, 30, 36, 0,

0, 27, 28, 29, 0, 20, 0, 18, 0, 37,

0, 38, 35, 17, 136, 0, 19, 22, 23, 26,

25, 24, 0, 0, 21, 30, 36, 0, 0, 27,

28, 29, 3, 20, 0, 18, 109, 37, 118, 38,

35, 17, 212, 0, 19, 22, 23, 26, 25, 24,

0, 9, 21, 30, 11, 0, 0, 27, 28, 29,

0, 20, 0, 18, 153, 10, 10, 12, 0, 17,

8, 75, 76, 77, 78, 79, 80, 81, 82, 83,

84, 85, 87, 86, 88, 0, 0, 0, 0, 267,

0, 0, 0, 212, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 123, 0,

0, 72, 0, 0, 0, 0, 0, 266, 0, 0,

0, 0, 0, 0, 0, 186, 0, 0, 72, 0,

0, 0, 0, 302, 0, 0, 0, 0, 212, 197,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, -24, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 186, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

193, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 213, 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, 46,

72, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 76, 81, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0,

};

static const short yygindex[] = { 0,

205, 347, -23, 158, -28, -26, 189, 73, 95, 198,

200, 0, -31, -25, 0, 0, -91, -85, 246, 0,

65, 0, 0, -90, 0, 0, 229, 0, 9, 0,

0, 0, 152, 0, 266, 0,

};

#define YYTABLESIZE 542

static const short yytable[] = { 158,

123, 6, 127, 63, 144, 69, 62, 84, 9, 91,

139, 96, 36, 98, 73, 9, 89, 21, 29, 89,

22, 126, 95, 199, 145, 6, 35, 42, 24, 25,

37, 114, 44, 192, 89, 60, 193, 136, 68, 110,

63, 108, 169, 62, 107, 70, 113, 132, 121, 6,

172, 27, 164, 28, 167, 168, 137, 76, 138, 103,

174, 170, 204, 171, 186, 205, 165, 218, 166, 109,

193, 130, 202, 6, 203, 68, 41, 24, 25, 222,

197, 118, 223, 30, 78, 201, 71, 30, 109, 71,

32, 93, 30, 109, 206, 38, 155, 154, 210, 211,

89, 209, 125, 156, 100, 99, 112, 79, 80, 76,

81, 38, 70, 82, 116, 70, 73, 220, 38, 73,

122, 72, 225, 226, 72, 124, 73, 146, 118, 140,

6, 147, 229, 148, 150, 6, 195, 14, 15, 194,

16, 17, 149, 6, 157, 6, 173, 185, 6, 175,

176, 177, 188, 178, 179, 180, 181, 182, 187, 189,

18, 85, 86, 87, 88, 89, 96, 196, 46, 47,

48, 49, 50, 51, 52, 53, 54, 55, 56, 57,

58, 59, 152, 72, 198, 208, 14, 15, 212, 16,

17, 38, 46, 47, 48, 49, 50, 51, 52, 53,

54, 55, 56, 57, 58, 59, 143, 109, 216, 18,

14, 15, 217, 16, 17, 219, 46, 47, 48, 49,

50, 51, 52, 53, 54, 55, 56, 57, 58, 59,

224, 227, 228, 18, 14, 15, 98, 16, 17, 77,

46, 47, 48, 49, 50, 51, 52, 53, 54, 55,

56, 57, 58, 59, 129, 104, 122, 18, 14, 15,

78, 16, 17, 200, 105, 213, 106, 78, 39, 221,

94, 153, 26, 0, 0, 0, 0, 0, 0, 0,

0, 18, 0, 79, 80, 76, 81, 0, 131, 82,

79, 80, 76, 81, 0, 131, 82, 46, 47, 48,

49, 50, 51, 52, 53, 54, 55, 56, 57, 58,

59, 1, 0, 0, 0, 14, 15, 0, 16, 17,

14, 15, 0, 16, 17, 0, 0, 2, 0, 2,

3, 0, 3, 14, 15, 0, 16, 17, 18, 0,

78, 0, 4, 18, 4, 5, 0, 5, 19, 20,

0, 0, 23, 0, 0, 0, 18, 0, 0, 0,

0, 0, 0, 79, 80, 76, 81, 34, 131, 82,

0, 0, 0, 43, 0, 45, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 23, 0,

97, 0, 46, 47, 48, 49, 50, 51, 52, 53,

54, 55, 56, 57, 58, 59, 0, 0, 101, 102,

14, 15, 0, 16, 17, 0, 0, 0, 0, 117,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 18, 0, 0, 0, 0, 0, 0,

0, 128, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 141, 142, 0, 0, 0, 0, 0,

0, 0, 0, 0, 151, 0, 117, 46, 47, 48,

49, 50, 51, 52, 53, 54, 55, 56, 57, 58,

59, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 190, 191, 0, 0, 0,

0, 0, 213, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

214, 215,

0, 0, 0, 0, 0, 0, 0, 213 };

};

static YYCONST yytabelem yypact[]={

static const short yycheck[] = { 41,

41, 91, 93, 30, 93, 32, 30, 36, 0, 38,

555, -76,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -294, -30,

102, 43, 40, 45, 123, 7, 41, 291, 58, 44,

-213, 548, -266, 548,-10000000, 389, 6,-10000000,-10000000,-10000000,

299, 44, 58, 41, 110, 91, 40, 44, 44, 44,

-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,

58, 44, 291, 41, 59, 125, 44, 40, 30, 61,

-10000000, -30, -274, 234,-10000000,-10000000,-10000000,-10000000,-10000000, 548,

67, 68, 40, 67, 68, 44, 59, 59, 74, 91,

54,-10000000, 43, -288,-10000000, -30, 142, -6, -30, 302,

142, 275, 138, 277, 59, 141, 59, 297, 61, 125,

593, -49, -278,-10000000, 548, 46, -265, 232,-10000000, 187,

146, 59, 41, 61, 150, 44, 59, 41, 61, 91,

-35,-10000000, -47, 96, 280,-10000000,-10000000,-10000000,-10000000,-10000000,

44, 97, 59, 91, 61, 67, 93, 93, 93, 41,

-10000000, 548, -223, 520, 492,-10000000,-10000000,-10000000,-10000000,-10000000,

166, 73, 44, 123, 272, 171, 41, 123, 91, 44,

-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,

58, 58, 123, 91, 185, 123, 128, 126, 190, 191,

-30, -111, 120, -246, 36,-10000000, 436, -49, -297,-10000000,

125, 187, 125, 129, 273, 59, 274, 295, 296, 297,

-265, -265,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 330,

298, 123, 41, 301, 300, 44, 41, 203, 123, 44,

-10000000,-10000000,-10000000, -289,-10000000,-10000000, 27,-10000000,-10000000,-10000000,

297, 41, 214, 215, 44, 41, 123, 61, 120, 59,

548,-10000000,-10000000, 275,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,

91, 40, 223, 284, 61, 91, 163, 276, 277, 163,

-10000000, 288, 548, 464, -169, 460, 548, 383, 548, -47,

279, 280, 59, 91, 59, 91, 93, 40, 91, 275,

-10000000, -49,-10000000, 270, -257, 359, 45, 53, -80, 391,

276, 277, 59, 279, 280, 281, 282, 283, 61, 59,

267,-10000000, 375, 548,-10000000,-10000000, -265,-10000000,-10000000,-10000000,

299, 285, 286, 287, 288, 289, 44, 59, 258, 259,

232, 309,-10000000,-10000000, 356, 2, 233, 230, 379, 548,

260, 261, 262, 263, 264, 265, 266, 267, 268, 269,

337, 548,-10000000, 329, 2, 334,-10000000, 323, 2, 333,

270, 271, 125, 292, 59, 59, 276, 277, 59, 279,

-10000000,-10000000,-10000000, 338, -196,-10000000,-10000000,-10000000, 45, -16,

280, 123, 258, 259, 260, 261, 262, 263, 264, 265,

-10000000, 266,-10000000,-10000000,-10000000, 2, 274,-10000000,-10000000,-10000000,

266, 267, 268, 269, 270, 271, 295, 91, 59, 299,

2, 249,-10000000,-10000000,-10000000,-10000000, -275, 17, 533, 248,

276, 277, 59, 279, 280, 59, 258, 259, 260, 261,

-10000000, 548, -243, 322,-10000000, 271, 2, 188,-10000000, 224,

262, 263, 264, 265, 266, 267, 268, 269, 270, 271,

2, 292,-10000000, 221, 2, 32,-10000000, 2, 239,-10000000,

59, 59, 59, 299, 276, 277, 44, 279, 280, 35,

2, 177,-10000000, 2, 236,-10000000, 150, 2, -265, 531,

258, 259, 260, 261, 262, 263, 264, 265, 266, 267,

-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,

268, 269, 270, 271, 97, 67, 297, 299, 276, 277,

-10000000,-10000000, 217,-10000000, 2, 213,-10000000, -30, 15,-10000000,

272, 279, 280, 169, 67, 193, 67, 272, 23, 205,

-10000000, 210, 278,-10000000, 5, 548, 548, -244,-10000000, 2,

42, 120, 7, -1, -1, -1, -1, -1, -1, -1,

203, 509, 198,-10000000, 2, 197,-10000000, 2, 97,-10000000,

-1, 299, -1, 295, 296, 297, 298, -1, 300, 301,

2, 194,-10000000, 75, 2, 193,-10000000, 186,-10000000, 2,

295, 296, 297, 298, -1, 300, 301, 258, 259, 260,

176,-10000000,-10000000, 2, 171, 296,-10000000,-10000000, -196,-10000000,

261, 262, 263, 264, 265, 266, 267, 268, 269, 270,

155,-10000000, -54,-10000000, -154,-10000000,-10000000,-10000000, 5, 5,

271, 257, -1, -1, -1, 276, 277, -1, 279, 280,

548, 126,-10000000, 125,-10000000, 117,-10000000, 114,-10000000, 2,

276, 277, -1, 279, 280, -1, -1, 275, -1, 275,

108,-10000000,-10000000, 2, 101,-10000000,-10000000, 92,-10000000, 76,

278, -1, 278, 276, 277, -1, 279, 280, 299, -1,

-10000000, -265,-10000000,-10000000,-10000000, -83,-10000000,-10000000,-10000000, 5,

272, -1, 290, 299, 290, 293, -1, 293, 2, 3,

-10000000,-10000000,-10000000,-10000000, 72,-10000000, 59,-10000000,-10000000,-10000000,

-1, -1, 6, -1, -1, -1, 299, -1, -1, -1,

-10000000, 350,-10000000,-10000000,-10000000,-10000000 };

-1, -1, -1, 295, 296, 297, 298, 21, 300, 301,

static YYCONST yytabelem yypgo[]={

-1, -1, -1, 27, -1, 29, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, 42, -1,

0, 566, 462, 655, 20, 130, 758, 683, 242, 33,

44, -1, 258, 259, 260, 261, 262, 263, 264, 265,

50, 239, 213, 180, 162, 99, 565, 65, 73, 564,

266, 267, 268, 269, 270, 271, -1, -1, 62, 63,

560, 1, 3, 552, 533, 17, 51, 445, 525, 14,

276, 277, -1, 279, 280, -1, -1, -1, -1, 73,

520, 515, 4, 508, 90, 507, 416, 480, 844, 476,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

439, 430, 0, 2, 461, 370 };

-1, -1, -1, 299, -1, -1, -1, -1, -1, -1,

static YYCONST yytabelem yyr1[]={

-1, 95, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, 107, 108, -1, -1, -1, -1, -1,

0, 1, 1, 1, 44, 44, 44, 44, 45, 45,

-1, -1, -1, -1, 118, -1, 120, 258, 259, 260,

40, 40, 40, 40, 17, 17, 16, 16, 16, 16,

261, 262, 263, 264, 265, 266, 267, 268, 269, 270,

16, 16, 16, 16, 16, 16, 16, 16, 38, 37,

271, -1, -1, -1, -1, -1, -1, -1, -1, -1,

37, 36, 36, 36, 36, 39, 39, 33, 33, 34,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

34, 32, 32, 32, 32, 32, 32, 8, 8, 8,

-1, -1, -1, -1, -1, 159, 160, -1, -1, -1,

8, 8, 8, 8, 8, 13, 13, 13, 13, 13,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

13, 13, 13, 14, 14, 14, 14, 14, 14, 14,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

14, 11, 11, 11, 11, 11, 11, 11, 11, 12,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

12, 12, 12, 12, 12, 12, 12, 15, 15, 15,

194, 195,

15, 10, 10, 9, 9, 9, 9, 9, 9, 9,

};

9, 21, 21, 22, 22, 23, 23, 24, 24, 25,

#define YYFINAL 7

25, 25, 26, 26, 27, 27, 28, 28, 6, 6,

6, 6, 6, 6, 2, 2, 19, 19, 20, 20,

20, 20, 31, 30, 30, 29, 29, 29, 29, 29,

29, 29, 29, 35, 41, 41, 41, 41, 18, 18,

5, 43, 43, 42, 42, 42, 42, 4, 4, 4,

4, 4, 3, 3, 3, 3, 3, 3, 3, 3,

3, 3, 3, 3, 3, 3, 7, 7, 7, 7,

7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };

static YYCONST yytabelem yyr2[]={

0, 3, 5, 3, 3, 3, 3, 3, 11, 15,

7, 11, 9, 13, 9, 7, 3, 3, 3, 3,

3, 3, 5, 5, 5, 5, 5, 5, 7, 3,

7, 3, 5, 7, 9, 7, 3, 3, 7, 3,

5, 3, 3, 3, 3, 3, 3, 7, 9, 9,

11, 11, 13, 13, 15, 7, 9, 9, 11, 11,

13, 13, 15, 7, 9, 9, 11, 11, 13, 13,

15, 9, 11, 13, 15, 11, 13, 15, 17, 9,

11, 11, 13, 13, 15, 15, 17, 13, 15, 11,

13, 3, 7, 5, 7, 7, 9, 7, 9, 9,

11, 7, 5, 3, 3, 7, 5, 3, 7, 3,

3, 13, 3, 3, 7, 5, 3, 7, 3, 3,

3, 3, 3, 3, 3, 5, 11, 13, 5, 9,

7, 11, 11, 3, 7, 3, 3, 3, 3, 3,

3, 3, 3, 11, 9, 11, 11, 13, 9, 7,

5, 3, 5, 5, 7, 9, 11, 3, 3, 3,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };

static YYCONST yytabelem yychk[]={

-10000000, -1, -44, 257, -45, -40, -19, -41, 295, 276,

-38, 279, 292, 91, -44, 301, -3, 301, 295, 276,

293, 284, 277, 278, 281, 280, 279, 289, 290, 291,

285, 276, 292, -4, -3, 272, 258, 269, 271, 293,

-37, -36, -4, 40, -17, 58, 123, -3, 293, -20,

58, -3, -4, 93, 44, -39, 58, 40, -27, 123,

-2, 299, -3, -16, 125, -8, -15, -11, -12, -13,

-14, -7, -38, -3, 272, 258, 259, 260, 261, 262,

263, 264, 265, 266, 267, 268, 270, 269, 271, -17,

58, -3, -31, 44, -7, -18, 123, -5, 294, -36,

58, -34, -32, 286, 287, 288, 289, 290, 291, -6,

297, 298, 300, -2, 273, 303, -28, 125, -6, 41,

44, 299, -17, 125, -8, -15, -11, -12, -13, -14,

59, -4, -7, -3, 272, -4, 274, -4, 274, -3,

-18, -5, 59, -35, 44, 275, 61, -21, 91, -43,

125, -42, -4, -38, -18, 302, -34, -32, 41, 125,

44, -4, 59, 59, -21, 61, 40, -4, -4, 274,

-4, 274, 59, -21, 61, -4, 59, -21, 61, -4,

-17, -18, 59, 285, 40, -26, -6, -27, 61, 297,

93, 125, -42, 59, 59, 61, -4, -6, 41, 59,

61, -22, -25, -23, -6, 302, 292, 123, -10, 41,

-9, -7, -3, -38, 59, -21, 61, 40, 59, -21,

61, -4, 59, -21, 61, -4, 59, 61, -22, 59,

61, -21, 59, 61, -22, 59, -21, 61, 40, -30,

-29, 276, 277, 278, 280, 281, 282, 283, 284, -26,

93, 59, -22, 59, 61, -22, 59, 293, -24, 125,

-25, 41, 44, 59, -4, 274, -7, -3, 59, 61,

-22, -10, 41, 59, 61, -22, 59, 61, -21, 59,

61, -22, 59, -21, 61, -22, 59, -22, 59, 61,

-22, 59, 59, 61, -22, -33, -32, 41, 44, 59,

-22, 59, -3, 125, 44, 59, -9, -21, -4, -4,

274, -22, 59, 41, 59, -22, 59, -22, 59, 61,

-22, 59, 59, 61, -22, 59, 59, -22, 59, -22,

59, 44, 41, -29, 59, 123, -25, -21, -21, -4,

59, 59, 59, 59, -22, 59, -22, 59, 59, 59,

-32, -43, -21, 59, 59, 125 };

static YYCONST yytabelem yydef[]={

0, -2, 1, 3, 4, 5, 6, 7, 0, 0,

0, 0, 0, 0, 2, 0, 0, 162, 163, 164,

165, 166, 167, 168, 169, 170, 171, 172, 173, 174,

175, 0, 0, 0, 157, 158, 159, 160, 161, 0,

0, 29, 31, 0, 10, 0, 0, 0, 0, 0,

0, 157, 0, 28, 0, 32, 0, 0, 36, 0,

0, 124, 0, 0, 0, 16, 17, 18, 19, 20,

21, 0, 0, 0, 0, 176, 177, 178, 179, 180,

181, 182, 183, 184, 185, 186, 187, 188, 189, 12,

0, 0, 0, 0, 128, 144, 0, 0, 0, 30,

0, 33, 39, 41, 42, 43, 44, 45, 46, 0,

118, 119, 120, 121, 122, 123, 0, 115, 116, 8,

0, 125, 11, 0, 22, 23, 24, 25, 26, 27,

15, 0, 0, 0, 0, 0, 0, 0, 0, 0,

145, 0, 126, 0, 0, 0, 0, 130, 0, 0,

0, 151, 0, 0, 146, 150, 34, 40, 35, 114,

0, 0, 14, 47, 0, 0, 0, 0, 0, 0,

0, 0, 55, 0, 0, 0, 63, 0, 0, 0,

13, 147, 127, 0, 0, 129, 112, 113, 0, 0,

102, 0, 152, 149, 153, 0, 0, 117, 9, 49,

0, 0, 103, 104, 109, 110, 0, 0, 0, 0,

91, 0, 0, 0, 48, 0, 0, 0, 56, 0,

0, 0, 64, 0, 0, 0, 57, 0, 0, 71,

0, 0, 65, 0, 0, 79, 0, 0, 0, 0,

133, 135, 136, 137, 138, 139, 140, 141, 142, 131,

101, 148, 0, 154, 0, 0, 51, 0, 0, 106,

107, 0, 0, 89, 93, 0, 0, 0, 50, 0,

0, 0, 0, 58, 0, 0, 72, 0, 0, 66,

0, 0, 80, 0, 0, 0, 59, 0, 75, 0,

0, 67, 81, 0, 0, 0, 37, 132, 0, 155,

0, 53, 0, 105, 0, 87, 92, 97, 94, 95,

0, 0, 52, 0, 90, 0, 60, 0, 76, 0,

0, 68, 82, 0, 0, 61, 73, 0, 69, 0,

83, 0, 143, 134, 156, 0, 108, 98, 99, 96,

54, 88, 62, 74, 0, 70, 0, 85, 77, 84,

38, 0, 100, 78, 86, 111 };

typedef struct

#ifdef __cplusplus

yytoktype

#endif

{

#ifdef __cplusplus

const

#endif

char *t_name; int t_val; } yytoktype;

#ifndef YYDEBUG

#define YYDEBUG 0

# define YYDEBUG 0 /* don't allow debugging */

#endif

#define YYMAXTOKEN 301

#if YYDEBUG

static const char *yyname[] = {

"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,

yytoktype yytoks[] =

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,0,0,0,0,0,0,0,0,0,0,0,"'['",0,"']'",0,0,0,0,

{ "TOK_ERROR", 257 },

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,

{ "TOK_BOOLEAN", 258 },

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,

{ "TOK_SINT8", 259 },

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,

{ "TOK_UINT8", 260 },

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,

{ "TOK_SINT16", 261 },

0,0,0,"TOK_ERROR","TOK_BOOLEAN","TOK_SINT8","TOK_UINT8","TOK_SINT16",

{ "TOK_UINT16", 262 },

"TOK_UINT16","TOK_SINT32","TOK_UINT32","TOK_SINT64","TOK_UINT64","TOK_REAL32",

{ "TOK_SINT32", 263 },

"TOK_REAL64","TOK_DATETIME","TOK_CHAR16","TOK_STRING","TOK_BOOLEAN_VALUE",

{ "TOK_UINT32", 264 },

"TOK_REF","TOK_SCOPE","TOK_CLASS","TOK_ASSOCIATION","TOK_INDICATION",

{ "TOK_SINT64", 265 },

"TOK_QUALIFIER","TOK_PROPERTY","TOK_REFERENCE","TOK_METHOD","TOK_PARAMETER",

{ "TOK_UINT64", 266 },

"TOK_ANY","TOK_FLAVOR","TOK_ENABLEOVERRIDE","TOK_DISABLEOVERRIDE",

{ "TOK_REAL32", 267 },

"TOK_RESTRICTED","TOK_TOSUBCLASS","TOK_TRANSLATABLE","TOK_INSTANCE","TOK_OF",

{ "TOK_REAL64", 268 },

"TOK_AS","TOK_PRAGMA","TOK_SCHEMA","TOK_INTEGER_VALUE","TOK_REAL_VALUE",

{ "TOK_DATETIME", 269 },

"TOK_STRING_VALUE","TOK_CHAR_VALUE","TOK_IDENT","TOK_ALIAS_IDENTIFIER",

{ "TOK_CHAR16", 270 },

"TOK_NULL",

{ "TOK_STRING", 271 },

{ "TOK_OBJECT", 272 },

{ "TOK_BOOLEAN_VALUE", 273 },

{ "TOK_REF", 274 },

{ "TOK_SCOPE", 275 },

{ "TOK_CLASS", 276 },

{ "TOK_ASSOCIATION", 277 },

{ "TOK_INDICATION", 278 },

{ "TOK_QUALIFIER", 279 },

{ "TOK_PROPERTY", 280 },

{ "TOK_REFERENCE", 281 },

{ "TOK_METHOD", 282 },

{ "TOK_PARAMETER", 283 },

{ "TOK_ANY", 284 },

{ "TOK_FLAVOR", 285 },

{ "TOK_ENABLEOVERRIDE", 286 },

{ "TOK_DISABLEOVERRIDE", 287 },

{ "TOK_RESTRICTED", 288 },

{ "TOK_TOSUBCLASS", 289 },

{ "TOK_TOINSTANCE", 290 },

{ "TOK_TRANSLATABLE", 291 },

{ "TOK_INSTANCE", 292 },

{ "TOK_OF", 293 },

{ "TOK_AS", 294 },

{ "TOK_PRAGMA", 295 },

{ "TOK_SCHEMA", 296 },

{ "TOK_INTEGER_VALUE", 297 },

{ "TOK_REAL_VALUE", 298 },

{ "TOK_STRING_VALUE", 299 },

{ "TOK_CHAR_VALUE", 300 },

{ "TOK_IDENT", 301 },

{ "TOK_ALIAS_IDENTIFIER", 302 },

{ "TOK_NULL", 303 },

{ "-unknown-", } -1 /* ends search */

};

static const char *yyrule[] = {

"$accept : mofSpecification",

#ifdef __cplusplus

const

#endif

char * yyreds[] =

{

"-no such reduction-",

"mofSpecification : mofProduction",

"mofSpecification : mofSpecification mofProduction",

"mofSpecification : TOK_ERROR",

Line 432

Line 507

"mofProduction : qualifierDeclaration",

"mofProduction : instanceDeclaration",

"compilerDirective : TOK_PRAGMA TOK_IDENT '(' stringValue ')'",

"classDeclaration : TOK_CLASS identifier classBody",

"compilerDirective : TOK_PRAGMA TOK_IDENT '(' stringValue ',' identifier ')'",

"classDeclaration : TOK_CLASS identifier ':' identifier classBody",

"classDeclaration : TOK_CLASS classNameIdentifier classBody",

"classDeclaration : qualifierExpr TOK_CLASS identifier classBody",

"classDeclaration : TOK_CLASS classNameIdentifier ':' classNameIdentifier classBody",

"classDeclaration : qualifierExpr TOK_CLASS identifier ':' identifier classBody",

"classDeclaration : qualifierExpr TOK_CLASS classNameIdentifier classBody",

"classDeclaration : qualifierExpr TOK_CLASS classNameIdentifier ':' classNameIdentifier classBody",

"classBody : '{' classFeatureList '}' ';'",

"classBody : '{' '}' ';'",

"classFeatureList : propertyDeclaration",

"classFeatureList : methodDeclaration",

"classFeatureList : referenceDeclaration",

"classFeatureList : dynamicReferenceDeclaration",

"classFeatureList : staticEmbeddedInstanceDeclaration",

"classFeatureList : dynamicEmbeddedInstanceDeclaration",

"classFeatureList : classFeatureList propertyDeclaration",

"classFeatureList : classFeatureList methodDeclaration",

"classFeatureList : classFeatureList referenceDeclaration",

"classFeatureList : classFeatureList dynamicReferenceDeclaration",

"classFeatureList : classFeatureList staticEmbeddedInstanceDeclaration",

"classFeatureList : classFeatureList dynamicEmbeddedInstanceDeclaration",

"qualifierExpr : '[' qualifierList ']'",

"qualifierList : qualifier",

"qualifierList : qualifierList ',' qualifier",

"qualifier : identifier",

"qualifier : identifier qualifierParameter",

"qualifier : identifier ':' flavor",

"qualifier : identifier ':' qualifierFlavorList",

"qualifier : identifier qualifierParameter ':' flavor",

"qualifier : identifier qualifierParameter ':' qualifierFlavorList",

"qualifierParameter : '(' constantValue ')'",

"qualifierParameter : arrayInitializer",

"qualifierParameter : nonAggregateArrayInitializer",

"flavorList : flavor",

"flavorList : flavorList ',' flavor",

"qualifierFlavorList : flavor",

"qualifierFlavorList : qualifierFlavorList flavor",

"flavor : TOK_ENABLEOVERRIDE",

"flavor : TOK_DISABLEOVERRIDE",

"flavor : TOK_RESTRICTED",

"flavor : TOK_TOSUBCLASS",

"flavor : TOK_TOINSTANCE",

"flavor : TOK_TRANSLATABLE",

"propertyDeclaration : dataType identifier ';'",

"propertyDeclaration : qualifierExpr dataType identifier ';'",

Line 468

Line 553

"propertyDeclaration : qualifierExpr dataType identifier '=' initializer ';'",

"propertyDeclaration : dataType identifier subscript '=' initializer ';'",

"propertyDeclaration : qualifierExpr dataType identifier subscript '=' initializer ';'",

"referenceDeclaration : objectRef identifier ';'",

"staticEmbeddedInstanceDeclaration : classNameIdentifier identifier ';'",

"referenceDeclaration : qualifierExpr objectRef identifier ';'",

"staticEmbeddedInstanceDeclaration : qualifierExpr classNameIdentifier identifier ';'",

"referenceDeclaration : objectRef identifier initializer ';'",

"staticEmbeddedInstanceDeclaration : classNameIdentifier identifier subscript ';'",

"referenceDeclaration : qualifierExpr objectRef identifier initializer ';'",

"staticEmbeddedInstanceDeclaration : qualifierExpr classNameIdentifier identifier subscript ';'",

"staticEmbeddedInstanceDeclaration : classNameIdentifier identifier '=' initializer ';'",

"staticEmbeddedInstanceDeclaration : qualifierExpr classNameIdentifier identifier '=' initializer ';'",

"staticEmbeddedInstanceDeclaration : classNameIdentifier identifier subscript '=' initializer ';'",

"staticEmbeddedInstanceDeclaration : qualifierExpr classNameIdentifier identifier subscript '=' initializer ';'",

"dynamicEmbeddedInstanceDeclaration : TOK_OBJECT identifier ';'",

"dynamicEmbeddedInstanceDeclaration : qualifierExpr TOK_OBJECT identifier ';'",

"dynamicEmbeddedInstanceDeclaration : TOK_OBJECT identifier subscript ';'",

"dynamicEmbeddedInstanceDeclaration : qualifierExpr TOK_OBJECT identifier subscript ';'",

"dynamicEmbeddedInstanceDeclaration : TOK_OBJECT identifier '=' initializer ';'",

"dynamicEmbeddedInstanceDeclaration : qualifierExpr TOK_OBJECT identifier '=' initializer ';'",

"dynamicEmbeddedInstanceDeclaration : TOK_OBJECT identifier subscript '=' initializer ';'",

"dynamicEmbeddedInstanceDeclaration : qualifierExpr TOK_OBJECT identifier subscript '=' initializer ';'",

"referenceDeclaration : classNameIdentifier TOK_REF identifier ';'",

"referenceDeclaration : qualifierExpr classNameIdentifier TOK_REF identifier ';'",

"referenceDeclaration : classNameIdentifier TOK_REF identifier '=' initializer ';'",

"referenceDeclaration : qualifierExpr classNameIdentifier TOK_REF identifier '=' initializer ';'",

"referenceDeclaration : classNameIdentifier TOK_REF identifier subscript ';'",

"referenceDeclaration : qualifierExpr classNameIdentifier TOK_REF identifier subscript ';'",

"referenceDeclaration : classNameIdentifier TOK_REF identifier subscript '=' initializer ';'",

"referenceDeclaration : qualifierExpr classNameIdentifier TOK_REF identifier subscript '=' initializer ';'",

"dynamicReferenceDeclaration : TOK_OBJECT TOK_REF identifier ';'",

"dynamicReferenceDeclaration : qualifierExpr TOK_OBJECT TOK_REF identifier ';'",

"dynamicReferenceDeclaration : TOK_OBJECT TOK_REF identifier subscript ';'",

"dynamicReferenceDeclaration : qualifierExpr TOK_OBJECT TOK_REF identifier subscript ';'",

"dynamicReferenceDeclaration : TOK_OBJECT TOK_REF identifier '=' initializer ';'",

"dynamicReferenceDeclaration : TOK_OBJECT TOK_REF identifier subscript '=' initializer ';'",

"dynamicReferenceDeclaration : qualifierExpr TOK_OBJECT TOK_REF identifier '=' initializer ';'",

"dynamicReferenceDeclaration : qualifierExpr TOK_OBJECT TOK_REF identifier subscript '=' initializer ';'",

"methodDeclaration : dataType identifier '(' parameterList ')' ';'",

"methodDeclaration : qualifierExpr dataType identifier '(' parameterList ')' ';'",

"methodDeclaration : dataType identifier '(' ')' ';'",

"methodDeclaration : qualifierExpr dataType identifier '(' ')' ';'",

"dataType : TOK_BOOLEAN",

"dataType : TOK_SINT8",

"dataType : TOK_UINT8",

"dataType : TOK_SINT16",

"dataType : TOK_UINT16",

"dataType : TOK_SINT32",

"dataType : TOK_UINT32",

"dataType : TOK_SINT64",

"dataType : TOK_UINT64",

"dataType : TOK_REAL32",

"dataType : TOK_REAL64",

"dataType : TOK_CHAR16",

"dataType : TOK_DATETIME",

"dataType : TOK_STRING",

"objectRef : identifier TOK_REF",

"parameterList : parameter",

"parameterList : parameterList ',' parameter",

"parameter : dataType identifier",

"parameter : objectRef identifier",

"parameter : classNameIdentifier TOK_REF identifier",

"parameter : qualifierExpr dataType identifier",

"parameter : qualifierExpr objectRef identifier",

"parameter : qualifierExpr classNameIdentifier TOK_REF identifier",

"parameter : dataType identifier subscript",

"parameter : objectRef identifier subscript",

"parameter : classNameIdentifier TOK_REF identifier subscript",

"parameter : qualifierExpr dataType identifier subscript",

"parameter : qualifierExpr objectRef identifier subscript",

"parameter : qualifierExpr classNameIdentifier TOK_REF identifier subscript",

"subscript : '[' TOK_INTEGER_VALUE ']'",

"subscript : '[' ']'",

"initializer : constantValue",

"initializer : scalarInitializer",

"initializer : arrayInitializer",

"initializer : TOK_ALIAS_IDENTIFIER",

"arrayInitializer : '{' arrayInitializerList '}'",

"arrayInitializerList : constantValue",

"arrayInitializer : '{' '}'",

"arrayInitializerList : arrayInitializerList ',' constantValue",

"arrayInitializerList : scalarInitializer",

"arrayInitializerList : arrayInitializerList ',' scalarInitializer",

"scalarInitializer : constantValue",

"scalarInitializer : TOK_ALIAS_IDENTIFIER",

"scalarInitializer : TOK_INSTANCE TOK_OF classNameIdentifier '{' valueInitializerList '}'",

"nonAggregateInitializer : constantValue",

"nonAggregateInitializer : nonAggregateArrayInitializer",

"nonAggregateArrayInitializer : '{' nonAggregateArrayInitializerList '}'",

"nonAggregateArrayInitializer : '{' '}'",

"nonAggregateArrayInitializerList : constantValue",

"nonAggregateArrayInitializerList : nonAggregateArrayInitializerList ',' constantValue",

"constantValue : TOK_INTEGER_VALUE",

"constantValue : TOK_REAL_VALUE",

"constantValue : TOK_CHAR_VALUE",

Line 520

Line 627

"qualifierDeclaration : TOK_QUALIFIER identifier qualifierType scopeExpr ';'",

"qualifierDeclaration : TOK_QUALIFIER identifier qualifierType scopeExpr flavorExpr ';'",

"qualifierType : ':' dataType",

"qualifierType : ':' dataType '=' initializer",

"qualifierType : ':' dataType '=' nonAggregateInitializer",

"qualifierType : ':' dataType subscript",

"qualifierType : ':' dataType subscript '=' initializer",

"qualifierType : ':' dataType subscript '=' nonAggregateInitializer",

"scopeExpr : ',' TOK_SCOPE '(' scopeList ')'",

"scopeList : scope",

"scopeList : scopeList ',' scope",

Line 535

Line 642

"scope : TOK_PARAMETER",

"scope : TOK_ANY",

"flavorExpr : ',' TOK_FLAVOR '(' flavorList ')'",

"instanceDeclaration : TOK_INSTANCE TOK_OF identifier instanceBody",

"instanceDeclaration : TOK_INSTANCE TOK_OF classNameIdentifier instanceBody",

"instanceDeclaration : qualifierExpr TOK_INDICATION TOK_OF identifier instanceBody",

"instanceDeclaration : qualifierExpr TOK_INSTANCE TOK_OF classNameIdentifier instanceBody",

"instanceDeclaration : TOK_INSTANCE TOK_OF identifier alias instanceBody",

"instanceDeclaration : qualifierExpr TOK_INDICATION TOK_OF identifier alias instanceBody",

"instanceDeclaration : qualifierExpr TOK_INSTANCE TOK_OF classNameIdentifier alias instanceBody",

"instanceBody : '{' valueInitializerList '}' ';'",

"instanceBody : '{' '}' ';'",

"alias : TOK_AS TOK_ALIAS_IDENTIFIER",

"valueInitializerList : valueInitializer",

"valueInitializerList : valueInitializerList valueInitializer",

"valueInitializer : identifier ';'",

"valueInitializer : qualifierExpr identifier ';'",

"valueInitializer : identifier '=' initializer ';'",

"valueInitializer : qualifierExpr identifier '=' initializer ';'",

"identifier : TOK_IDENT",

"identifier : classNameIdentifier",

"identifier : TOK_ASSOCIATION",

"identifier : TOK_OBJECT",

"identifier : TOK_INDICATION",

"identifier : TOK_BOOLEAN",

"identifier : TOK_REFERENCE",

"identifier : TOK_DATETIME",

"identifier : TOK_PROPERTY",

"identifier : TOK_STRING",

"classNameIdentifier : TOK_IDENT",

"classNameIdentifier : TOK_PRAGMA",

"classNameIdentifier : TOK_CLASS",

"classNameIdentifier : TOK_OF",

"classNameIdentifier : TOK_ANY",

"classNameIdentifier : TOK_ASSOCIATION",

"classNameIdentifier : TOK_INDICATION",

"classNameIdentifier : TOK_REFERENCE",

"classNameIdentifier : TOK_PROPERTY",

"classNameIdentifier : TOK_QUALIFIER",

"classNameIdentifier : TOK_TOSUBCLASS",

"classNameIdentifier : TOK_TOINSTANCE",

"classNameIdentifier : TOK_TRANSLATABLE",

"classNameIdentifier : TOK_FLAVOR",

"dataType : TOK_BOOLEAN",

"dataType : TOK_SINT8",

"dataType : TOK_UINT8",

"dataType : TOK_SINT16",

"dataType : TOK_UINT16",

"dataType : TOK_SINT32",

"dataType : TOK_UINT32",

"dataType : TOK_SINT64",

"dataType : TOK_UINT64",

"dataType : TOK_REAL32",

"dataType : TOK_REAL64",

"dataType : TOK_CHAR16",

"dataType : TOK_DATETIME",

"dataType : TOK_STRING",

};

#endif

#endif /* YYDEBUG */

# line 1 "/usr/ccs/bin/yaccpar"

int yydebug;

int yynerrs;

int yyerrflag;

int yychar;

YYSTYPE yyval;

YYSTYPE yylval;

/* define the initial stack-sizes */

#ifdef YYSTACKSIZE

#undef YYMAXDEPTH

#define YYMAXDEPTH YYSTACKSIZE

#else

#ifdef YYMAXDEPTH

#define YYSTACKSIZE YYMAXDEPTH

#else

#define YYSTACKSIZE 500

#define YYMAXDEPTH 500

#endif

#define YYINITSTACKSIZE 500

typedef struct {

unsigned stacksize;

** Skeleton parser driver for yacc output

short *s_base;

short *s_mark;

short *s_last;

YYSTYPE *l_base;

YYSTYPE *l_mark;

} YYSTACKDATA;

/* variables for the parser stack */

static YYSTACKDATA yystack;

#if YYDEBUG

#include <stdio.h> /* needed for printf */

** yacc user known macros and defines

#define YYERROR goto yyerrlab

#define YYACCEPT return(0)

#define YYABORT return(1)

#define YYBACKUP( newtoken, newvalue )\

if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\

yyerror( "syntax error - cannot backup" );\

goto yyerrlab;\

yychar = newtoken;\

yystate = *yyps;\

yylval = newvalue;\

goto yynewstate;\

}

#define YYRECOVERING() (!!yyerrflag)

#define YYNEW(type) PAL_Malloc(sizeof(type) * yynewmax)

#define YYCOPY(to, from, type) \

(type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type))

#define YYENLARGE( from, type) \

(type *) PAL_Realloc((char *) from, yynewmax * sizeof(type))

#ifndef YYDEBUG

# define YYDEBUG 1 /* make debugging available */

#endif

#include <stdlib.h> /* needed for malloc, etc */

#include <string.h> /* needed for memset */

** user known globals

/* allocate initial stack or double stack size, up to YYMAXDEPTH */

int yydebug; /* set to 1 to get debugging */

static int yygrowstack(YYSTACKDATA *data)

{

int i;

unsigned newsize;

short *newss;

YYSTYPE *newvs;

if ((newsize = data->stacksize) == 0)

newsize = YYINITSTACKSIZE;

** driver internal defines

else if (newsize >= YYMAXDEPTH)

return -1;

#define YYFLAG (-10000000)

else if ((newsize *= 2) > YYMAXDEPTH)

newsize = YYMAXDEPTH;

i = data->s_mark - data->s_base;

newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));

** global variables used by the parser

if (newss == 0)

return -1;

YYSTYPE *yypv; /* top of value stack */

int *yyps; /* top of state stack */

data->s_base = newss;

int yystate; /* current state */

data->s_mark = newss + i;

int yytmp; /* extra var (lasts between blocks) */

newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));

int yynerrs; /* number of errors */

if (newvs == 0)

int yyerrflag; /* error recovery flag */

return -1;

int yychar; /* current input token number */

data->l_base = newvs;

data->l_mark = newvs + i;

data->stacksize = newsize;

data->s_last = data->s_base + newsize - 1;

return 0;

}

#if YYPURE || defined(YY_NO_LEAKS)

#ifdef YYNMBCHARS

static void yyfreestack(YYSTACKDATA *data)

#define YYLEX() yycvtok(yylex())

{

free(data->s_base);

** yycvtok - return a token if i is a wchar_t value that exceeds 255.

free(data->l_base);

** If i<255, i itself is the token. If i>255 but the neither

memset(data, 0, sizeof(*data));

** of the 30th or 31st bit is on, i is already a token.

}

#if defined(__STDC__) || defined(__cplusplus)

int yycvtok(int i)

#else

#define yyfreestack(data) /* nothing */

int yycvtok(i) int i;

#endif

{

int first = 0;

int last = YYNMBCHARS - 1;

int mid;

wchar_t j;

if(i&0x60000000){/*Must convert to a token. */

if( yymbchars[last].character < i ){

return i;/*Giving up*/

}

while ((last>=first)&&(first>=0)) {/*Binary search loop*/

mid = (first+last)/2;

j = yymbchars[mid].character;

if( j==i ){/*Found*/

return yymbchars[mid].tvalue;

}else if( j<i ){

first = mid + 1;

}else{

last = mid -1;

}

/*No entry in the table.*/

return i;/* Giving up.*/

}else{/* i is already a token. */

return i;

}

#else/*!YYNMBCHARS*/

#define YYLEX() yylex()

#endif/*!YYNMBCHARS*/

#define YYABORT goto yyabort

#define YYREJECT goto yyabort

** yyparse - return 0 if worked, 1 if syntax error not recovered from

#define YYACCEPT goto yyaccept

#define YYERROR goto yyerrlab

#if defined(__STDC__) || defined(__cplusplus)

int yyparse(void)

int

#else

YYPARSE_DECL()

int yyparse()

#endif

{

int yym, yyn, yystate;

#if YYDEBUG

const char *yys;

if ((yys = getenv("YYDEBUG")) != 0)

#if defined(__cplusplus) || defined(lint)

workarounds to please C++ and lint - goto's inside

switch should never be executed

static int __yaccpar_lint_workaround__ = 0;

switch (__yaccpar_lint_workaround__)

{

yyn = *yys;

case 1: goto yyerrlab;

if (yyn >= '0' && yyn <= '9')

case 2: goto yynewstate;

yydebug = yyn - '0';

}

#endif

** Initialize externals - yyparse may be called more than once

yypv = &yyv[-1];

yyps = &yys[-1];

yystate = 0;

yytmp = 0;

yynerrs = 0;

yyerrflag = 0;

yychar = YYEMPTY;

yychar = -1;

yystate = 0;

#if YYPURE

memset(&yystack, 0, sizeof(yystack));

#endif

if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;

yystack.s_mark = yystack.s_base;

yystack.l_mark = yystack.l_base;

yystate = 0;

*yystack.s_mark = 0;

yyloop:

#if YYMAXDEPTH <= 0

if ((yyn = yydefred[yystate]) != 0) goto yyreduce;

if (yymaxdepth <= 0)

if (yychar < 0)

{

if ((yychar = YYLEX) < 0) yychar = 0;

if ((yymaxdepth = YYEXPAND(0)) <= 0)

#if YYDEBUG

if (yydebug)

{

yys = 0;

yyerror("yacc initialization error");

if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

YYABORT;

if (!yys) yys = "illegal-symbol";

printf("%sdebug: state %d, reading %d (%s)\n",

YYPREFIX, yystate, yychar, yys);

}

#endif

}

if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&

yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

{

#if YYDEBUG

if (yydebug)

printf("%sdebug: state %d, shifting to state %d\n",

YYPREFIX, yystate, yytable[yyn]);

#endif

if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))

{

goto yyoverflow;

}

yystate = yytable[yyn];

*++yystack.s_mark = yytable[yyn];

*++yystack.l_mark = yylval;

yychar = YYEMPTY;

if (yyerrflag > 0) --yyerrflag;

goto yyloop;

}

if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&

yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

{

yyn = yytable[yyn];

goto yyreduce;

}

if (yyerrflag) goto yyinrecovery;

yyerror("syntax error");

{

goto yystack; /* moved from 6 lines above to here to please C++ */

goto yyerrlab;

** get globals into registers.

** branch to here only if YYBACKUP was called.

yynewstate:

yy_pv = yypv;

yy_ps = yyps;

yy_state = yystate;

goto yy_newstate;

yyerrlab:

++yynerrs;

** get globals into registers.

** either we just started, or we just finished a reduction

yystack:

yy_pv = yypv;

yy_ps = yyps;

yy_state = yystate;

yyinrecovery:

if (yyerrflag < 3)

** top of for (;;) loop while no reductions done

{

yyerrflag = 3;

yy_stack:

for (;;)

{

** put a state and value onto the stacks

if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&

yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)

{

#if YYDEBUG

** if debugging, look up token value in list of value vs.

** name pairs. 0 and negative (-1) are special values.

** Note: linear search is used since time is not a real

** consideration while debugging.

if (yydebug)

printf("%sdebug: state %d, error recovery shifting\

to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);

#endif

if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))

{

goto yyoverflow;

}

yystate = yytable[yyn];

printf( "State %d, token ", yy_state );

*++yystack.s_mark = yytable[yyn];

if ( yychar == 0 )

*++yystack.l_mark = yylval;

printf( "end-of-file\n" );

goto yyloop;

else if ( yychar < 0 )

}

printf( "-none-\n" );

else

{

#if YYDEBUG

for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

if (yydebug)

yy_i++ )

printf("%sdebug: error recovery discarding state %d\n",

{

YYPREFIX, *yystack.s_mark);

if ( yytoks[yy_i].t_val == yychar )

#endif

break;

if (yystack.s_mark <= yystack.s_base) goto yyabort;

--yystack.s_mark;

--yystack.l_mark;

}

printf( "%s\n", yytoks[yy_i].t_name );

}

else

#endif /* YYDEBUG */

if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */

{

if (yychar == 0) goto yyabort;

#if YYDEBUG

** reallocate and recover. Note that pointers

if (yydebug)

** have to be reset, or bad things will happen

long yyps_index = (yy_ps - yys);

long yypv_index = (yy_pv - yyv);

long yypvt_index = (yypvt - yyv);

int yynewmax;

#ifdef YYEXPAND

yynewmax = YYEXPAND(yymaxdepth);

#else

yynewmax = 2 * yymaxdepth; /* double table size */

if (yymaxdepth == YYMAXDEPTH) /* first time growth */

{

char *newyys = (char *)YYNEW(int);

char *newyyv = (char *)YYNEW(YYSTYPE);

if (newyys != 0 && newyyv != 0)

{

yys = YYCOPY(newyys, yys, int);

yyv = YYCOPY(newyyv, yyv, YYSTYPE);

}

else

yynewmax = 0; /* failed */

}

else /* not first time */

{

yys = 0;

yys = YYENLARGE(yys, int);

if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

yyv = YYENLARGE(yyv, YYSTYPE);

if (!yys) yys = "illegal-symbol";

if (yys == 0 || yyv == 0)

printf("%sdebug: state %d, error recovery discards token %d (%s)\n",

yynewmax = 0; /* failed */

YYPREFIX, yystate, yychar, yys);

}

#endif

yychar = YYEMPTY;

if (yynewmax <= yymaxdepth) /* tables not expanded */

goto yyloop;

{

yyerror( "yacc stack overflow" );

YYABORT;

}

yymaxdepth = yynewmax;

yy_ps = yys + yyps_index;

yy_pv = yyv + yypv_index;

yypvt = yyv + yypvt_index;

}

*yy_ps = yy_state;

*++yy_pv = yyval;

yyreduce:

** we have a new state - find out what to do

yy_newstate:

if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )

goto yydefault; /* simple state */

#if YYDEBUG

if (yydebug)

printf("%sdebug: state %d, reducing by rule %d (%s)\n",

** if debugging, need to mark whether new token grabbed

YYPREFIX, yystate, yyn, yyrule[yyn]);

yytmp = yychar < 0;

#endif

yym = yylen[yyn];

if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )

if (yym)

yychar = 0; /* reached EOF */

yyval = yystack.l_mark[1-yym];

#if YYDEBUG

if ( yydebug && yytmp )

{

printf( "Received token " );

if ( yychar == 0 )

printf( "end-of-file\n" );

else if ( yychar < 0 )

printf( "-none-\n" );

else

memset(&yyval, 0, sizeof yyval);

switch (yyn)

{

case 1:

for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

#line 139 "mof.y"

yy_i++ )

{

}

if ( yytoks[yy_i].t_val == yychar )

break;

case 2:

#line 142 "mof.y"

{

}

break;

printf( "%s\n", yytoks[yy_i].t_name );

case 3:

#line 145 "mof.y"

{

YYABORT;

}

break;

case 4:

#line 151 "mof.y"

{

}

break;

#endif /* YYDEBUG */

case 5:

if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )

#line 154 "mof.y"

goto yydefault;

if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/

{

/* [TODO: validate the class here] */

yychar = -1;

yystack.l_mark[0].classDeclaration->flags = MI_FLAG_CLASS;

yyval = yylval;

yystack.l_mark[0].classDeclaration->flags |= GetQualFlags(yystack.l_mark[0].classDeclaration->qualifiers, yystack.l_mark[0].classDeclaration->numQualifiers);

yy_state = yy_n;

if (FinalizeClass(yystack.l_mark[0].classDeclaration) != 0)

if ( yyerrflag > 0 )

YYABORT;

yyerrflag--;

goto yy_stack;

AddClassDecl(yystack.l_mark[0].classDeclaration);

if (state.classDeclCallback)

(*state.classDeclCallback)(yystack.l_mark[0].classDeclaration, state.classDeclCallbackData);

}

break;

case 6:

#line 167 "mof.y"

{

AddQualifierDeclaration(yystack.l_mark[0].qualifierDeclaration);

if (state.qualifierDeclCallback)

yydefault:

(*state.qualifierDeclCallback)(yystack.l_mark[0].qualifierDeclaration, state.qualifierDeclCallbackData);

if ( ( yy_n = yydef[ yy_state ] ) == -2 )

}

break;

case 7:

#line 174 "mof.y"

{

if (FinalizeInstance(yystack.l_mark[0].instanceDeclaration) != 0)

#if YYDEBUG

YYABORT;

yytmp = yychar < 0;

#endif

AddInstanceDecl(yystack.l_mark[0].instanceDeclaration);

if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )

yychar = 0; /* reached EOF */

#if YYDEBUG

if ( yydebug && yytmp )

{

if (state.instanceDeclCallback)

printf( "Received token " );

(*state.instanceDeclCallback)(yystack.l_mark[0].instanceDeclaration, state.instanceDeclCallbackData);

if ( yychar == 0 )

}

printf( "end-of-file\n" );

break;

else if ( yychar < 0 )

case 8:

printf( "-none-\n" );

#line 186 "mof.y"

else

{

if (strcmp(yystack.l_mark[-3].string, "include") == 0)

for ( yy_i = 0;

yytoks[yy_i].t_val >= 0;

yy_i++ )

{

if (openIncludeFile(yystack.l_mark[-1].string) != 0)

if ( yytoks[yy_i].t_val

YYABORT;

== yychar )

}

else if (strcmp(yystack.l_mark[-3].string, "instancelocale") == 0)

{

if (state.pragmaCallback)

break;

(*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);

}

else if (strcmp(yystack.l_mark[-3].string, "locale") == 0)

{

if (state.pragmaCallback)

(*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);

}

else if (strcmp(yystack.l_mark[-3].string, "namespace") == 0)

printf( "%s\n", yytoks[yy_i].t_name );

{

if (state.pragmaCallback)

(*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);

}

else

}

#endif /* YYDEBUG */

** look through exception table

{

yywarnf(ID_UNKNOWN_PRAGMA,

"warning: unknown pragma: %s=%s", yystack.l_mark[-3].string, yystack.l_mark[-1].string);

if (state.pragmaCallback)

while ( ( *yyxi != -1 ) ||

(*state.pragmaCallback)(yystack.l_mark[-3].string, yystack.l_mark[-1].string, state.pragmaCallbackData);

( yyxi[1] != yy_state ) )

{

yyxi += 2;

}

while ( ( *(yyxi += 2) >= 0 ) &&

( *yyxi != yychar ) )

;

if ( ( yy_n = yyxi[1] ) < 0 )

YYACCEPT;

}

break;

}

case 9:

#line 219 "mof.y"

{

** check for syntax error

/* Check whether class already exists */

if (FindClassDecl(yystack.l_mark[-1].string))

if ( yy_n == 0 ) /* have an error */

{

/* no worry about speed here! */

switch ( yyerrflag )

{

case 0: /* new error */

yyerror( "syntax error" );

goto skip_init;

yyerrlab:

** get globals into registers.

** we have a user generated syntax type error

yy_pv = yypv;

yy_ps = yyps;

yy_state = yystate;

skip_init:

yynerrs++;

/* FALLTHRU */

case 1:

case 2: /* incompletely recovered error */

/* try again... */

yyerrflag = 3;

** find state where "error" is a legal

** shift action

while ( yy_ps >= yys )

{

yy_n = yypact[ *yy_ps ] + YYERRCODE;

if ( yy_n >= 0 && yy_n < YYLAST &&

yychk[yyact[yy_n]] == YYERRCODE) {

** simulate shift of "error"

yy_state = yyact[ yy_n ];

goto yy_stack;

}

** current state has no shift on

** "error", pop stack

#if YYDEBUG

# define _POP_ "Error recovery pops state %d, uncovers state %d\n"

if ( yydebug )

printf( _POP_, *yy_ps,

yy_ps[-1] );

# undef _POP_

#endif

yy_ps--;

yy_pv--;

}

** there is no state on stack with "error" as

** a valid shift. give up.

YYABORT;

case 3: /* no shift yet; eat a token */

#if YYDEBUG

** if debugging, look up token in list of

** pairs. 0 and negative shouldn't occur,

** but since timing doesn't matter when

** debugging, it doesn't hurt to leave the

** tests here.

if ( yydebug )

{

printf( "Error recovery discards " );

if ( yychar == 0 )

printf( "token end-of-file\n" );

else if ( yychar < 0 )

printf( "token -none-\n" );

else

{

for ( yy_i = 0;

yytoks[yy_i].t_val >= 0;

yy_i++ )

{

if ( yytoks[yy_i].t_val

== yychar )

{

break;

}

printf( "token %s\n",

yytoks[yy_i].t_name );

}

#endif /* YYDEBUG */

if ( yychar == 0 ) /* reached EOF. quit */

YYABORT;

yychar = -1;

goto yy_newstate;

}

}/* end if ( yy_n == 0 ) */

** reduction by production yy_n

** put stack tops, etc. so things right after switch

#if YYDEBUG

** if debugging, print the string that is the user's

** specification of the reduction which is just about

** to be done.

if ( yydebug )

printf( "Reduce by (%d) \"%s\"\n",

yy_n, yyreds[ yy_n ] );

#endif

yytmp = yy_n; /* value to switch over */

yypvt = yy_pv; /* $vars top of value stack */

** Look in goto table for next state

** Sorry about using yy_state here as temporary

** register variable, but why not, if it works...

** If yyr2[ yy_n ] doesn't have the low order bit

** set, then there is no action to be done for

** this reduction. So, no saving & unsaving of

** registers done. The only difference between the

** code just after the if and the body of the if is

** the goto yy_stack in the body. This way the test

** can be made before the choice of what to do is needed.

{

/* length of production doubled with extra bit */

if ( !( yy_len & 01 ) )

{

yy_len >>= 1;

yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */

yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +

*( yy_ps -= yy_len ) + 1;

if ( yy_state >= YYLAST ||

yychk[ yy_state =

yyact[ yy_state ] ] != -yy_n )

{

yy_state = yyact[ yypgo[ yy_n ] ];

}

goto yy_stack;

}

yy_len >>= 1;

yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */

yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +

*( yy_ps -= yy_len ) + 1;

if ( yy_state >= YYLAST ||

yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )

{

yy_state = yyact[ yypgo[ yy_n ] ];

}

/* save until reenter driver code */

yystate = yy_state;

yyps = yy_ps;

yypv = yy_pv;

}

** code supplied by user is placed in this switch

switch( yytmp )

{

case 1:

# line 167 "mof.y"

{

} break;

case 2:

# line 170 "mof.y"

{

} break;

case 3:

# line 173 "mof.y"

{

YYABORT;

} break;

case 4:

# line 179 "mof.y"

{

} break;

case 5:

# line 182 "mof.y"

{

/* [TODO: validate the class here] */

yypvt[-0].classDeclaration->flags = MI_FLAG_CLASS;

yypvt[-0].classDeclaration->flags |= GetQualFlags(yypvt[-0].classDeclaration->qualifiers, yypvt[-0].classDeclaration->numQualifiers);

if (FinalizeClass(yypvt[-0].classDeclaration) != 0)

YYABORT;

AddClassDecl(yypvt[-0].classDeclaration);

if (state.classDeclCallback)

(*state.classDeclCallback)(yypvt[-0].classDeclaration, state.classDeclCallbackData);

} break;

case 6:

# line 195 "mof.y"

{

AddQualifierDeclaration(yypvt[-0].qualifierDeclaration);

if (state.qualifierDeclCallback)

(*state.qualifierDeclCallback)(yypvt[-0].qualifierDeclaration, state.qualifierDeclCallbackData);

} break;

case 7:

# line 202 "mof.y"

{

if (FinalizeInstance(yypvt[-0].instanceDeclaration) != 0)

YYABORT;

AddInstanceDecl(yypvt[-0].instanceDeclaration);

if (state.instanceDeclCallback)

(*state.instanceDeclCallback)(yypvt[-0].instanceDeclaration, state.instanceDeclCallbackData);

} break;

case 8:

# line 214 "mof.y"

{

if (strcmp(yypvt[-3].string, "include") == 0)

{

if (openIncludeFile(yypvt[-1].string) != 0)

YYABORT;

}

else if (strcmp(yypvt[-3].string, "instancelocale") == 0)

{

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-3].string, yypvt[-1].string, state.pragmaCallbackData);

}

else if (strcmp(yypvt[-3].string, "locale") == 0)

{

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-3].string, yypvt[-1].string, state.pragmaCallbackData);

}

else if (strcmp(yypvt[-3].string, "namespace") == 0)

{

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-3].string, yypvt[-1].string, state.pragmaCallbackData);

}

else if (state.extensionsEnabled == MI_TRUE && strcmp(yypvt[-3].string, "deleteclass") == 0)

{

yywarnf(ID_UNKNOWN_PRAGMA,

"warning: nonstandard pragma: %s(%s)", yypvt[-5].string, yypvt[-3].string);

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-3].string, yypvt[-1].string, state.pragmaCallbackData);

}

else

{

yywarnf(ID_UNKNOWN_PRAGMA,

"warning: unknown pragma: %s(%s)", yypvt[-3].string, yypvt[-1].string);

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-3].string, yypvt[-1].string, state.pragmaCallbackData);

}

} break;

case 9:

# line 250 "mof.y"

{

if (state.extensionsEnabled == MI_TRUE && strcmp(yypvt[-5].string, "deleteclass") == 0)

{

yywarnf(ID_UNKNOWN_PRAGMA,

"warning: nonstandard pragma: %s(%s)", yypvt[-5].string, yypvt[-3].string);

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-5].string, yypvt[-3].string, state.pragmaCallbackData);

}

else

{

yywarnf(ID_UNKNOWN_PRAGMA,

"warning: unknown pragma: %s(%s)", yypvt[-5].string, yypvt[-3].string);

if (state.pragmaCallback)

(*state.pragmaCallback)(yypvt[-5].string, yypvt[-3].string, state.pragmaCallbackData);

}

} break;

case 10:

# line 268 "mof.y"

{

/* Check whether class already exists */

if (FindClassDecl(yypvt[-1].string))

{

if (state.extensionsEnabled == MI_FALSE)

{

yyerrorf(ID_CLASS_ALREADY_DEFINED,

"class already defined: \"%s\"", yystack.l_mark[-1].string);

"class already defined: \"%s\"", yypvt[-1].string);

YYABORT;

}

else

yywarnf(ID_CLASS_ALREADY_DEFINED,

"class already defined: \"%s\"", yypvt[-1].string);

}

yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);

yyval.classDeclaration->flags = MI_FLAG_CLASS;

yyval.classDeclaration->name = yystack.l_mark[-1].string;

yyval.classDeclaration->name = yypvt[-1].string;

yyval.classDeclaration->properties = yystack.l_mark[0].featureList.propertySet.data;

yyval.classDeclaration->properties = yypvt[-0].featureList.propertySet.data;

yyval.classDeclaration->numProperties = yystack.l_mark[0].featureList.propertySet.size;

yyval.classDeclaration->numProperties = yypvt[-0].featureList.propertySet.size;

yyval.classDeclaration->methods = yystack.l_mark[0].featureList.methodList.data;

yyval.classDeclaration->methods = yypvt[-0].featureList.methodList.data;

yyval.classDeclaration->numMethods = yystack.l_mark[0].featureList.methodList.size;

yyval.classDeclaration->numMethods = yypvt[-0].featureList.methodList.size;

}

} break;

break;

case 11:

case 10:

# line 292 "mof.y"

#line 237 "mof.y"

{

const MI_ClassDecl* scd;

/* Check whether class already exists */

if (FindClassDecl(yystack.l_mark[-3].string))

if (FindClassDecl(yypvt[-3].string))

{

if (state.extensionsEnabled == MI_FALSE)

{

yyerrorf(ID_CLASS_ALREADY_DEFINED,

"class already defined: \"%s\"", yystack.l_mark[-3].string);

"class already defined: \"%s\"", yypvt[-3].string);

YYABORT;

}

else

yywarnf(ID_CLASS_ALREADY_DEFINED,

"class already defined: \"%s\"", yypvt[-3].string);

}

/* Check whether superclass exists */

scd = FindClassDecl(yystack.l_mark[-1].string);

scd = FindClassDecl(yypvt[-1].string);

if (!scd)

{

yyerrorf(ID_UNDEFINED_SUPERCLASS,

"super class of \"%s\" is undefined: \"%s\"", yystack.l_mark[-3].string, yystack.l_mark[-1].string);

"super class of \"%s\" is undefined: \"%s\"", yypvt[-3].string, yypvt[-1].string);

YYABORT;

}

yyval.classDeclaration = CALLOC_T(MI_ClassDecl, 1);

yyval.classDeclaration->flags = MI_FLAG_CLASS;

yyval.classDeclaration->name = yystack.l_mark[-3].string;

yyval.classDeclaration->name = yypvt[-3].string;

yyval.classDeclaration->superClass = yystack.l_mark[-1].string;

yyval.classDeclaration->superClass = yypvt[-1].string;

yyval.classDeclaration->superClassDecl = (MI_ClassDecl*)scd;