cimmof_tab.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif

#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
#line 168 "cimmof.y"
typedef union YYSTYPE {
  //char                     *strval;
  CIMClass                 *mofclass;
  CIMFlavor                *flavor;
  CIMInstance              *instance;
  CIMKeyBinding            *keybinding;
  CIMMethod                *method;
  CIMName                  *cimnameval;
  CIMObjectPath            *reference;
  CIMProperty              *property;
  CIMQualifier             *qualifier;
  CIMQualifierDecl         *mofqualifier;
  CIMScope                 *scope;
  CIMType                   datatype;
  CIMValue                 *value;
  int                       ival;
  modelPath                *modelpath;
  String                   *strptr;
  String                   *strval;
  struct pragma            *pragma;
  TYPED_INITIALIZER_VALUE  *typedinitializer;
} YYSTYPE;
/* Line 191 of yacc.c.  */
#line 380 "cimmoftemp"
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif



/* Copy the second part of user declarations.  */


/* Line 214 of yacc.c.  */
#line 392 "cimmoftemp"

#if ! defined (yyoverflow) || YYERROR_VERBOSE

/* The parser invokes alloca or malloc; define the necessary symbols.  */

# if YYSTACK_USE_ALLOCA
#  define YYSTACK_ALLOC alloca
# else
#  ifndef YYSTACK_USE_ALLOCA
#   if defined (alloca) || defined (_ALLOCA_H)
#    define YYSTACK_ALLOC alloca
#   else
#    ifdef __GNUC__
#     define YYSTACK_ALLOC __builtin_alloca
#    endif
#   endif
#  endif
# endif

# ifdef YYSTACK_ALLOC
   /* Pacify GCC's `empty if-body' warning. */
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# else
#  if defined (__STDC__) || defined (__cplusplus)
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
#   define YYSIZE_T size_t
#  endif
#  define YYSTACK_ALLOC malloc
#  define YYSTACK_FREE free
# endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */


#if (! defined (yyoverflow) \
     && (! defined (__cplusplus) \
	 || (YYSTYPE_IS_TRIVIAL)))

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  short yyss;
  YYSTYPE yyvs;
  };

/* The size of the maximum gap between one aligned stack and the next.  */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# define YYSTACK_BYTES(N) \
     ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
      + YYSTACK_GAP_MAXIMUM)

/* Copy COUNT objects from FROM to TO.  The source and destination do
   not overlap.  */
# ifndef YYCOPY
#  if 1 < __GNUC__
#   define YYCOPY(To, From, Count) \
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
#  else
#   define YYCOPY(To, From, Count)		\
      do					\
	{					\
	  register YYSIZE_T yyi;		\
	  for (yyi = 0; yyi < (Count); yyi++)	\
	    (To)[yyi] = (From)[yyi];		\
	}					\
      while (0)
#  endif
# endif

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack)					\
    do									\
      {									\
	YYSIZE_T yynewbytes;						\
	YYCOPY (&yyptr->Stack, Stack, yysize);				\
	Stack = &yyptr->Stack;						\
	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
	yyptr += yynewbytes / sizeof (*yyptr);				\
      }									\
    while (0)

#endif

#if defined (__STDC__) || defined (__cplusplus)
   typedef signed char yysigned_char;
#else
   typedef short yysigned_char;
#endif

/* YYFINAL -- State number of the termination state. */
#define YYFINAL  32
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   292

/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS  68
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS  84
/* YYNRULES -- Number of rules. */
#define YYNRULES  160
/* YYNRULES -- Number of states. */
#define YYNSTATES  239

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
#define YYUNDEFTOK  2
#define YYMAXUTOK   322

#define YYTRANSLATE(YYX) 						\
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
static const unsigned char yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
      65,    66,    67
};

#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
   YYRHS.  */
static const unsigned short yyprhs[] =
{
       0,     0,     3,     5,     8,     9,    11,    13,    15,    17,
      20,    26,    28,    31,    32,    37,    41,    43,    46,    48,
      50,    52,    57,    60,    64,    66,    68,    70,    74,    75,
      80,    82,    84,    88,    93,    95,   102,   104,   106,   109,
     110,   113,   115,   117,   121,   124,   125,   128,   129,   131,
     133,   135,   137,   139,   141,   143,   145,   149,   151,   153,
     155,   157,   159,   161,   163,   165,   167,   169,   171,   173,
     175,   177,   179,   182,   184,   188,   191,   193,   195,   200,
     202,   205,   206,   208,   212,   214,   218,   222,   224,   227,
     228,   230,   233,   239,   244,   246,   249,   255,   257,   259,
     265,   267,   273,   280,   285,   289,   293,   295,   299,   301,
     303,   305,   307,   309,   311,   313,   315,   317,   322,   323,
     326,   328,   332,   334,   336,   338,   340,   342,   344,   345,
     347,   350,   352,   354,   356,   358,   360,   362,   364,   366,
     368,   370,   372,   374,   376,   378,   380,   382,   386,   387,
     389,   391,   395,   399,   401,   403,   407,   411,   413,   414,
     416
};

/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const short yyrhs[] =
{
      69,     0,    -1,    70,    -1,    71,    70,    -1,    -1,   125,
      -1,   129,    -1,    72,    -1,   120,    -1,    73,    76,    -1,
     144,     9,    74,   118,    75,    -1,    62,    -1,    10,    74,
      -1,    -1,    38,    77,    55,    60,    -1,    38,    55,    60,
      -1,    78,    -1,    77,    78,    -1,    87,    -1,    79,    -1,
      90,    -1,   144,    80,    81,    82,    -1,   141,    83,    -1,
      39,    84,    56,    -1,    60,    -1,    62,    -1,    85,    -1,
      84,    11,    85,    -1,    -1,   144,    86,    95,    97,    -1,
     141,    -1,    94,    -1,   144,    88,    89,    -1,   141,    96,
      97,    98,    -1,    60,    -1,   144,    91,    52,    92,    93,
      60,    -1,    62,    -1,    62,    -1,    31,   107,    -1,    -1,
      74,    52,    -1,    62,    -1,    62,    -1,    40,    47,    57,
      -1,    40,    57,    -1,    -1,    31,   100,    -1,    -1,   102,
      -1,   108,    -1,   109,    -1,   103,    -1,    42,    -1,   108,
      -1,   109,    -1,   102,    -1,   101,    11,   102,    -1,   103,
      -1,    42,    -1,   104,    -1,    51,    -1,     8,    -1,   106,
      -1,   105,    -1,    47,    -1,    61,    -1,    43,    -1,    34,
      -1,     7,    -1,    32,    -1,    66,    -1,   107,    -1,   106,
     107,    -1,    63,    -1,    38,   101,    55,    -1,    38,    55,
      -1,   110,    -1,   111,    -1,    13,   112,   114,    13,    -1,
     119,    -1,   113,    10,    -1,    -1,   107,    -1,    74,    46,
     115,    -1,   116,    -1,   115,    11,   116,    -1,   117,    31,
      99,    -1,    62,    -1,     5,   119,    -1,    -1,     3,    -1,
     121,   122,    -1,   144,    37,    44,    74,   118,    -1,    38,
     123,    55,    60,    -1,   124,    -1,   123,   124,    -1,   144,
      62,    31,   100,    60,    -1,   126,    -1,   128,    -1,    48,
      35,    39,   127,    56,    -1,   107,    -1,    48,   150,    39,
     151,    56,    -1,    50,   148,   130,   131,   135,    60,    -1,
      10,   141,    97,    98,    -1,   132,   133,    56,    -1,    11,
      59,    39,    -1,   134,    -1,   133,    11,   134,    -1,     9,
      -1,    58,    -1,     6,    -1,    36,    -1,    49,    -1,    53,
      -1,    41,    -1,    45,    -1,     4,    -1,    11,   136,   137,
      56,    -1,    -1,    33,    39,    -1,   138,    -1,   137,    11,
     138,    -1,    29,    -1,    12,    -1,    54,    -1,    64,    -1,
      65,    -1,   140,    -1,    -1,   138,    -1,   140,   138,    -1,
     142,    -1,   143,    -1,    24,    -1,    14,    -1,    17,    -1,
      28,    -1,    23,    -1,    25,    -1,    20,    -1,    26,    -1,
      21,    -1,    27,    -1,    22,    -1,    15,    -1,    18,    -1,
      19,    -1,   145,   146,    57,    -1,    -1,    40,    -1,   147,
      -1,   146,    11,   147,    -1,   148,   149,   139,    -1,    62,
      -1,   134,    -1,    39,   103,    56,    -1,    39,    42,    56,
      -1,   108,    -1,    -1,    62,    -1,    63,    -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
static const unsigned short yyrline[] =
{
       0,   311,   311,   314,   315,   319,   320,   322,   324,   337,
     345,   365,   368,   369,   372,   373,   376,   377,   380,   383,
     386,   403,   414,   433,   436,   439,   445,   446,   447,   450,
     476,   477,   492,   506,   522,   537,   554,   557,   560,   561,
     564,   568,   571,   574,   579,   580,   583,   584,   591,   592,
     593,   599,   605,   611,   617,   627,   629,   642,   643,   646,
     647,   648,   649,   650,   653,   654,   655,   658,   661,   666,
     667,   670,   671,   677,   709,   711,   715,   716,   719,   736,
     763,   765,   768,   771,   777,   778,   781,   791,   794,   801,
     807,   818,   838,   855,   860,   861,   868,   925,   929,   935,
     942,   945,   963,   973,   981,   984,   988,   989,   994,   996,
     997,   998,  1000,  1001,  1002,  1003,  1004,  1008,  1010,  1016,
    1019,  1020,  1032,  1034,  1035,  1036,  1037,  1040,  1041,  1044,
    1045,  1049,  1050,  1051,  1052,  1053,  1056,  1057,  1058,  1059,
    1060,  1061,  1062,  1063,  1064,  1067,  1068,  1080,  1081,  1087,
    1095,  1096,  1100,  1116,  1118,  1124,  1130,  1136,  1142,  1149,
    1152
};
#endif

#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "TOK_ALIAS_IDENTIFIER", "TOK_ANY", 
  "TOK_AS", "TOK_ASSOCIATION", "TOK_BINARY_VALUE", "TOK_CHAR_VALUE", 
  "TOK_CLASS", "TOK_COLON", "TOK_COMMA", "TOK_DISABLEOVERRIDE", 
  "TOK_DQUOTE", "TOK_DT_BOOL", "TOK_DT_CHAR16", "TOK_DT_CHAR8", 
  "TOK_DT_DATETIME", "TOK_DT_REAL32", "TOK_DT_REAL64", "TOK_DT_SINT16", 
  "TOK_DT_SINT32", "TOK_DT_SINT64", "TOK_DT_SINT8", "TOK_DT_STR", 
  "TOK_DT_UINT16", "TOK_DT_UINT32", "TOK_DT_UINT64", "TOK_DT_UINT8", 
  "TOK_ENABLEOVERRIDE", "TOK_END_OF_FILE", "TOK_EQUAL", "TOK_FALSE", 
  "TOK_FLAVOR", "TOK_HEX_VALUE", "TOK_INCLUDE", "TOK_INDICATION", 
  "TOK_INSTANCE", "TOK_LEFTCURLYBRACE", "TOK_LEFTPAREN", 
  "TOK_LEFTSQUAREBRACKET", "TOK_METHOD", "TOK_NULL_VALUE", 
  "TOK_OCTAL_VALUE", "TOK_OF", "TOK_PARAMETER", "TOK_PERIOD", 
  "TOK_POSITIVE_DECIMAL_VALUE", "TOK_PRAGMA", "TOK_PROPERTY", 
  "TOK_QUALIFIER", "TOK_REAL_VALUE", "TOK_REF", "TOK_REFERENCE", 
  "TOK_RESTRICTED", "TOK_RIGHTCURLYBRACE", "TOK_RIGHTPAREN", 
  "TOK_RIGHTSQUAREBRACKET", "TOK_SCHEMA", "TOK_SCOPE", "TOK_SEMICOLON", 
  "TOK_SIGNED_DECIMAL_VALUE", "TOK_SIMPLE_IDENTIFIER", "TOK_STRING_VALUE", 
  "TOK_TOSUBCLASS", "TOK_TRANSLATABLE", "TOK_TRUE", "TOK_UNEXPECTED_CHAR", 
  "$accept", "mofSpec", "mofProductions", "mofProduction", 
  "classDeclaration", "classHead", "className", "superClass", "classBody", 
  "classFeatures", "classFeature", "methodDeclaration", "methodHead", 
  "methodBody", "methodEnd", "methodName", "parameters", "parameter", 
  "parameterType", "propertyDeclaration", "propertyBody", "propertyEnd", 
  "referenceDeclaration", "referencedObject", "referenceName", 
  "referencePath", "objectRef", "parameterName", "propertyName", "array", 
  "typedDefaultValue", "initializer", "typedInitializer", 
  "constantValues", "constantValue", "nonNullConstantValue", 
  "integerValue", "booleanValue", "stringValues", "stringValue", 
  "arrayInitializer", "referenceInitializer", "objectHandle", 
  "aliasInitializer", "namespaceHandleRef", "namespaceHandle", 
  "modelPath", "keyValuePairList", "keyValuePair", "keyValuePairName", 
  "alias", "aliasIdentifier", "instanceDeclaration", "instanceHead", 
  "instanceBody", "valueInitializers", "valueInitializer", 
  "compilerDirective", "compilerDirectiveInclude", "fileName", 
  "compilerDirectivePragma", "qualifierDeclaration", "qualifierValue", 
  "scope", "scope_begin", "metaElements", "metaElement", "defaultFlavor", 
  "flavorHead", "explicitFlavors", "explicitFlavor", "flavor", 
  "overrideFlavors", "dataType", "intDataType", "realDataType", 
  "qualifierList", "qualifierListBegin", "qualifiers", "qualifier", 
  "qualifierName", "typedQualifierParameter", "pragmaName", "pragmaVal", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const unsigned short yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
     315,   316,   317,   318,   319,   320,   321,   322
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const unsigned char yyr1[] =
{
       0,    68,    69,    70,    70,    71,    71,    71,    71,    72,
      73,    74,    75,    75,    76,    76,    77,    77,    78,    78,
      78,    79,    80,    81,    82,    83,    84,    84,    84,    85,
      86,    86,    87,    88,    89,    90,    91,    92,    93,    93,
      94,    95,    96,    97,    97,    97,    98,    98,    99,    99,
      99,   100,   100,   100,   100,   101,   101,   102,   102,   103,
     103,   103,   103,   103,   104,   104,   104,   104,   104,   105,
     105,   106,   106,   107,   108,   108,   109,   109,   110,   111,
     112,   112,   113,   114,   115,   115,   116,   117,   118,   118,
     119,   120,   121,   122,   123,   123,   124,   125,   125,   126,
     127,   128,   129,   130,   131,   132,   133,   133,   134,   134,
     134,   134,   134,   134,   134,   134,   134,   135,   135,   136,
     137,   137,   138,   138,   138,   138,   138,   139,   139,   140,
     140,   141,   141,   141,   141,   141,   142,   142,   142,   142,
     142,   142,   142,   142,   142,   143,   143,   144,   144,   145,
     146,   146,   147,   148,   148,   149,   149,   149,   149,   150,
     151
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */