path: root/TAO/orbsvcs/PSS/PSDL_y.cpp

// $Id$
/* A Bison parser, made from PSDL.yy
   by GNU bison 1.35.  */

#define YYBISON 1  /* Identify Bison output.  */

#define yyparse TAO_PSDL_yyparse
#define yylex TAO_PSDL_yylex
#define yyerror TAO_PSDL_yyerror
#define yylval TAO_PSDL_yylval
#define yychar TAO_PSDL_yychar
#define yydebug TAO_PSDL_yydebug
#define yynerrs TAO_PSDL_yynerrs
# define  TAO_PSDL_SEMI 257
# define  TAO_PSDL_MODULE 258
# define  TAO_PSDL_COLON  259
# define  TAO_PSDL_OPEN_CURLY_BRACE 260
# define  TAO_PSDL_CLOSE_CURLY_BRACE  261
# define  TAO_PSDL_OPEN_BRACE 262
# define  TAO_PSDL_CLOSE_BRACE  263
# define  TAO_PSDL_ABSTRACT 264
# define  TAO_PSDL_STORAGETYPE  265
# define  TAO_PSDL_STORAGEHOME  266
# define  TAO_PSDL_CATALOG  267
# define  TAO_PSDL_PROVIDES 268
# define  TAO_PSDL_IMPLEMENTS 269
# define  TAO_PSDL_SCOPE  270
# define  TAO_PSDL_STORES 271
# define  TAO_PSDL_STATE  272
# define  TAO_PSDL_AS 273
# define  TAO_PSDL_PRIMARY  274
# define  TAO_PSDL_STRONG 275
# define  TAO_PSDL_REF  276
# define  TAO_PSDL_OF 277
# define  TAO_PSDL_OPEN_ANGULAR_BRACE 278
# define  TAO_PSDL_CLOSE_ANGULAR_BRACE  279
# define  TAO_PSDL_COMMA  280
# define  TAO_PSDL_KEY  281
# define  TAO_PSDL_READONLY 282
# define  TAO_PSDL_UNION  283
# define  TAO_PSDL_SWITCH 284
# define  TAO_PSDL_CASE 285
# define  TAO_PSDL_WCHAR  286
# define  TAO_PSDL_BOOLEAN  287
# define  TAO_PSDL_OCTET  288
# define  TAO_PSDL_ANY  289
# define  TAO_PSDL_OBJECT 290
# define  TAO_PSDL_STRUCT 291
# define  TAO_PSDL_DEFAULT  292
# define  TAO_PSDL_FLOAT  293
# define  TAO_PSDL_DOUBLE 294
# define  TAO_PSDL_LONG 295
# define  TAO_PSDL_SHORT  296
# define  TAO_PSDL_UNSIGNED 297
# define  TAO_PSDL_CHAR 298
# define  TAO_PSDL_IDENT  299
# define  TAO_PSDL_TYPEDEF  300
# define  TAO_PSDL_NATIVE 301
# define  TAO_PSDL_PLUS 302
# define  TAO_PSDL_MINUS  303
# define  TAO_PSDL_XOR  304
# define  TAO_PSDL_AND  305
# define  TAO_PSDL_MULT 306
# define  TAO_PSDL_RIGHT_SHIFT  307
# define  TAO_PSDL_LEFT_SHIFT 308
# define  TAO_PSDL_DIV  309
# define  TAO_PSDL_PERCENT  310
# define  TAO_PSDL_TILDA  311
# define  TAO_PSDL_ONEWAY 312
# define  TAO_PSDL_CONST  313
# define  TAO_PSDL_EQUAL  314
# define  TAO_PSDL_OR 315
# define  TAO_PSDL_VOID 316
# define  TAO_PSDL_IN 317
# define  TAO_PSDL_OUT  318
# define  TAO_PSDL_INOUT  319
# define  TAO_PSDL_RAISES 320
# define  TAO_PSDL_CONTEXT  321
# define  TAO_PSDL_FIXED  322
# define  TAO_PSDL_VALUEBASE  323
# define  TAO_PSDL_EXCEPTION  324
# define  TAO_PSDL_INTERFACE  325
# define  TAO_PSDL_LOCAL  326
# define  TAO_PSDL_DOUBLE_COLON 327
# define  TAO_PSDL_VALUETYPE  328
# define  TAO_PSDL_CUSTOM 329
# define  TAO_PSDL_TRUNCATABLE  330
# define  TAO_PSDL_SUPPORTS 331
# define  TAO_PSDL_STRING 332
# define  TAO_PSDL_WSTRING  333
# define  TAO_PSDL_ATTRIBUTE  334
# define  TAO_PSDL_OPEN_SQUARE_BRACE  335
# define  TAO_PSDL_CLOSE_SQUARE_BRACE 336
# define  TAO_PSDL_ENUM 337
# define  TAO_PSDL_SEQUENCE 338
# define  TAO_PSDL_TRUE 339
# define  TAO_PSDL_FALSE  340
# define  TAO_PSDL_INTEGER  341
# define  TAO_PSDL_FLOATING 342
# define  TAO_PSDL_PRIVATE  343
# define  TAO_PSDL_PUBLIC 344
# define  TAO_PSDL_FACTORY  345
# define  TAO_PSDL_FLOATING_PT  346
# define  TAO_PSDL_CHAR_LITERAL 347
# define  TAO_PSDL_FIXED_PT 348

#line 1 "PSDL.yy"

// $Id$
// ========================================================================
//
// = LIBRARY
//   orbsvcs / Persistent State Definition Language parser.
//
// = FILENAME
//   PSDL.yy
//
// = AUTHOR
//   Priyanka Gontla <pgontla@doc.ece.uci.edu>
//
// ========================================================================

#include "PSDL_y.h"
#include "PSDL_Node.h"
#include "PSDL_Interpreter.h"
#include "PSDL_Scope.h"
#include "PSDL_Module_Scope.h"

#define YYPARSE_PARAM lex_state
#define YYLEX_PARAM lex_state

//extern int yylex (TAO_PSDL_Node **, void *);
extern int yylex (void);

static void yyerror (const char *error)
{
  ACE_OS::printf ("Error %s\n", error);
}

#ifndef YYSTYPE
# define YYSTYPE int
# define YYSTYPE_IS_TRIVIAL 1
#endif
#ifndef YYDEBUG
# define YYDEBUG 0
#endif



#define YYFINAL   593
#define YYFLAG    -32768
#define YYNTBASE  95

/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
#define YYTRANSLATE(x) ((unsigned)(x) <= 348 ? yytranslate[x] : 262)

/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
static const 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,     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,    68,    69,    70,    71,    72,    73,    74,    75,
      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
      86,    87,    88,    89,    90,    91,    92,    93,    94
};

#if YYDEBUG
static const short yyprhs[] =
{
       0,     0,     2,     5,     8,    11,    14,    17,    20,    23,
      26,    29,    32,    35,    38,    39,    46,    48,    50,    55,
      59,    63,    66,    70,    73,    75,    78,    81,    84,    87,
      89,    93,    98,   102,   104,   106,   108,   110,   112,   118,
     123,   125,   127,   131,   136,   140,   147,   153,   155,   158,
     161,   164,   167,   170,   172,   176,   181,   185,   191,   194,
     201,   207,   212,   218,   221,   223,   227,   229,   232,   235,
     238,   242,   244,   246,   251,   255,   258,   263,   267,   271,
     273,   276,   279,   282,   285,   288,   290,   293,   298,   301,
     307,   312,   314,   316,   321,   326,   330,   337,   343,   349,
     354,   356,   359,   362,   365,   368,   370,   373,   377,   381,
     383,   386,   388,   390,   392,   395,   397,   400,   402,   404,
     406,   408,   410,   412,   414,   416,   418,   420,   422,   424,
     426,   428,   430,   432,   434,   436,   438,   440,   442,   444,
     448,   450,   452,   454,   456,   460,   462,   464,   466,   469,
     471,   473,   475,   477,   479,   481,   483,   486,   488,   490,
     492,   495,   498,   502,   504,   506,   508,   510,   512,   514,
     515,   522,   524,   527,   531,   541,   543,   545,   547,   549,
     551,   553,   556,   560,   564,   567,   572,   576,   579,   585,
     587,   589,   591,   593,   595,   597,   599,   601,   603,   605,
     607,   609,   613,   615,   619,   621,   625,   627,   631,   635,
     637,   641,   645,   647,   651,   655,   659,   662,   664,   666,
     668,   670,   672,   674,   678,   681,   686,   690,   692,   699,
     705,   711,   717,   722,   727,   731,   733,   735,   737,   741,
     744,   748,   754,   756,   758,   760,   765,   772,   777,   779,
     781,   783,   785,   792,   794,   796,   799,   802,   804,   806,
     811,   815,   819,   823,   826,   829,   832,   835,   837,   841,
     845,   848,   850,   853,   856,   859,   862,   865,   868,   871,
     873,   877,   881,   883,   887,   889,   891,   893,   895,   897,
     900,   903,   905,   908,   915,   921,   926,   930,   933,   936,
     942,   947,   950,   954,   957,   962,   964,   969,   971,   974,
     978,   983,   987,   993,   995,   999,  1006,  1011,  1013,  1015,
    1017,  1019,  1021,  1023,  1025,  1027,  1029,  1031,  1033,  1035,
    1037,  1039,  1041,  1043,  1045,  1047,  1051,  1053,  1055,  1057,
    1062,  1067,  1074,  1080,  1082,  1086,  1090,  1092,  1094,  1098,
    1102
};
static const short yyrhs[] =
{
      96,     0,    95,    96,     0,   150,     3,     0,   188,     3,
       0,   201,     3,     0,   216,     3,     0,    97,     3,     0,
     121,     3,     0,   141,     3,     0,   111,     3,     0,   127,
       3,     0,    99,     3,     0,   227,     3,     0,     0,     4,
     149,    98,     6,    95,     7,     0,   100,     0,   101,     0,
     103,     6,   104,     7,     0,   103,     6,     7,     0,    10,
      11,   149,     0,    11,   149,     0,    10,   102,   106,     0,
      10,   102,     0,   105,     0,   105,   104,     0,   108,     3,
       0,   119,     3,     0,     5,   107,     0,   225,     0,   225,
      26,   107,     0,    28,    18,   109,   159,     0,    18,   109,
     159,     0,   154,     0,   235,     0,   236,     0,   110,     0,
     225,     0,    21,    22,    24,   107,    25,     0,    22,    24,
     107,    25,     0,   113,     0,   112,     0,    10,    12,   149,
       0,   114,     6,   115,     7,     0,   114,     6,     7,     0,
      10,    12,   149,    23,   107,   117,     0,    10,    12,   149,
      23,   107,     0,   116,     0,   116,   115,     0,   119,     3,
       0,   120,     3,     0,   260,     3,     0,     5,   118,     0,
     225,     0,   225,    26,   118,     0,   205,   202,   206,   209,
       0,   205,   202,   206,     0,    27,   149,     8,   160,     9,
       0,    27,   149,     0,    13,   149,   122,     6,   124,     7,
       0,    13,   149,     6,   124,     7,     0,    13,   149,     6,
       7,     0,    13,   149,   122,     6,     7,     0,     5,   123,
       0,   225,     0,   225,    26,   123,     0,   125,     0,   125,
     124,     0,   126,     3,     0,   119,     3,     0,    14,   118,
     159,     0,   128,     0,   129,     0,   130,     6,   131,     7,
       0,   130,     6,     7,     0,    11,   149,     0,    11,   149,
     133,   135,     0,    11,   149,   133,     0,    11,   149,   135,
       0,   132,     0,   132,   131,     0,   108,     3,     0,   138,
       3,     0,   140,     3,     0,     5,   134,     0,   225,     0,
      15,   107,     0,    22,    24,   134,    25,     0,    16,   146,
       0,    17,   159,    19,   139,   137,     0,    17,   159,    19,
     139,     0,   134,     0,   136,     0,    22,     8,   159,     9,
       0,   142,     6,   143,     7,     0,   142,     6,     7,     0,
      12,   149,    23,   134,   145,   147,     0,    12,   149,    23,
     134,   145,     0,    12,   149,    23,   134,   147,     0,    12,
     149,    23,   134,     0,   144,     0,   144,   143,     0,   120,
       3,     0,   148,     3,     0,     5,   146,     0,   225,     0,
      15,   118,     0,    20,    27,   149,     0,    20,    27,    22,
       0,    45,     0,    46,   151,     0,   178,     0,   182,     0,
     240,     0,    47,   159,     0,   215,     0,   152,   157,     0,
     153,     0,   156,     0,   154,     0,   155,     0,   225,     0,
     162,     0,   163,     0,   172,     0,   173,     0,   174,     0,
     175,     0,   176,     0,   177,     0,   214,     0,   242,     0,
     235,     0,   236,     0,   212,     0,   178,     0,   182,     0,
     240,     0,   158,     0,   158,    26,   157,     0,   159,     0,
     161,     0,   149,     0,   159,     0,   160,    26,   159,     0,
     237,     0,    39,     0,    40,     0,    41,    40,     0,   164,
       0,   168,     0,   165,     0,   166,     0,   167,     0,    42,
       0,    41,     0,    41,    41,     0,   169,     0,   170,     0,
     171,     0,    43,    42,     0,    43,    41,     0,    43,    41,
      41,     0,    44,     0,    32,     0,    33,     0,    34,     0,
      35,     0,    36,     0,     0,    37,   149,   179,     6,   180,
       7,     0,   181,     0,   181,   180,     0,   152,   157,     3,
       0,    29,   149,    30,     8,   183,     9,     6,   184,     7,
       0,   163,     0,   172,     0,   174,     0,   240,     0,   225,
       0,   185,     0,   185,   184,     0,   186,   187,     3,     0,
      31,   190,     5,     0,    38,     5,     0,    31,   190,     5,
     186,     0,    38,     5,   186,     0,   152,   158,     0,    59,
     189,   149,    60,   190,     0,   163,     0,   172,     0,   173,
       0,   174,     0,   162,     0,   235,     0,   236,     0,   213,
       0,   225,     0,   175,     0,   191,     0,   192,     0,   191,
      61,   192,     0,   193,     0,   192,    50,   193,     0,   194,
       0,   193,    51,   194,     0,   195,     0,   194,    53,   195,
       0,   194,    54,   195,     0,   196,     0,   195,    48,   196,
       0,   195,    49,   196,     0,   197,     0,   196,    52,   197,
       0,   196,    55,   197,     0,   196,    56,   197,     0,   198,
     199,     0,   199,     0,    49,     0,    48,     0,    57,     0,
     225,     0,   243,     0,     8,   190,     9,     0,    70,   149,
       0,   200,     6,   180,     7,     0,   200,     6,     7,     0,
     149,     0,   204,   205,   202,   206,   209,   210,     0,   205,
     202,   206,   209,   210,     0,   204,   205,   202,   206,   209,
       0,   204,   205,   202,   206,   210,     0,   205,   202,   206,
     209,     0,   205,   202,   206,   210,     0,   205,   202,   206,
       0,    58,     0,   211,     0,    62,     0,     8,   207,     9,
       0,     8,     9,     0,   208,   211,   159,     0,   208,   211,
     159,    26,   207,     0,    63,     0,    64,     0,    65,     0,
      66,     8,   225,     9,     0,    66,     8,   225,    26,   226,
       9,     0,    67,     8,   249,     9,     0,   154,     0,   235,
       0,   236,     0,   225,     0,    68,    24,   259,    26,   259,
      25,     0,    68,     0,    69,     0,    37,   149,     0,    29,
     149,     0,   217,     0,   218,     0,   220,     6,   221,     7,
       0,   220,     6,     7,     0,    10,    71,   149,     0,    72,
      71,   149,     0,    71,   149,     0,    71,   149,     0,    10,
     219,     0,    72,   219,     0,   219,     0,    10,   219,   223,
       0,    72,   219,   223,     0,   219,   223,     0,   222,     0,
     222,   221,     0,   150,     3,     0,   188,     3,     0,   201,
       3,     0,   239,     3,     0,   203,     3,     0,     5,   224,
       0,   225,     0,   225,    26,   224,     0,   149,    73,   225,
       0,   149,     0,   149,    26,   226,     0,   149,     0,   232,
       0,   231,     0,   230,     0,   229,     0,    74,   149,     0,
      10,   228,     0,   228,     0,   228,   152,     0,    10,   228,
     234,     6,   222,     7,     0,    10,   228,     6,   222,     7,
       0,   233,     6,   253,     7,     0,    75,   228,   234,     0,
     228,   234,     0,    75,   228,     0,     5,    76,   252,    77,
     224,     0,     5,   252,    77,   224,     0,    77,   224,     0,
       5,    76,   252,     0,     5,   252,     0,    78,    24,   259,
      25,     0,    78,     0,    79,    24,   259,    25,     0,    79,
       0,   149,   238,     0,    81,   259,    82,     0,    28,    80,
     211,   159,     0,    80,   211,   159,     0,    83,   149,     6,
     241,     7,     0,   149,     0,   149,    26,   241,     0,    84,
      24,   153,    26,   259,    25,     0,    84,    24,   153,    25,
       0,   245,     0,   249,     0,   250,     0,   247,     0,   248,
       0,   251,     0,   246,     0,   244,     0,    85,     0,    86,
       0,    87,     0,    92,     0,    93,     0,    32,     0,    78,
       0,    79,     0,    94,     0,   225,     0,   225,    26,   252,
       0,   222,     0,   254,     0,   255,     0,    90,   152,   157,
       3,     0,    89,   152,   157,     3,     0,    91,   149,     8,
     256,     9,     3,     0,    91,   149,     8,     9,     3,     0,
     257,     0,   257,    26,   256,     0,   258,   211,   159,     0,
      63,     0,   190,     0,    91,   149,   261,     0,     8,   159,
       9,     0,     8,     9,     0
};

#endif

#if YYDEBUG
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const short yyrline[] =
{
       0,    78,    80,    85,    87,    90,    93,    96,    99,   102,
     105,   108,   111,   114,   119,   119,   131,   134,   139,   141,
     146,   150,   160,   163,   168,   171,   176,   179,   184,   189,
     192,   197,   199,   204,   206,   209,   212,   215,   220,   223,
     228,   230,   235,   240,   243,   248,   251,   256,   259,   264,
     267,   270,   275,   280,   283,   288,   291,   297,   299,   304,
     306,   309,   312,   317,   321,   323,   328,   330,   335,   337,
     342,   346,   348,   353,   355,   360,   364,   366,   369,   374,
     376,   381,   383,   386,   391,   395,   399,   403,   407,   411,
     413,   418,   421,   426,   430,   432,   437,   439,   442,   445,
     450,   452,   457,   459,   464,   468,   472,   476,   478,   483,
     487,   489,   492,   495,   498,   501,   506,   510,   512,   517,
     519,   522,   527,   529,   532,   535,   538,   541,   544,   547,
     550,   555,   557,   560,   563,   568,   570,   573,   578,   580,
     585,   587,   592,   596,   598,   603,   607,   609,   612,   617,
     619,   624,   626,   629,   634,   638,   642,   646,   648,   651,
     656,   660,   664,   668,   672,   676,   680,   684,   688,   692,
     692,   705,   707,   712,   716,   720,   722,   725,   728,   731,
     736,   738,   743,   747,   749,   752,   755,   760,   764,   768,
     770,   773,   776,   779,   782,   785,   788,   791,   794,   799,
     803,   805,   810,   812,   817,   819,   824,   826,   829,   834,
     836,   839,   844,   846,   849,   852,   857,   859,   864,   866,
     869,   874,   876,   879,   884,   893,   898,   906,   917,   920,
     924,   928,   932,   936,   940,   946,   950,   952,   957,   959,
     964,   966,   971,   973,   976,   981,   983,   988,   992,   994,
     997,  1000,  1005,  1009,  1013,  1017,  1019,  1024,  1026,  1031,
    1036,  1044,  1046,  1049,  1054,  1064,  1066,  1069,  1072,  1075,
    1078,  1083,  1085,  1090,  1092,  1095,  1098,  1101,  1106,  1111,
    1113,  1118,  1120,  1125,  1127,  1132,  1134,  1137,  1140,  1145,
    1149,  1151,  1156,  1160,  1162,  1167,  1171,  1173,  1176,  1181,
    1183,  1186,  1189,  1192,  1198,  1200,  1205,  1207,  1212,  1216,
    1220,  1222,  1227,  1231,  1233,  1238,  1240,  1245,  1247,  1250,
    1253,  1256,  1259,  1262,  1265,  1270,  1272,  1277,  1281,  1285,
    1289,  1293,  1297,  1301,  1305,  1307,  1312,  1314,  1317,  1322,
    1324,  1329,  1331,  1336,  1338,  1343,  1347,  1351,  1355,  1359,
    1361
};
#endif


#if (YYDEBUG) || defined YYERROR_VERBOSE

/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
static const char *const yytname[] =
{
  "$", "error", "$undefined.", "TAO_PSDL_SEMI", "TAO_PSDL_MODULE",
  "TAO_PSDL_COLON", "TAO_PSDL_OPEN_CURLY_BRACE",
  "TAO_PSDL_CLOSE_CURLY_BRACE", "TAO_PSDL_OPEN_BRACE",
  "TAO_PSDL_CLOSE_BRACE", "TAO_PSDL_ABSTRACT", "TAO_PSDL_STORAGETYPE",
  "TAO_PSDL_STORAGEHOME", "TAO_PSDL_CATALOG", "TAO_PSDL_PROVIDES",
  "TAO_PSDL_IMPLEMENTS", "TAO_PSDL_SCOPE", "TAO_PSDL_STORES",
  "TAO_PSDL_STATE", "TAO_PSDL_AS", "TAO_PSDL_PRIMARY", "TAO_PSDL_STRONG",
  "TAO_PSDL_REF", "TAO_PSDL_OF", "TAO_PSDL_OPEN_ANGULAR_BRACE",
  "TAO_PSDL_CLOSE_ANGULAR_BRACE", "TAO_PSDL_COMMA", "TAO_PSDL_KEY",
  "TAO_PSDL_READONLY", "TAO_PSDL_UNION", "TAO_PSDL_SWITCH",
  "TAO_PSDL_CASE", "TAO_PSDL_WCHAR", "TAO_PSDL_BOOLEAN", "TAO_PSDL_OCTET",
  "TAO_PSDL_ANY", "TAO_PSDL_OBJECT", "TAO_PSDL_STRUCT",
  "TAO_PSDL_DEFAULT", "TAO_PSDL_FLOAT", "TAO_PSDL_DOUBLE",
  "TAO_PSDL_LONG", "TAO_PSDL_SHORT", "TAO_PSDL_UNSIGNED", "TAO_PSDL_CHAR",
  "TAO_PSDL_IDENT", "TAO_PSDL_TYPEDEF", "TAO_PSDL_NATIVE",
  "TAO_PSDL_PLUS", "TAO_PSDL_MINUS", "TAO_PSDL_XOR", "TAO_PSDL_AND",
  "TAO_PSDL_MULT", "TAO_PSDL_RIGHT_SHIFT", "TAO_PSDL_LEFT_SHIFT",
  "TAO_PSDL_DIV", "TAO_PSDL_PERCENT", "TAO_PSDL_TILDA", "TAO_PSDL_ONEWAY",
  "TAO_PSDL_CONST", "TAO_PSDL_EQUAL", "TAO_PSDL_OR", "TAO_PSDL_VOID",
  "TAO_PSDL_IN", "TAO_PSDL_OUT", "TAO_PSDL_INOUT", "TAO_PSDL_RAISES",
  "TAO_PSDL_CONTEXT", "TAO_PSDL_FIXED", "TAO_PSDL_VALUEBASE",
  "TAO_PSDL_EXCEPTION", "TAO_PSDL_INTERFACE", "TAO_PSDL_LOCAL",
  "TAO_PSDL_DOUBLE_COLON", "TAO_PSDL_VALUETYPE", "TAO_PSDL_CUSTOM",
  "TAO_PSDL_TRUNCATABLE", "TAO_PSDL_SUPPORTS", "TAO_PSDL_STRING",
  "TAO_PSDL_WSTRING", "TAO_PSDL_ATTRIBUTE", "TAO_PSDL_OPEN_SQUARE_BRACE",
  "TAO_PSDL_CLOSE_SQUARE_BRACE", "TAO_PSDL_ENUM", "TAO_PSDL_SEQUENCE",
  "TAO_PSDL_TRUE", "TAO_PSDL_FALSE", "TAO_PSDL_INTEGER",
  "TAO_PSDL_FLOATING", "TAO_PSDL_PRIVATE", "TAO_PSDL_PUBLIC",
  "TAO_PSDL_FACTORY", "TAO_PSDL_FLOATING_PT", "TAO_PSDL_CHAR_LITERAL",
  "TAO_PSDL_FIXED_PT", "psdl_specification", "psdl_definition",
  "psdl_module", "@1", "abstract_storagetype", "abstract_storagetype_dcl",
  "abstract_storagetype_fwd_dcl", "storagetype_identifier",
  "abstract_storagetype_header", "abstract_storagetype_body",
  "abstract_storagetype_member", "abstract_storagetype_inh_spec",
  "abstract_storagetype_name", "psdl_state_dcl", "psdl_state_type_spec",
  "abstract_storagetype_ref_type", "abstract_storagehome",
  "abstract_storagehome_fwd_dcl", "abstract_storagehome_dcl",
  "abstract_storagehome_header", "abstract_storagehome_body",
  "abstract_storagehome_member", "abstract_storagehome_inh_spec",
  "abstract_storagehome_name", "local_op_dcl", "key_dcl", "catalog",
  "catalog_inh_spec", "catalog_name", "catalog_body", "catalog_member",
  "provides_dcl", "storagetype", "storagetype_dcl", "storagetype_fwd_dcl",
  "storagetype_header", "storagetype_body", "storagetype_member",
  "storagetype_inh_spec", "storagetype_name", "storagetype_impl_spec",
  "storagetype_ref_type", "storagehome_scope", "store_directive",
  "psdl_concrete_state_type", "ref_rep_directive", "storagehome",
  "storagehome_header", "storagehome_body", "storagehome_member",
  "storagehome_inh_spec", "storagehome_name", "storagehome_impl_spec",
  "primary_key_dcl", "identifier", "type_dcl", "type_declarator",
  "type_spec", "simple_type_spec", "base_type_spec", "template_type_spec",
  "constr_type_spec", "declarators", "declarator", "simple_declarator",
  "simple_declarator_list", "complex_declarator", "floating_pt_type",
  "integer_type", "signed_int", "signed_short_int", "signed_long_int",
  "signed_longlong_int", "unsigned_int", "unsigned_short_int",
  "unsigned_long_int", "unsigned_longlong_int", "char_type",
  "wide_char_type", "boolean_type", "octet_type", "any_type",
  "object_type", "struct_type", "@2", "member_list", "member",
  "union_type", "switch_type_spec", "switch_body", "case", "case_label",
  "element_spec", "const_dcl", "const_type", "const_exp", "or_expr",
  "xor_expr", "and_expr", "shift_expr", "add_expr", "mult_expr",
  "unary_expr", "unary_operator", "primary_expr", "except_header",
  "except_dcl", "op_name", "op_dcl", "op_attribute", "op_type_spec",
  "parameter_dcls", "param_dcl", "param_attribute", "raises_expr",
  "context_expr", "param_type_spec", "fixed_pt_type",
  "fixed_pt_const_type", "value_base_type", "constr_forward_decl",
  "interface", "interface_dcl", "forward_dcl", "interface_identifier",
  "interface_header", "interface_body", "export",
  "interface_inheritance_spec", "interface_name", "scoped_name",
  "comma_scoped_name", "value", "value_common_base", "value_forward_dcl",
  "value_box_dcl", "value_abs_dcl", "value_dcl", "value_header",
  "value_inheritance_spec", "string_type", "wide_string_type",
  "array_declarator", "fixed_array_size", "attr_dcl", "enum_type",
  "enumerator", "sequence_type", "literal", "boolean_literal",
  "integer_literal", "floating_pt_literal", "character_literal",
  "wide_character_literal", "string_literal", "wide_string_literal",
  "fixed_pt_literal", "value_name", "value_element", "state_member",
  "init_dcl", "init_param_decls", "init_param_decl",
  "init_param_attribute", "positive_int_const", "factory_dcl",
  "factory_parameters", 0
};
#endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const short yyr1[] =
{
       0,    95,    95,    96,    96,    96,    96,    96,    96,    96,
      96,    96,    96,    96,    98,    97,    99,    99,   100,   100,
     101,   102,   103,   103,   104,   104,   105,   105,   106,   107,
     107,   108,   108,   109,   109,   109,   109,   109,   110,   110,
     111,   111,   112,   113,   113,   114,   114,   115,   115,   116,
     116,   116,   117,   118,   118,   119,   119,   120,   120,   121,
     121,   121,   121,   122,   123,   123,   124,   124,   125,   125,
     126,   127,   127,   128,   128,   129,   130,   130,   130,   131,
     131,   132,   132,   132,   133,   134,   135,   136,   137,   138,
     138,   139,   139,   140,   141,   141,   142,   142,   142,   142,
     143,   143,   144,   144,   145,   146,   147,   148,   148,   149,
     150,   150,   150,   150,   150,   150,   151,   152,   152,   153,
     153,   153,   154,   154,   154,   154,   154,   154,   154,   154,
     154,   155,   155,   155,   155,   156,   156,   156,   157,   157,
     158,   158,   159,   160,   160,   161,   162,   162,   162,   163,
     163,   164,   164,   164,   165,   166,   167,   168,   168,   168,
     169,   170,   171,   172,   173,   174,   175,   176,   177,   179,
     178,   180,   180,   181,   182,   183,   183,   183,   183,   183,
     184,   184,   185,   186,   186,   186,   186,   187,   188,   189,
     189,   189,   189,   189,   189,   189,   189,   189,   189,   190,
     191,   191,   192,   192,   193,   193,   194,   194,   194,   195,
     195,   195,   196,   196,   196,   196,   197,   197,   198,   198,
     198,   199,   199,   199,   200,   201,   201,   202,   203,   203,
     203,   203,   203,   203,   203,   204,   205,   205,   206,   206,
     207,   207,   208,   208,   208,   209,   209,   210,   211,   211,
     211,   211,   212,   213,   214,   215,   215,   216,   216,   217,
     217,   218,   218,   218,   219,   220,   220,   220,   220,   220,
     220,   221,   221,   222,   222,   222,   222,   222,   223,   224,
     224,   225,   225,   226,   226,   227,   227,   227,   227,   228,
     229,   229,   230,   231,   231,   232,   233,   233,   233,   234,
     234,   234,   234,   234,   235,   235,   236,   236,   237,   238,
     239,   239,   240,   241,   241,   242,   242,   243,   243,   243,
     243,   243,   243,   243,   243,   244,   244,   245,   246,   247,
     248,   249,   250,   251,   252,   252,   253,   253,   253,   254,
     254,   255,   255,   256,   256,   257,   258,   259,   260,   261,
     261
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const short yyr2[] =
{
       0,     1,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     0,     6,     1,     1,     4,     3,
       3,     2,     3,     2,     1,     2,     2,     2,     2,     1,
       3,     4,     3,     1,     1,     1,     1,     1,     5,     4,
       1,     1,     3,     4,     3,     6,     5,     1,     2,     2,
       2,     2,     2,     1,     3,     4,     3,     5,     2,     6,
       5,     4,     5,     2,     1,     3,     1,     2,     2,     2,
       3,     1,     1,     4,     3,     2,     4,     3,     3,     1,
       2,     2,     2,     2,     2,     1,     2,     4,     2,     5,
       4,     1,     1,     4,     4,     3,     6,     5,     5,     4,
       1,     2,     2,     2,     2,     1,     2,     3,     3,     1,
       2,     1,     1,     1,     2,     1,     2,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     3,
       1,     1,     1,     1,     3,     1,     1,     1,     2,     1,
       1,     1,     1,     1,     1,     1,     2,     1,     1,     1,
       2,     2,     3,     1,     1,     1,     1,     1,     1,     0,
       6,     1,     2,     3,     9,     1,     1,     1,     1,     1,
       1,     2,     3,     3,     2,     4,     3,     2,     5,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     3,     1,     3,     1,     3,     1,     3,     3,     1,
       3,     3,     1,     3,     3,     3,     2,     1,     1,     1,
       1,     1,     1,     3,     2,     4,     3,     1,     6,     5,
       5,     5,     4,     4,     3,     1,     1,     1,     3,     2,
       3,     5,     1,     1,     1,     4,     6,     4,     1,     1,
       1,     1,     6,     1,     1,     2,     2,     1,     1,     4,
       3,     3,     3,     2,     2,     2,     2,     1,     3,     3,
       2,     1,     2,     2,     2,     2,     2,     2,     2,     1,
       3,     3,     1,     3,     1,     1,     1,     1,     1,     2,
       2,     1,     2,     6,     5,     4,     3,     2,     2,     5,
       4,     2,     3,     2,     4,     1,     4,     1,     2,     3,
       4,     3,     5,     1,     3,     6,     4,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     3,     1,     1,     1,     4,
       4,     6,     5,     1,     3,     3,     1,     1,     3,     3,
       2
};

/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
   doesn't specify something else to do.  Zero means the default is an
   error. */
static const short yydefact[] =
{
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     1,     0,
       0,    16,    17,     0,     0,    41,    40,     0,     0,     0,
      71,    72,     0,     0,     0,     0,   111,   112,     0,     0,
       0,   115,     0,   257,   258,   267,     0,     0,   291,   288,
     287,   286,   285,     0,   113,   109,    14,     0,     0,     0,
      23,   265,   290,    75,     0,     0,   256,   169,     0,   164,
     165,   166,   167,   168,     0,   146,   147,   155,   154,     0,
     163,     0,   254,   305,   307,     0,   282,   110,     0,   117,
     119,   120,   118,   122,   123,   149,   151,   152,   153,   150,
     157,   158,   159,   124,   125,   126,   127,   128,   129,   135,
     136,   134,   130,   121,   132,   133,   137,   131,   142,   114,
     253,   193,   189,   190,   191,   192,   198,     0,   196,   197,
     194,   195,   224,   264,     0,   266,   289,   298,     0,     2,
       7,    12,     0,    10,     0,     8,    11,     0,     9,     0,
       3,     4,     0,     5,     6,     0,   270,     0,    13,     0,
       0,   292,   297,     0,     0,    21,    42,   264,     0,    22,
     268,     0,     0,     0,     0,    77,    78,     0,     0,     0,
       0,     0,     0,     0,   169,   148,   156,   161,   160,     0,
       0,     0,     0,     0,   142,   116,   138,   140,   141,   145,
       0,   264,   269,   296,     0,    19,     0,     0,   237,     0,
      24,     0,     0,   248,     0,   236,   251,   249,   250,    44,
       0,     0,     0,    47,     0,     0,     0,    74,     0,     0,
       0,     0,    79,     0,     0,    95,     0,     0,     0,   100,
       0,   226,     0,     0,   171,   278,   279,   260,     0,   235,
       0,     0,     0,     0,     0,     0,     0,     0,   271,     0,
       0,   334,   303,   301,     0,     0,     0,   336,     0,   337,
     338,     0,     0,    28,    29,     0,     0,    84,    85,    86,
      76,    99,    63,    64,    61,     0,     0,     0,    66,     0,
       0,     0,     0,   162,     0,   330,   219,   218,   220,   331,
     332,   325,   326,   327,   328,   329,   333,   347,   199,   200,
     202,   204,   206,   209,   212,     0,   217,   221,   222,   324,
     317,   323,   320,   321,   318,   319,   322,     0,     0,     0,
       0,   281,     0,   308,     0,     0,   313,     0,     0,     0,
       0,    36,    33,    37,    34,    35,     0,    18,    25,    26,
      27,   227,     0,    58,     0,    43,    48,    49,    50,    51,
       0,     0,    81,    73,    80,    82,    83,     0,   102,    94,
     101,   103,     0,   225,   172,     0,     0,     0,   273,   274,
     275,   277,     0,     0,   259,   272,   276,   302,     0,     0,
       0,     0,     0,   295,     0,    46,     0,   294,     0,     0,
       0,    97,    98,     0,     0,    53,    69,    60,    67,    68,
      62,     0,   155,   175,   176,   177,     0,   179,   178,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,   216,     0,   304,   306,   316,     0,     0,   139,   188,
       0,   312,     0,     0,    32,     0,     0,    56,     0,     0,
     348,     0,     0,   108,   107,   173,   280,     0,   311,     0,
     234,     0,   335,   300,     0,     0,     0,    15,     0,    45,
      30,   293,   104,   105,   106,    96,    65,    70,     0,    59,
       0,   170,   223,   201,   203,   205,   207,   208,   210,   211,
     213,   214,   215,     0,     0,   309,   314,     0,     0,    31,
     239,   242,   243,   244,     0,     0,     0,    55,   143,     0,
     350,     0,     0,    91,    92,    90,    93,   310,     0,     0,
     232,   233,   299,   340,   339,     0,   346,     0,   343,     0,
      52,    54,     0,   252,   315,     0,    39,   238,     0,     0,
      57,     0,   349,     0,     0,    89,   230,   231,     0,   229,
     342,     0,     0,     0,     0,     0,     0,   180,     0,    38,
     240,     0,   144,     0,    88,   228,     0,   341,   344,   345,
       0,   184,   174,   181,     0,     0,     0,   245,     0,    87,
     247,   183,   186,   187,   182,   241,   284,     0,   185,     0,
     246,   283,     0,     0
};

static const short yydefgoto[] =
{
      17,    18,    19,   164,    20,    21,    22,    60,    23,   209,
     210,   169,   273,   211,   340,   341,    24,    25,    26,    27,
     222,   223,   469,   404,   286,   225,    28,   180,   282,   287,
     288,   289,    29,    30,    31,    32,   231,   232,   175,   277,
     176,   514,   545,   233,   515,   234,    33,    34,   238,   239,
     401,   472,   402,   240,    86,   251,    87,   242,    89,   213,
      91,    92,   195,   196,   197,   509,   198,    93,    94,    95,
      96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
     106,   107,   108,    36,   182,   243,   244,    37,   416,   556,
     557,   558,   575,   252,   127,   307,   308,   309,   310,   311,
     312,   313,   314,   315,   316,    39,   253,   352,   254,   255,
     214,   447,   504,   505,   507,   521,   215,   111,   128,   112,
      41,    42,    43,    44,    45,    46,   257,   258,   156,   245,
     317,   587,    47,    48,    49,    50,    51,    52,    53,   162,
     217,   218,   199,   333,   259,    54,   337,   117,   318,   319,
     320,   321,   322,   323,   324,   325,   326,   262,   268,   269,
     270,   527,   528,   529,   327,   226,   450
};

static const short yypact[] =
{
     671,    66,    84,    66,    66,    66,    66,    66,  1142,    66,
    1060,    66,    66,     1,    66,    44,    66,   553,-32768,    87,
     129,-32768,-32768,   151,   175,-32768,-32768,   153,   209,   218,
  -32768,-32768,   234,   246,   244,   251,-32768,-32768,   254,   252,
     256,-32768,   258,-32768,-32768,   176,   257,   261,   608,-32768,
  -32768,-32768,-32768,   262,-32768,-32768,-32768,    66,    66,    66,
     268,   176,    43,    69,   259,   131,   245,   271,    66,-32768,
  -32768,-32768,-32768,-32768,    66,-32768,-32768,   152,-32768,   174,
  -32768,   255,-32768,   274,   282,   289,   243,-32768,    66,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,    66,-32768,-32768,
  -32768,-32768,-32768,   314,    66,   176,-32768,    35,   317,-32768,
  -32768,-32768,   798,-32768,   442,-32768,-32768,   189,-32768,   146,
  -32768,-32768,   724,-32768,-32768,    66,-32768,   742,-32768,    18,
      66,-32768,-32768,   979,   319,   323,   297,   324,    66,-32768,
  -32768,  1090,   325,    66,    66,   315,-32768,    66,    66,   839,
     328,   330,   334,   245,-32768,-32768,-32768,   302,-32768,   372,
     372,   372,  1122,    66,   263,-32768,   320,-32768,-32768,-32768,
     285,   344,-32768,-32768,    66,-32768,  1042,   331,-32768,   341,
    1011,   347,   348,-32768,    66,-32768,-32768,-32768,-32768,-32768,
      66,    66,   345,   926,   350,   351,   352,-32768,    66,   349,
     353,   354,   208,   356,   359,-32768,   337,   362,   360,    89,
     367,-32768,    66,   364,  1142,-32768,   346,-32768,   293,-32768,
    1209,   371,   374,   376,   379,  1195,    66,   368,  1090,   380,
      66,   358,   308,-32768,  1142,  1142,    66,-32768,   385,-32768,
  -32768,   671,    66,-32768,   369,   387,  1090,-32768,-32768,-32768,
  -32768,   172,-32768,   370,-32768,    66,   383,   391,   895,   396,
     854,   105,  1142,-32768,   372,-32768,-32768,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   355,   357,
     363,   180,   190,   143,-32768,    36,-32768,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,   384,   377,   381,
     217,-32768,   372,-32768,    66,   372,   398,   402,   403,   404,
      66,-32768,-32768,-32768,-32768,-32768,  1042,-32768,-32768,-32768,
  -32768,-32768,   397,   418,   419,-32768,-32768,-32768,-32768,-32768,
     411,    66,-32768,-32768,-32768,-32768,-32768,    54,-32768,-32768,
  -32768,-32768,   428,-32768,-32768,    66,  1209,    66,-32768,-32768,
  -32768,-32768,    66,   397,-32768,-32768,-32768,   361,    66,    66,
      66,    66,   424,-32768,   651,   430,    66,-32768,   426,    66,
      66,   421,-32768,    66,    66,   414,-32768,-32768,-32768,-32768,
  -32768,   434,   401,-32768,-32768,-32768,   436,-32768,-32768,   439,
     443,   372,   372,   372,   372,   372,   372,   372,   372,   372,
     372,-32768,   372,-32768,-32768,-32768,   372,   378,-32768,-32768,
      66,-32768,   413,    66,-32768,    66,    80,   388,    66,    53,
  -32768,    58,   444,-32768,-32768,-32768,-32768,    66,-32768,   397,
     178,    66,-32768,-32768,   440,   459,    37,-32768,    66,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    66,-32768,
     461,-32768,-32768,   357,   363,   180,   190,   190,   143,   143,
  -32768,-32768,-32768,   445,   446,-32768,-32768,    66,   447,-32768,
  -32768,-32768,-32768,-32768,   470,  1209,   460,-32768,-32768,   115,
  -32768,   479,   465,-32768,-32768,   475,-32768,-32768,   178,   484,
     427,-32768,-32768,-32768,-32768,   490,-32768,   486,   471,  1209,
  -32768,-32768,   132,-32768,-32768,   473,-32768,-32768,    66,    66,
  -32768,    66,-32768,    66,    66,-32768,   427,-32768,   422,-32768,
  -32768,   493,   438,    66,   372,   494,   496,   132,  1142,-32768,
     481,   156,-32768,   483,-32768,-32768,   501,-32768,-32768,-32768,
     507,   132,-32768,-32768,    66,   510,   137,-32768,    66,-32768,
  -32768,   132,-32768,-32768,-32768,-32768,   489,   509,-32768,    66,
  -32768,-32768,   516,-32768
};

static const short yypgoto[] =
{
     248,   -16,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   312,
  -32768,-32768,  -165,  -126,   177,-32768,-32768,-32768,-32768,-32768,
     301,-32768,-32768,  -377,   -83,  -131,-32768,-32768,   122,  -202,
  -32768,-32768,-32768,-32768,-32768,-32768,   294,-32768,-32768,  -150,
     373,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   288,-32768,
  -32768,   -15,   127,-32768,    -1,    19,-32768,    29,   338,    77,
  -32768,-32768,  -230,   -43,    57,-32768,-32768,   522,     4,-32768,
  -32768,-32768,-32768,-32768,-32768,-32768,-32768,    21,   524,    31,
     525,-32768,-32768,    27,-32768,  -190,-32768,    71,-32768,   -21,
  -32768,  -387,-32768,    25,-32768,  -243,-32768,   117,   120,   116,
    -177,  -174,  -220,-32768,   228,-32768,    28,  -240,-32768,-32768,
    -124,  -354,   -32,-32768,  -408,  -449,  -200,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,   149,-32768,   287,  -137,   -18,  -143,
      12,   -42,-32768,    63,-32768,-32768,-32768,-32768,-32768,   -24,
      22,    45,-32768,-32768,-32768,    16,   106,-32768,-32768,-32768,
  -32768,-32768,-32768,-32768,     2,-32768,-32768,  -253,-32768,-32768,
  -32768,    -3,-32768,-32768,  -108,-32768,-32768
};


#define YYLAST    1288


static const short yytable[] =
{
      56,   139,    63,    64,    65,    66,    67,   387,   118,   279,
     132,   133,   372,   136,   122,   138,   383,   263,   237,    35,
     113,   230,   129,   474,   116,    38,   267,   281,    40,   460,
     114,   123,   130,   256,   275,   109,    35,    88,   172,   256,
     159,   125,    38,   170,   294,    40,   525,   256,   159,   171,
     377,   420,   520,   115,   374,   131,   165,   166,   167,   212,
     113,   224,   510,    55,   116,    62,   119,   183,   295,   547,
     114,   549,   134,   184,   173,   109,   453,   161,   137,   110,
     512,    55,   328,   329,   174,    90,   408,   194,   411,   500,
     140,   530,   439,   115,   260,    57,    58,   565,    55,    55,
     526,   531,   419,    55,   438,   518,   230,   395,   237,   236,
     546,    55,   160,   203,   299,   300,   220,   202,    14,   110,
     160,   301,   302,   303,   540,    90,   200,   212,   304,   305,
     306,   382,   141,   201,   256,   462,   178,   179,    70,   398,
     224,   541,   459,   501,   502,   503,   412,    78,    79,    80,
      55,    61,   256,   235,   216,    59,   216,   142,    14,   144,
     464,   465,   135,   554,   113,   577,   236,   246,   116,   216,
     555,   261,   246,   220,   114,   216,   457,   399,   143,   109,
     274,   155,   578,   216,   582,   278,   274,   400,    16,   278,
     283,   216,   185,   186,   588,   428,   227,   115,   429,   430,
     501,   502,   503,   336,   113,   331,   228,   206,   490,   491,
     492,   229,   145,   351,   114,   187,   188,   207,   343,   353,
     354,   146,   216,   110,   437,   228,   206,   118,   344,    90,
     229,   470,   456,   424,   425,   216,   207,   115,   426,   427,
     147,   194,   435,   436,   506,   519,   463,   486,   487,   148,
     149,   345,   488,   489,   150,   351,   113,   151,   152,   153,
     116,   154,   216,   157,   158,   392,   114,   216,   163,    90,
     216,   109,   261,   168,  -255,   181,   113,   113,   498,   189,
     116,   116,   177,   342,   274,   360,   114,   114,   216,   115,
      35,   109,   109,   390,   391,   413,    38,   405,   190,    40,
     216,   513,   216,   417,   113,   538,   191,   418,   116,   115,
     115,   570,   414,   192,   114,   110,   193,  -263,   522,   109,
     272,    90,   415,   204,   493,   271,   -20,  -261,   494,   553,
     174,   276,   535,   194,   290,   110,   110,   115,   291,   118,
     292,    90,    90,   293,   332,   335,   334,  -262,   347,   346,
     349,   350,   355,   357,   358,   359,   362,   361,   343,   365,
     118,   363,   366,   110,   367,   368,   454,   369,   344,    90,
     371,   373,   375,   376,   378,   384,   118,   379,   139,   380,
     294,   351,   381,   386,   388,   389,   406,   246,   216,   194,
     194,   345,   393,   563,   397,   396,   403,   444,   407,   409,
     261,   246,   433,   118,   295,   446,   434,   422,   274,   441,
     432,   473,   405,    35,   423,   283,   421,    55,   452,    38,
     296,   297,    40,   342,   440,   442,   448,   449,   443,   298,
     451,   455,   466,   471,   458,   468,   400,   497,   461,   336,
     478,   479,   186,   523,   118,   480,   481,   118,   118,   219,
     299,   300,   482,   516,   506,   274,   118,   301,   302,   303,
     495,   477,   524,   278,   304,   305,   306,   532,   539,   220,
     533,   534,   536,   246,    69,    70,    71,    72,    73,   537,
     405,    75,    76,    77,    78,    79,    80,    55,   542,   543,
     405,   544,   548,   550,   519,   551,   567,   552,   559,   571,
     299,   526,   499,   572,   208,   508,   511,   576,   579,   274,
     580,    82,   581,   584,   517,   589,   593,   216,   590,   394,
      83,    84,   348,   445,   356,   476,   364,   370,   475,   564,
     330,   583,   121,   221,   124,   126,   573,   118,   483,   485,
     118,   216,   484,   431,   585,   385,   496,   591,   280,   568,
     566,   561,   118,   592,     0,   278,   473,     1,     0,     0,
       0,     0,     0,     2,     3,     4,     5,     0,     0,     0,
     113,     0,     0,   194,   116,     0,     0,   586,     0,     0,
     114,     0,     6,     0,     0,   109,     0,   574,   586,     0,
       7,     0,     0,     0,     0,   560,     0,     0,   562,     8,
       9,     0,     0,   115,     0,     0,     0,     0,     0,     0,
     569,     0,    10,   159,     0,     0,     0,     0,     0,     0,
       0,     0,     0,    11,    12,    13,     0,    14,    15,   110,
       0,     0,     0,     0,     0,    90,    16,    68,     0,     0,
      69,    70,    71,    72,    73,    74,     0,    75,    76,    77,
      78,    79,    80,    55,     0,     1,     0,     0,   467,     0,
       0,     2,     3,     4,     5,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     1,    81,    82,     0,     0,
       6,     2,     3,     4,     5,   160,    83,    84,     7,     0,
       0,    16,    85,     0,     0,     0,     0,     8,     9,     0,
       6,     0,     0,     0,     0,     0,     0,     0,     7,     0,
      10,     0,     0,     0,     0,     0,     0,     8,     9,     0,
       0,    11,    12,    13,     0,    14,    15,     0,     0,     0,
      10,   241,     0,     0,    16,     0,     0,     0,     0,     0,
       0,    11,    12,    13,     0,    14,    15,     0,     0,   247,
       0,     0,     0,    68,    16,     0,    69,    70,    71,    72,
      73,    74,     0,    75,    76,    77,    78,    79,    80,    55,
     248,     6,     0,     0,    69,    70,    71,    72,    73,     7,
       0,    75,    76,    77,    78,    79,    80,    55,     8,     9,
       0,     0,    81,    82,     0,     0,     0,     0,     0,     0,
     249,    10,    83,    84,   208,   205,     0,    16,    85,     0,
       0,    82,    11,     0,     0,     0,   206,     0,     0,     0,
      83,    84,   250,     0,     0,    16,   207,     0,     0,     0,
      69,    70,    71,    72,    73,     0,     0,    75,    76,    77,
      78,    79,    80,    55,     0,     0,   284,     0,     0,     0,
       0,     0,     0,   285,     0,     0,     0,     0,     0,     0,
     208,   410,     0,     0,     0,     0,     0,    82,   285,     0,
       0,    69,    70,    71,    72,    73,    83,    84,    75,    76,
      77,    78,    79,    80,    55,     0,    69,    70,    71,    72,
      73,     0,     0,    75,    76,    77,    78,    79,    80,    55,
       0,   208,     0,     0,     0,     0,     0,     0,    82,   285,
       0,     0,     0,     0,     0,     0,   208,    83,    84,     0,
       0,     0,     0,    82,     0,     0,     0,    69,    70,    71,
      72,    73,    83,    84,    75,    76,    77,    78,    79,    80,
      55,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,     0,   220,     0,     0,     0,   208,    69,    70,
      71,    72,    73,     0,    82,    75,    76,    77,    78,    79,
      80,    55,     0,    83,    84,     0,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,   208,     0,
       0,     0,     0,     0,     0,    82,     0,     0,     0,     0,
       0,     0,     0,     0,    83,    84,     0,   248,     6,     0,
       0,    69,    70,    71,    72,    73,     7,   221,    75,    76,
      77,    78,    79,    80,    55,     8,     9,     0,     0,   206,
       0,     0,     0,     0,     0,     0,     0,   249,    10,   207,
       0,   208,     0,    69,    70,    71,    72,    73,    82,    11,
      75,    76,    77,    78,    79,    80,    55,    83,    84,   250,
       0,     0,    16,   338,   339,     0,     0,     0,   264,   265,
     266,     0,     0,   208,    69,    70,    71,    72,    73,     0,
      82,    75,    76,    77,    78,    79,    80,    55,     0,    83,
      84,     0,    69,    70,    71,     0,     0,     0,     0,    75,
      76,    77,    78,    79,    80,    55,     0,     0,     0,     0,
       0,    82,     0,     0,     0,     0,     0,     0,   248,     6,
      83,    84,    69,    70,    71,    72,    73,     7,   120,    75,
      76,    77,    78,    79,    80,    55,     8,     9,    83,    84,
       0,     0,     0,     0,     0,     0,     0,     0,   249,    10,
       0,     0,   208,     0,    69,    70,    71,    72,    73,    82,
      11,    75,    76,    77,    78,    79,    80,    55,    83,    84,
     250,    68,     0,    16,    69,    70,    71,    72,    73,    74,
       0,    75,    76,    77,    78,    79,    80,    55,     0,     0,
      81,    82,     0,     0,     0,     0,     0,     0,     0,     0,
      83,    84,     0,     0,     0,     0,    85,     0,     0,     0,
      81,    82,     0,     0,     0,     0,     0,     0,     0,     0,
      83,    84,     0,     0,     0,    16,    85,    69,    70,    71,
      72,    73,     0,     0,    75,    76,    77,    78,    79,    80,
      55,    69,    70,    71,    72,    73,     0,     0,    75,    76,
      77,    78,    79,    80,    55,     0,     0,   208,     0,     0,
       0,     0,     0,     0,    82,     0,     0,     0,     0,     0,
       0,     0,     0,    83,    84,     0,     0,     0,    82,     0,
       0,     0,     0,     0,     0,     0,     0,    83,    84
};

static const short yycheck[] =
{
       1,    17,     3,     4,     5,     6,     7,   260,     9,   174,
      11,    12,   242,    14,    10,    16,   256,   160,   149,     0,
       8,   147,    10,   400,     8,     0,   163,   177,     0,   383,
       8,    10,    10,   157,   171,     8,    17,     8,    62,   163,
       5,    10,    17,    61,     8,    17,     9,   171,     5,     6,
     250,   294,   460,     8,   244,    10,    57,    58,    59,   142,
      48,   144,     9,    45,    48,     2,     9,    68,    32,   518,
      48,   520,    71,    74,     5,    48,    22,    48,    15,     8,
      22,    45,   190,   191,    15,     8,   288,    88,   290,     9,
       3,   468,   335,    48,    76,    11,    12,   546,    45,    45,
      63,   478,   292,    45,   334,   459,   232,   272,   239,    20,
     518,    45,    77,   137,    78,    79,    27,   135,    74,    48,
      77,    85,    86,    87,     9,    48,   127,   210,    92,    93,
      94,   255,     3,   134,   258,   388,     5,     6,    33,   276,
     223,    26,   382,    63,    64,    65,    41,    42,    43,    44,
      45,     2,   276,     7,   142,    71,   144,     6,    74,     6,
     390,   391,    13,    31,   152,     9,    20,   155,   152,   157,
      38,   159,   160,    27,   152,   163,   376,     5,     3,   152,
     168,     5,    26,   171,   571,   173,   174,    15,    83,   177,
     178,   179,    40,    41,   581,    52,     7,   152,    55,    56,
      63,    64,    65,   204,   192,   193,    17,    18,   428,   429,
     430,    22,     3,   214,   192,    41,    42,    28,   206,   220,
     221,     3,   210,   152,   332,    17,    18,   228,   206,   152,
      22,   396,   375,    53,    54,   223,    28,   192,    48,    49,
       6,   242,    25,    26,    66,    67,   389,   424,   425,     3,
       6,   206,   426,   427,     3,   256,   244,     3,     6,     3,
     244,     3,   250,     6,     3,   266,   244,   255,     6,   192,
     258,   244,   260,     5,     3,    30,   264,   265,   443,    24,
     264,   265,    23,   206,   272,   228,   264,   265,   276,   244,
     271,   264,   265,   264,   265,   291,   271,   285,    24,   271,
     288,   451,   290,   291,   292,   505,    24,   291,   292,   264,
     265,   554,   291,    24,   292,   244,    73,     3,   461,   292,
      23,   244,   291,     6,   432,     6,     3,     3,   436,   529,
      15,     6,   497,   334,     6,   264,   265,   292,     8,   340,
       6,   264,   265,    41,    81,    60,    26,     3,     7,    18,
       3,     3,     7,     3,     3,     3,     3,     8,   346,     3,
     361,     7,     3,   292,    27,     3,   367,     7,   346,   292,
       3,     7,    26,    80,     3,     7,   377,     3,   394,     3,
       8,   382,     3,     3,    26,    77,     3,   375,   376,   390,
     391,   346,     7,   543,     7,    26,    26,   340,     7,     3,
     388,   389,    25,   404,    32,     8,    25,    50,   396,     7,
      26,   399,   400,   394,    51,   403,    61,    45,   361,   394,
      48,    49,   394,   346,    26,    22,     8,     8,    24,    57,
      19,     3,     8,     7,   377,     5,    15,    24,    77,   440,
      26,     7,    41,     3,   445,     9,     7,   448,   449,     7,
      78,    79,     9,     9,    66,   443,   457,    85,    86,    87,
      82,   404,     3,   451,    92,    93,    94,     6,     8,    27,
      25,    25,    25,   461,    32,    33,    34,    35,    36,     9,
     468,    39,    40,    41,    42,    43,    44,    45,     9,    24,
     478,    16,     8,     3,    67,     9,     3,    26,    25,     5,
      78,    63,   445,     7,    62,   448,   449,    26,    25,   497,
       9,    69,     5,     3,   457,    26,     0,   505,     9,   271,
      78,    79,   210,   346,   223,   403,   232,   239,   401,   544,
     192,   574,    10,    91,    10,    10,   557,   538,   421,   423,
     541,   529,   422,   315,   576,   258,   440,   589,   175,   552,
     548,   539,   553,     0,    -1,   543,   544,     4,    -1,    -1,
      -1,    -1,    -1,    10,    11,    12,    13,    -1,    -1,    -1,
     558,    -1,    -1,   574,   558,    -1,    -1,   578,    -1,    -1,
     558,    -1,    29,    -1,    -1,   558,    -1,   558,   589,    -1,
      37,    -1,    -1,    -1,    -1,   538,    -1,    -1,   541,    46,
      47,    -1,    -1,   558,    -1,    -1,    -1,    -1,    -1,    -1,
     553,    -1,    59,     5,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    70,    71,    72,    -1,    74,    75,   558,
      -1,    -1,    -1,    -1,    -1,   558,    83,    29,    -1,    -1,
      32,    33,    34,    35,    36,    37,    -1,    39,    40,    41,
      42,    43,    44,    45,    -1,     4,    -1,    -1,     7,    -1,
      -1,    10,    11,    12,    13,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,     4,    68,    69,    -1,    -1,
      29,    10,    11,    12,    13,    77,    78,    79,    37,    -1,
      -1,    83,    84,    -1,    -1,    -1,    -1,    46,    47,    -1,
      29,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    -1,
      59,    -1,    -1,    -1,    -1,    -1,    -1,    46,    47,    -1,
      -1,    70,    71,    72,    -1,    74,    75,    -1,    -1,    -1,
      59,     7,    -1,    -1,    83,    -1,    -1,    -1,    -1,    -1,
      -1,    70,    71,    72,    -1,    74,    75,    -1,    -1,     7,
      -1,    -1,    -1,    29,    83,    -1,    32,    33,    34,    35,
      36,    37,    -1,    39,    40,    41,    42,    43,    44,    45,
      28,    29,    -1,    -1,    32,    33,    34,    35,    36,    37,
      -1,    39,    40,    41,    42,    43,    44,    45,    46,    47,
      -1,    -1,    68,    69,    -1,    -1,    -1,    -1,    -1,    -1,
      58,    59,    78,    79,    62,     7,    -1,    83,    84,    -1,
      -1,    69,    70,    -1,    -1,    -1,    18,    -1,    -1,    -1,
      78,    79,    80,    -1,    -1,    83,    28,    -1,    -1,    -1,
      32,    33,    34,    35,    36,    -1,    -1,    39,    40,    41,
      42,    43,    44,    45,    -1,    -1,     7,    -1,    -1,    -1,
      -1,    -1,    -1,    14,    -1,    -1,    -1,    -1,    -1,    -1,
      62,     7,    -1,    -1,    -1,    -1,    -1,    69,    14,    -1,
      -1,    32,    33,    34,    35,    36,    78,    79,    39,    40,
      41,    42,    43,    44,    45,    -1,    32,    33,    34,    35,
      36,    -1,    -1,    39,    40,    41,    42,    43,    44,    45,
      -1,    62,    -1,    -1,    -1,    -1,    -1,    -1,    69,    14,
      -1,    -1,    -1,    -1,    -1,    -1,    62,    78,    79,    -1,
      -1,    -1,    -1,    69,    -1,    -1,    -1,    32,    33,    34,
      35,    36,    78,    79,    39,    40,    41,    42,    43,    44,
      45,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    27,    -1,    -1,    -1,    62,    32,    33,
      34,    35,    36,    -1,    69,    39,    40,    41,    42,    43,
      44,    45,    -1,    78,    79,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    62,    -1,
      -1,    -1,    -1,    -1,    -1,    69,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    78,    79,    -1,    28,    29,    -1,
      -1,    32,    33,    34,    35,    36,    37,    91,    39,    40,
      41,    42,    43,    44,    45,    46,    47,    -1,    -1,    18,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,    28,
      -1,    62,    -1,    32,    33,    34,    35,    36,    69,    70,
      39,    40,    41,    42,    43,    44,    45,    78,    79,    80,
      -1,    -1,    83,    21,    22,    -1,    -1,    -1,    89,    90,
      91,    -1,    -1,    62,    32,    33,    34,    35,    36,    -1,
      69,    39,    40,    41,    42,    43,    44,    45,    -1,    78,
      79,    -1,    32,    33,    34,    -1,    -1,    -1,    -1,    39,
      40,    41,    42,    43,    44,    45,    -1,    -1,    -1,    -1,
      -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    28,    29,
      78,    79,    32,    33,    34,    35,    36,    37,    68,    39,
      40,    41,    42,    43,    44,    45,    46,    47,    78,    79,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    58,    59,
      -1,    -1,    62,    -1,    32,    33,    34,    35,    36,    69,
      70,    39,    40,    41,    42,    43,    44,    45,    78,    79,
      80,    29,    -1,    83,    32,    33,    34,    35,    36,    37,
      -1,    39,    40,    41,    42,    43,    44,    45,    -1,    -1,
      68,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      78,    79,    -1,    -1,    -1,    -1,    84,    -1,    -1,    -1,
      68,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      78,    79,    -1,    -1,    -1,    83,    84,    32,    33,    34,
      35,    36,    -1,    -1,    39,    40,    41,    42,    43,    44,
      45,    32,    33,    34,    35,    36,    -1,    -1,    39,    40,
      41,    42,    43,    44,    45,    -1,    -1,    62,    -1,    -1,
      -1,    -1,    -1,    -1,    69,    -1,    -1,    -1,    -1,    -1,
      -1,    -1,    -1,    78,    79,    -1,    -1,    -1,    69,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    78,    79
};
#define YYPURE 1

/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/usr/share/bison/bison.simple"

/* Skeleton output parser for bison,

   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
   Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* As a special exception, when this file is copied by Bison into a
   Bison output file, you may use that output file without restriction.
   This special exception was added by the Free Software Foundation
   in version 1.24 of Bison.  */

/* This is the parser code that is written into each bison parser when
   the %semantic_parser declaration is not specified in the grammar.
   It was written by Richard Stallman by simplifying the hairy parser
   used when %semantic_parser is specified.  */

/* All symbols defined below should begin with yy or YY, to avoid
   infringing on user name space.  This should be done even for local
   variables, as they might otherwise be expanded by user macros.
   There are some unavoidable exceptions within include files to
   define necessary library symbols; they are noted "INFRINGES ON
   USER NAME SPACE" below.  */

#if ! defined (yyoverflow) || defined (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) || defined (YYERROR_VERBOSE) */


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

/* A type that is properly aligned for any stack member.  */
union yyalloc
{
  short yyss;
  YYSTYPE yyvs;
# if YYLSP_NEEDED
  YYLTYPE yyls;
# endif
};

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

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */
# if YYLSP_NEEDED
#  define YYSTACK_BYTES(N) \
     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))  \
      + 2 * YYSTACK_GAP_MAX)
# else
#  define YYSTACK_BYTES(N) \
     ((N) * (sizeof (short) + sizeof (YYSTYPE))       \
      + YYSTACK_GAP_MAX)
# endif

/* 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_MAX; \
  yyptr += yynewbytes / sizeof (*yyptr);        \
      }                 \
    while (0)

#endif


#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
#  define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif

#define yyerrok   (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY   -2
#define YYEOF   0
#define YYACCEPT  goto yyacceptlab
#define YYABORT   goto yyabortlab
#define YYERROR   goto yyerrlab1
/* Like YYERROR except do call yyerror.  This remains here temporarily
   to ease the transition to the new meaning of YYERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define YYFAIL    goto yyerrlab
#define YYRECOVERING()  (!!yyerrstatus)
#define YYBACKUP(Token, Value)          \
do                \
  if (yychar == YYEMPTY && yylen == 1)        \
    {               \
      yychar = (Token);           \
      yylval = (Value);           \
      yychar1 = YYTRANSLATE (yychar);       \
      YYPOPSTACK;           \
      goto yybackup;            \
    }               \
  else                \
    {                 \
      yyerror ("syntax error: cannot back up");     \
      YYERROR;              \
    }               \
while (0)

#define YYTERROR  1
#define YYERRCODE 256


/* YYLLOC_DEFAULT -- Compute the default location (before the actions
   are run).

   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
   first token.  By default, to implement support for ranges, extend
   its range to the last symbol.  */

#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N)        \
   Current.last_line   = Rhs[N].last_line;  \
   Current.last_column = Rhs[N].last_column;
#endif


/* YYLEX -- calling `yylex' with the right arguments.  */

#if YYPURE
# if YYLSP_NEEDED
#  ifdef YYLEX_PARAM
#   define YYLEX    yylex (&yylval, &yylloc, YYLEX_PARAM)
#  else
#   define YYLEX    yylex (&yylval, &yylloc)
#  endif
# else /* !YYLSP_NEEDED */
#  ifdef YYLEX_PARAM
#   define YYLEX    yylex (&yylval, YYLEX_PARAM)
#  else
#   define YYLEX    yylex (&yylval)
#  endif
# endif /* !YYLSP_NEEDED */
#else /* !YYPURE */
# define YYLEX      yylex ()
#endif /* !YYPURE */


/* Enable debugging if requested.  */
#if YYDEBUG

# ifndef YYFPRINTF
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
#  define YYFPRINTF fprintf
# endif

# define YYDPRINTF(Args)      \
do {            \
  if (yydebug)          \
    YYFPRINTF Args;       \
} while (0)
/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
#endif /* !YYDEBUG */

/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#if YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif

#ifdef YYERROR_VERBOSE

# ifndef yystrlen
#  if defined (__GLIBC__) && defined (_STRING_H)
#   define yystrlen strlen
#  else
/* Return the length of YYSTR.  */
static YYSIZE_T
#   if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
#   else
yystrlen (yystr)
     const char *yystr;
#   endif
{
  register const char *yys = yystr;

  while (*yys++ != '\0')
    continue;

  return yys - yystr - 1;
}
#  endif
# endif

# ifndef yystpcpy
#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
#   define yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
static char *
#   if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
#   else
yystpcpy (yydest, yysrc)
     char *yydest;
     const char *yysrc;
#   endif
{
  register char *yyd = yydest;
  register const char *yys = yysrc;

  while ((*yyd++ = *yys++) != '\0')
    continue;

  return yyd - 1;
}
#  endif
# endif
#endif

#line 315 "/usr/share/bison/bison.simple"


/* The user can define YYPARSE_PARAM as the name of an argument to be passed
   into yyparse.  The argument should have type void *.
   It should actually point to an object.
   Grammar actions can access the variable by casting it
   to the proper pointer type.  */

#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL
# else
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
# endif
#else /* !YYPARSE_PARAM */
# define YYPARSE_PARAM_ARG
# define YYPARSE_PARAM_DECL
#endif /* !YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
# ifdef YYPARSE_PARAM
int yyparse (void *);
# else
int yyparse (void);
# endif
#endif

/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
   variables are global, or local to YYPARSE.  */

#define YY_DECL_NON_LSP_VARIABLES     \
/* The lookahead symbol.  */        \
int yychar;           \
              \
/* The semantic value of the lookahead symbol. */ \
YYSTYPE yylval;           \

/* The variables used to return semantic value and location from the
   action routines.  */
  YYSTYPE yyval;
#if YYLSP_NEEDED
  YYLTYPE yyloc;
#endif
            \
/* Number of parse errors so far.  */     \
int yynerrs;

#if YYLSP_NEEDED
# define YY_DECL_VARIABLES      \
YY_DECL_NON_LSP_VARIABLES     \
            \
/* Location data for the lookahead symbol.  */  \
YYLTYPE yylloc;
#else
# define YY_DECL_VARIABLES      \
YY_DECL_NON_LSP_VARIABLES
#endif


/* If nonreentrant, generate the variables here. */

#if !YYPURE
YY_DECL_VARIABLES
#endif  /* !YYPURE */

int
yyparse (YYPARSE_PARAM_ARG)
     YYPARSE_PARAM_DECL
{
  /* If reentrant, generate the variables here. */
#if YYPURE
  YY_DECL_VARIABLES
#endif  /* !YYPURE */

  register int yystate;
  register int yyn;
  int yyresult;
  /* Number of tokens to shift before error messages enabled.  */
  int yyerrstatus;
  /* Lookahead token as an internal (translated) token number.  */
  int yychar1 = 0;

  /* Three stacks and their tools:
     `yyss': related to states,
     `yyvs': related to semantic values,
     `yyls': related to locations.

     Refer to the stacks thru separate pointers, to allow yyoverflow
     to reallocate them elsewhere.  */

  /* The state stack. */
  short yyssa[YYINITDEPTH];
  short *yyss = yyssa;
  register short *yyssp;

  /* The semantic value stack.  */
  YYSTYPE yyvsa[YYINITDEPTH];
  YYSTYPE *yyvs = yyvsa;
  register YYSTYPE *yyvsp;

#if YYLSP_NEEDED
  /* The location stack.  */
  YYLTYPE yylsa[YYINITDEPTH];
  YYLTYPE *yyls = yylsa;
  YYLTYPE *yylsp;
#endif

#if YYLSP_NEEDED
# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
#else
# define YYPOPSTACK   (yyvsp--, yyssp--)
#endif

  YYSIZE_T yystacksize = YYINITDEPTH;


  /* When reducing, the number of symbols on the RHS of the reduced
     rule. */
  int yylen;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;   /* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss;
  yyvsp = yyvs;
#if YYLSP_NEEDED
  yylsp = yyls;
#endif
  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed. so pushing a state here evens the stacks.
     */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
  /* Give user a chance to reallocate the stack. Use copies of
     these so that the &'s don't force the real ones into
     memory.  */
  YYSTYPE *yyvs1 = yyvs;
  short *yyss1 = yyss;

  /* Each stack pointer address is followed by the size of the
     data in use in that stack, in bytes.  */
# if YYLSP_NEEDED
  YYLTYPE *yyls1 = yyls;
  /* This used to be a conditional around just the two extra args,
     but that might be undefined if yyoverflow is a macro.  */
  yyoverflow ("parser stack overflow",
        &yyss1, yysize * sizeof (*yyssp),
        &yyvs1, yysize * sizeof (*yyvsp),
        &yyls1, yysize * sizeof (*yylsp),
        &yystacksize);
  yyls = yyls1;
# else
  yyoverflow ("parser stack overflow",
        &yyss1, yysize * sizeof (*yyssp),
        &yyvs1, yysize * sizeof (*yyvsp),
        &yystacksize);
# endif
  yyss = yyss1;
  yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyoverflowlab;
# else
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
  goto yyoverflowlab;
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
  yystacksize = YYMAXDEPTH;

      {
  short *yyss1 = yyss;
  union yyalloc *yyptr =
    (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
  if (! yyptr)
    goto yyoverflowlab;
  YYSTACK_RELOCATE (yyss);
  YYSTACK_RELOCATE (yyvs);
# if YYLSP_NEEDED
  YYSTACK_RELOCATE (yyls);
# endif
# undef YYSTACK_RELOCATE
  if (yyss1 != yyssa)
    YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;
#if YYLSP_NEEDED
      yylsp = yyls + yysize - 1;
#endif

      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
      (unsigned long int) yystacksize));

      if (yyssp >= yyss + yystacksize - 1)
  YYABORT;
    }

  YYDPRINTF ((stderr, "Entering state %d\n", yystate));

  goto yybackup;


/*-----------.
| yybackup.  |
`-----------*/
yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* yychar is either YYEMPTY or YYEOF
     or a valid token in external form.  */

  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = YYLEX;
    }

  /* Convert token to internal form (in yychar1) for indexing tables with */

  if (yychar <= 0)    /* This means end of input. */
    {
      yychar1 = 0;
      yychar = YYEOF;   /* Don't call YYLEX any more */

      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yychar1 = YYTRANSLATE (yychar);

#if YYDEBUG
     /* We have to keep this `#if YYDEBUG', since we use variables
  which are defined only if `YYDEBUG' is set.  */
      if (yydebug)
  {
    YYFPRINTF (stderr, "Next token is %d (%s",
         yychar, yytname[yychar1]);
    /* Give the individual parser a way to print the precise
       meaning of a token, for further debugging info.  */
# ifdef YYPRINT
    YYPRINT (stderr, yychar, yylval);
# endif
    YYFPRINTF (stderr, ")\n");
  }
#endif
    }

  yyn += yychar1;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
    goto yydefault;

  yyn = yytable[yyn];

  /* yyn is what to do for this token type in this state.
     Negative => reduce, -yyn is rule number.
     Positive => shift, yyn is new state.
       New state is final state => don't bother to shift,
       just return success.
     0, or most negative number => error.  */

  if (yyn < 0)
    {
      if (yyn == YYFLAG)
  goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrlab;

  if (yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */
  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
        yychar, yytname[yychar1]));

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  *++yyvsp = yylval;
#if YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  yystate = yyn;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to the semantic value of
     the lookahead token.  This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

#if YYLSP_NEEDED
  /* Similarly for the default location.  Let the user run additional
     commands if for instance locations are ranges.  */
  yyloc = yylsp[1-yylen];
  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
#endif

#if YYDEBUG
  /* We have to keep this `#if YYDEBUG', since we use variables which
     are defined only if `YYDEBUG' is set.  */
  if (yydebug)
    {
      int yyi;

      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
     yyn, yyrline[yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
  YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    }
#endif

  switch (yyn) {

case 1:
#line 79 "PSDL.yy"
{ yyval = new TAO_PSDL_Specification (yyvsp[0]); ;
    break;}
case 2:
#line 82 "PSDL.yy"
{ yyval = new TAO_PSDL_Specification (yyvsp[-1], yyvsp[0]); ;
    break;}
case 3:
#line 86 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 4:
#line 89 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 5:
#line 92 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 6:
#line 95 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 7:
#line 98 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 8:
#line 101 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 9:
#line 104 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 10:
#line 107 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 11:
#line 110 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 12:
#line 113 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 13:
#line 116 "PSDL.yy"
{ yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
    break;}
case 14:
#line 120 "PSDL.yy"
{
  int good_module_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_module (TAO_PSDL_Scope::instance ()->get_identifier ());
  if (good_module_name == -1)
    YYABORT;
  ;
    break;}
case 15:
#line 126 "PSDL.yy"
{
      TAO_PSDL_Scope::instance ()->set_module_scope ();
      yyval = new TAO_PSDL_Module (TAO_PSDL_MODULE, yyvsp[-4], yyvsp[-1]); ;
    break;}
case 16:
#line 132 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Abstract_Storagetype (yyvsp[0]); ;
    break;}
case 17:
#line 136 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype (yyvsp[0]); ;
    break;}
case 18:
#line 140 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 19:
#line 143 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Dcl (yyvsp[-2]); ;
    break;}
case 20:
#line 147 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Fwd_Dcl (yyvsp[0]); ;
    break;}
case 21:
#line 151 "PSDL.yy"
{
      int good_storagetype_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_interface (TAO_PSDL_Scope::instance ()->get_identifier ());
      if (good_storagetype_name == -1)
          YYABORT;

      yyval = yyvsp[0];
    ;
    break;}
case 22:
#line 162 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 23:
#line 165 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Header (yyvsp[0]); ;
    break;}
case 24:
#line 170 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Body (yyvsp[0]); ;
    break;}
case 25:
#line 173 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 26:
#line 178 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Member (yyvsp[-1]); ;
    break;}
case 27:
#line 181 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Member (yyvsp[-1]); ;
    break;}
case 28:
#line 186 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Inh_Spec (yyvsp[0]); ;
    break;}
case 29:
#line 191 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Name (yyvsp[0]); ;
    break;}
case 30:
#line 194 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 31:
#line 198 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Dcl (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
    break;}
case 32:
#line 201 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 33:
#line 205 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
    break;}
case 34:
#line 208 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
    break;}
case 35:
#line 211 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
    break;}
case 36:
#line 214 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
    break;}
case 37:
#line 217 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
    break;}
case 38:
#line 222 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Ref_Type (yyvsp[-4], yyvsp[-1]); ;
    break;}
case 39:
#line 225 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagetype_Ref_Type (yyvsp[-1]); ;
    break;}
case 40:
#line 229 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome (yyvsp[0]); ;
    break;}
case 41:
#line 232 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome (yyvsp[0]); ;
    break;}
case 42:
#line 237 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Fwd_Dcl (yyvsp[0]); ;
    break;}
case 43:
#line 242 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 44:
#line 245 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Dcl (yyvsp[-2]); ;
    break;}
case 45:
#line 250 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
    break;}
case 46:
#line 253 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Header (yyvsp[-2], yyvsp[0]); ;
    break;}
case 47:
#line 258 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Body (yyvsp[0]); ;
    break;}
case 48:
#line 261 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 49:
#line 266 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
    break;}
case 50:
#line 269 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
    break;}
case 51:
#line 272 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
    break;}
case 52:
#line 277 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Inh_Spec (yyvsp[0]); ;
    break;}
case 53:
#line 282 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Name (yyvsp[0]); ;
    break;}
case 54:
#line 285 "PSDL.yy"
{ yyval = new TAO_PSDL_Abstract_Storagehome_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 55:
#line 289 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 56:
#line 293 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 57:
#line 298 "PSDL.yy"
{ yyval = new TAO_PSDL_Key_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 58:
#line 301 "PSDL.yy"
{ yyval = new TAO_PSDL_Key_Dcl (yyvsp[0]); ;
    break;}
case 59:
#line 305 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog (yyvsp[-4], yyvsp[-3], yyvsp[-1]); ;
    break;}
case 60:
#line 308 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 61:
#line 311 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog (yyvsp[-2]); ;
    break;}
case 62:
#line 314 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog (yyvsp[-3], yyvsp[-2]); ;
    break;}
case 63:
#line 318 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Inh_Spec (yyvsp[0]); ;
    break;}
case 64:
#line 322 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Name (yyvsp[0]); ;
    break;}
case 65:
#line 325 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 66:
#line 329 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Body (yyvsp[0]); ;
    break;}
case 67:
#line 332 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 68:
#line 336 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Member (yyvsp[-1]); ;
    break;}
case 69:
#line 339 "PSDL.yy"
{ yyval = new TAO_PSDL_Catalog_Member (yyvsp[-1]); ;
    break;}
case 70:
#line 343 "PSDL.yy"
{ yyval = new TAO_PSDL_Provides_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 71:
#line 347 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype (yyvsp[0]); ;
    break;}
case 72:
#line 350 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype (yyvsp[0]); ;
    break;}
case 73:
#line 354 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 74:
#line 357 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Dcl (yyvsp[-2]); ;
    break;}
case 75:
#line 361 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Fwd_Dcl (yyvsp[0]); ;
    break;}
case 76:
#line 365 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 77:
#line 368 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 78:
#line 371 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 79:
#line 375 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Body (yyvsp[0]); ;
    break;}
case 80:
#line 378 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 81:
#line 382 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
    break;}
case 82:
#line 385 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
    break;}
case 83:
#line 388 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
    break;}
case 84:
#line 392 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Inh_Spec (yyvsp[0]); ;
    break;}
case 85:
#line 396 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Name (yyvsp[0]); ;
    break;}
case 86:
#line 400 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Impl_Spec (yyvsp[0]); ;
    break;}
case 87:
#line 404 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagetype_Ref_Type (yyvsp[-1]); ;
    break;}
case 88:
#line 408 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Scope (yyvsp[0]); ;
    break;}
case 89:
#line 412 "PSDL.yy"
{ yyval = new TAO_PSDL_Store_Directive (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
    break;}
case 90:
#line 415 "PSDL.yy"
{ yyval = new TAO_PSDL_Store_Directive (yyvsp[-2], yyvsp[0]); ;
    break;}
case 91:
#line 420 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_Concrete_State_Type (yyvsp[0]); ;
    break;}
case 92:
#line 423 "PSDL.yy"
{ yyval = new TAO_PSDL_Psdl_Concrete_State_Type (yyvsp[0]); ;
    break;}
case 93:
#line 427 "PSDL.yy"
{ yyval = new TAO_PSDL_Ref_Rep_Directive (yyvsp[-1]); ;
    break;}
case 94:
#line 431 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 95:
#line 434 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome (yyvsp[-2]); ;
    break;}
case 96:
#line 438 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-4], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 97:
#line 441 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
    break;}
case 98:
#line 444 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
    break;}
case 99:
#line 447 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-2], yyvsp[0]); ;
    break;}
case 100:
#line 451 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Body (yyvsp[0]); ;
    break;}
case 101:
#line 454 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 102:
#line 458 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Member (yyvsp[-1]); ;
    break;}
case 103:
#line 461 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Member (yyvsp[-1]); ;
    break;}
case 104:
#line 465 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Inh_Spec (yyvsp[0]); ;
    break;}
case 105:
#line 469 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Name (yyvsp[0]); ;
    break;}
case 106:
#line 473 "PSDL.yy"
{ yyval = new TAO_PSDL_Storagehome_Impl_Spec (yyvsp[0]); ;
    break;}
case 107:
#line 477 "PSDL.yy"
{ yyval = new TAO_PSDL_Primary_Key_Dcl (yyvsp[0]); ;
    break;}
case 108:
#line 480 "PSDL.yy"
{ yyval = new TAO_PSDL_Primary_Key_Dcl (); ;
    break;}
case 109:
#line 484 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 110:
#line 488 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (TAO_PSDL_TYPEDEF, yyvsp[0]); ;
    break;}
case 111:
#line 491 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
    break;}
case 112:
#line 494 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
    break;}
case 113:
#line 497 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
    break;}
case 114:
#line 500 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (TAO_PSDL_NATIVE, yyvsp[0]); ;
    break;}
case 115:
#line 503 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
    break;}
case 116:
#line 507 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Declarator (yyvsp[-1], yyvsp[0]); ;
    break;}
case 117:
#line 511 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Spec (yyvsp[0]); ;
    break;}
case 118:
#line 514 "PSDL.yy"
{ yyval = new TAO_PSDL_Type_Spec (yyvsp[0]); ;
    break;}
case 119:
#line 518 "PSDL.yy"
{ yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
    break;}
case 120:
#line 521 "PSDL.yy"
{ yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
    break;}
case 121:
#line 524 "PSDL.yy"
{ yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
    break;}
case 122:
#line 528 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 123:
#line 531 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 124:
#line 534 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 125:
#line 537 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 126:
#line 540 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 127:
#line 543 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 128:
#line 546 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 129:
#line 549 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 130:
#line 552 "PSDL.yy"
{ yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
    break;}
case 131:
#line 556 "PSDL.yy"
{ yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
    break;}
case 132:
#line 559 "PSDL.yy"
{ yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
    break;}
case 133:
#line 562 "PSDL.yy"
{ yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
    break;}
case 134:
#line 565 "PSDL.yy"
{ yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
    break;}
case 135:
#line 569 "PSDL.yy"
{ yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
    break;}
case 136:
#line 572 "PSDL.yy"
{ yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
    break;}
case 137:
#line 575 "PSDL.yy"
{ yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
    break;}
case 138:
#line 579 "PSDL.yy"
{ yyval = new TAO_PSDL_Declarators (yyvsp[0]); ;
    break;}
case 139:
#line 582 "PSDL.yy"
{ yyval = new TAO_PSDL_Declarators (yyvsp[-2], yyvsp[0]); ;
    break;}
case 140:
#line 586 "PSDL.yy"
{ yyval = new TAO_PSDL_Declarator (yyvsp[0]); ;
    break;}
case 141:
#line 589 "PSDL.yy"
{ yyval = new TAO_PSDL_Declarator (yyvsp[0]); ;
    break;}
case 142:
#line 593 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 143:
#line 597 "PSDL.yy"
{ yyval = new TAO_PSDL_Simple_Declarator_List (yyvsp[0]); ;
    break;}
case 144:
#line 600 "PSDL.yy"
{ yyval = new TAO_PSDL_Simple_Declarator_List (yyvsp[-2], yyvsp[0]); ;
    break;}
case 145:
#line 604 "PSDL.yy"
{ yyval = new TAO_PSDL_Complex_Declarator (yyvsp[0]); ;
    break;}
case 146:
#line 608 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_FLOAT); ;
    break;}
case 147:
#line 611 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_DOUBLE); ;
    break;}
case 148:
#line 614 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG, TAO_PSDL_DOUBLE); ;
    break;}
case 149:
#line 618 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 150:
#line 621 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 151:
#line 625 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 152:
#line 628 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 153:
#line 631 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 154:
#line 635 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SHORT); ;
    break;}
case 155:
#line 639 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG); ;
    break;}
case 156:
#line 643 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG, TAO_PSDL_LONG); ;
    break;}
case 157:
#line 647 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
    break;}
case 158:
#line 650 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
    break;}
case 159:
#line 653 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
    break;}
case 160:
#line 657 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_SHORT); ;
    break;}
case 161:
#line 661 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_LONG); ;
    break;}
case 162:
#line 665 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_LONG, TAO_PSDL_LONG); ;
    break;}
case 163:
#line 669 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_CHAR); ;
    break;}
case 164:
#line 673 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_WCHAR); ;
    break;}
case 165:
#line 677 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_BOOLEAN); ;
    break;}
case 166:
#line 681 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OCTET); ;
    break;}
case 167:
#line 685 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ANY); ;
    break;}
case 168:
#line 689 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OBJECT); ;
    break;}
case 169:
#line 693 "PSDL.yy"
{
      int good_struct_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_struct (TAO_PSDL_Scope::instance ()->get_identifier ());

      if (good_struct_name == -1)
      YYABORT;
    ;
    break;}
case 170:
#line 700 "PSDL.yy"
{
        TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRUCT, yyvsp[-4], yyvsp[-1]); ;
    break;}
case 171:
#line 706 "PSDL.yy"
{ yyval = new TAO_PSDL_Member_List (yyvsp[0]); ;
    break;}
case 172:
#line 709 "PSDL.yy"
{ yyval = new TAO_PSDL_Member_List (yyvsp[-1], yyvsp[0]); ;
    break;}
case 173:
#line 713 "PSDL.yy"
{ yyval = new TAO_PSDL_Member (yyvsp[-2], yyvsp[-1]); ;
    break;}
case 174:
#line 717 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[-7], yyvsp[-4], yyvsp[-1]); ;
    break;}
case 175:
#line 721 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
    break;}
case 176:
#line 724 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
    break;}
case 177:
#line 727 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
    break;}
case 178:
#line 730 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
    break;}
case 179:
#line 733 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
    break;}
case 180:
#line 737 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Body (yyvsp[0]); ;
    break;}
case 181:
#line 740 "PSDL.yy"
{ yyval = new TAO_PSDL_Switch_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 182:
#line 744 "PSDL.yy"
{ yyval = new TAO_PSDL_Case (yyvsp[-2], yyvsp[-1]); ;
    break;}
case 183:
#line 748 "PSDL.yy"
{ yyval = new TAO_PSDL_Case_Label (yyvsp[-2], yyvsp[-1]); ;
    break;}
case 184:
#line 751 "PSDL.yy"
{ yyval = new TAO_PSDL_Case_Label (yyvsp[-1]); ;
    break;}
case 185:
#line 754 "PSDL.yy"
{ yyval = new TAO_PSDL_Case_Label (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
    break;}
case 186:
#line 757 "PSDL.yy"
{ yyval = new TAO_PSDL_Case_Label (yyvsp[-2], yyvsp[0]); ;
    break;}
case 187:
#line 761 "PSDL.yy"
{ yyval = new TAO_PSDL_Element_Spec (yyvsp[-1], yyvsp[0]); ;
    break;}
case 188:
#line 765 "PSDL.yy"
{ yyval = new TAO_PSDL_Const_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
    break;}
case 189:
#line 769 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 190:
#line 772 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 191:
#line 775 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 192:
#line 778 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 193:
#line 781 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 194:
#line 784 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 195:
#line 787 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 196:
#line 790 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 197:
#line 793 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 198:
#line 796 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
    break;}
case 199:
#line 800 "PSDL.yy"
{ yyval = new TAO_PSDL_Const_Exp (yyvsp[0]); ;
    break;}
case 200:
#line 804 "PSDL.yy"
{ yyval = new TAO_PSDL_Or_Expr (yyvsp[0]); ;
    break;}
case 201:
#line 807 "PSDL.yy"
{ yyval = new TAO_PSDL_Or_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 202:
#line 811 "PSDL.yy"
{ yyval = new TAO_PSDL_Xor_Expr (yyvsp[0]); ;
    break;}
case 203:
#line 814 "PSDL.yy"
{ yyval = new TAO_PSDL_Xor_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 204:
#line 818 "PSDL.yy"
{ yyval = new TAO_PSDL_And_Expr (yyvsp[0]); ;
    break;}
case 205:
#line 821 "PSDL.yy"
{ yyval = new TAO_PSDL_And_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 206:
#line 825 "PSDL.yy"
{ yyval = new TAO_PSDL_Shift_Expr (yyvsp[0]); ;
    break;}
case 207:
#line 828 "PSDL.yy"
{ yyval = new TAO_PSDL_Shift_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 208:
#line 831 "PSDL.yy"
{ yyval = new TAO_PSDL_Shift_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 209:
#line 835 "PSDL.yy"
{ yyval = new TAO_PSDL_Add_Expr (yyvsp[0]); ;
    break;}
case 210:
#line 838 "PSDL.yy"
{ yyval = new TAO_PSDL_Add_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 211:
#line 841 "PSDL.yy"
{ yyval = new TAO_PSDL_Add_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 212:
#line 845 "PSDL.yy"
{ yyval = new TAO_PSDL_Mult_Expr (yyvsp[0]); ;
    break;}
case 213:
#line 848 "PSDL.yy"
{ yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 214:
#line 851 "PSDL.yy"
{ yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 215:
#line 854 "PSDL.yy"
{ yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
    break;}
case 216:
#line 858 "PSDL.yy"
{ yyval = new TAO_PSDL_Unary_Expr (yyvsp[-1], yyvsp[0]); ;
    break;}
case 217:
#line 861 "PSDL.yy"
{ yyval = new TAO_PSDL_Unary_Expr (yyvsp[0]); ;
    break;}
case 218:
#line 865 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 219:
#line 868 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 220:
#line 871 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 221:
#line 875 "PSDL.yy"
{ yyval = new TAO_PSDL_Primary_Expr (yyvsp[0]); ;
    break;}
case 222:
#line 878 "PSDL.yy"
{ yyval = new TAO_PSDL_Primary_Expr (yyvsp[0]); ;
    break;}
case 223:
#line 881 "PSDL.yy"
{ yyval = new TAO_PSDL_Primary_Expr (yyvsp[-1]); ;
    break;}
case 224:
#line 885 "PSDL.yy"
{
      int good_except_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_exception (TAO_PSDL_Scope::instance ()->get_identifier ());
            if (good_except_name == -1)
        YYABORT;
          yyval = yyvsp[0];
    ;
    break;}
case 225:
#line 894 "PSDL.yy"
{
      TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Except_Dcl (yyvsp[-3], yyvsp[-1]);
    ;
    break;}
case 226:
#line 900 "PSDL.yy"
{
      TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Except_Dcl (yyvsp[-2]);
    ;
    break;}
case 227:
#line 907 "PSDL.yy"
{
      int good_op_dcl_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_op_dcl (TAO_PSDL_Scope::instance ()->get_identifier ());

            if (good_op_dcl_name == -1)
        YYABORT;

      yyval = yyvsp[0];
    ;
    break;}
case 228:
#line 918 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-5], yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 229:
#line 922 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 230:
#line 926 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 231:
#line 930 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 232:
#line 934 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
                  yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 233:
#line 938 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
      yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 234:
#line 942 "PSDL.yy"
{ TAO_PSDL_Scope::instance ()->set_scope ();
                  yyval = new TAO_PSDL_Op_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 235:
#line 947 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ONEWAY); ;
    break;}
case 236:
#line 951 "PSDL.yy"
{ yyval = new TAO_PSDL_Op_Type_Spec (yyvsp[0]); ;
    break;}
case 237:
#line 954 "PSDL.yy"
{ yyval = new TAO_PSDL_Op_Type_Spec (TAO_PSDL_VOID); ;
    break;}
case 238:
#line 958 "PSDL.yy"
{ yyval = new TAO_PSDL_Parameter_Dcls (yyvsp[-1]); ;
    break;}
case 239:
#line 961 "PSDL.yy"
{ yyval = new TAO_PSDL_Parameter_Dcls (); ;
    break;}
case 240:
#line 965 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 241:
#line 968 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
    break;}
case 242:
#line 972 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_IN); ;
    break;}
case 243:
#line 975 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OUT); ;
    break;}
case 244:
#line 978 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_INOUT); ;
    break;}
case 245:
#line 982 "PSDL.yy"
{ yyval = new TAO_PSDL_Raises_Expr (yyvsp[-1]); ;
    break;}
case 246:
#line 985 "PSDL.yy"
{ yyval = new TAO_PSDL_Raises_Expr (yyvsp[-3], yyvsp[-2]); ;
    break;}
case 247:
#line 989 "PSDL.yy"
{ yyval = new TAO_PSDL_Context_Expr (yyvsp[-1]); ;
    break;}
case 248:
#line 993 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
    break;}
case 249:
#line 996 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
    break;}
case 250:
#line 999 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
    break;}
case 251:
#line 1002 "PSDL.yy"
{ yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
    break;}
case 252:
#line 1006 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 253:
#line 1010 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 254:
#line 1014 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 255:
#line 1018 "PSDL.yy"
{ yyval = new TAO_PSDL_Constr_Forward_Decl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 256:
#line 1021 "PSDL.yy"
{ yyval = new TAO_PSDL_Constr_Forward_Decl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 257:
#line 1025 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface (yyvsp[0]); ;
    break;}
case 258:
#line 1028 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface (yyvsp[0]); ;
    break;}
case 259:
#line 1032 "PSDL.yy"
{
      TAO_PSDL_Scope::instance ()->set_interface_scope ();
      yyval = new TAO_PSDL_Interface_Dcl (yyvsp[-3], yyvsp[-1]);
    ;
    break;}
case 260:
#line 1038 "PSDL.yy"
{
      TAO_PSDL_Scope::instance ()->set_interface_scope ();
      yyval = new TAO_PSDL_Interface_Dcl (yyvsp[-2]);
    ;
    break;}
case 261:
#line 1045 "PSDL.yy"
{ yyval = new TAO_PSDL_Forward_Dcl (TAO_PSDL_ABSTRACT, yyvsp[0]); ;
    break;}
case 262:
#line 1048 "PSDL.yy"
{ yyval = new TAO_PSDL_Forward_Dcl (TAO_PSDL_LOCAL, yyvsp[0]); ;
    break;}
case 263:
#line 1051 "PSDL.yy"
{ yyval = new TAO_PSDL_Forward_Dcl (yyvsp[0]); ;
    break;}
case 264:
#line 1055 "PSDL.yy"
{
      int good_interface_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_interface (TAO_PSDL_Scope::instance ()->get_identifier ());
      if (good_interface_name == -1)
          YYABORT;

      yyval = yyvsp[0];
    ;
    break;}
case 265:
#line 1065 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 266:
#line 1068 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 267:
#line 1071 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[0]); ;
    break;}
case 268:
#line 1074 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 269:
#line 1077 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 270:
#line 1080 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Header (yyvsp[0], yyvsp[-1]); ;
    break;}
case 271:
#line 1084 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Body (yyvsp[0]); ;
    break;}
case 272:
#line 1087 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Body (yyvsp[-1], yyvsp[0]); ;
    break;}
case 273:
#line 1091 "PSDL.yy"
{ yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
    break;}
case 274:
#line 1094 "PSDL.yy"
{ yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
    break;}
case 275:
#line 1097 "PSDL.yy"
{ yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
    break;}
case 276:
#line 1100 "PSDL.yy"
{ yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
    break;}
case 277:
#line 1103 "PSDL.yy"
{ yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
    break;}
case 278:
#line 1108 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Inheritance_Spec (yyvsp[0]); ;
    break;}
case 279:
#line 1112 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Name (yyvsp[0]); ;
    break;}
case 280:
#line 1115 "PSDL.yy"
{ yyval = new TAO_PSDL_Interface_Name (yyvsp[-2], yyvsp[-1]); ;
    break;}
case 281:
#line 1119 "PSDL.yy"
{ yyval = new TAO_PSDL_Scoped_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 282:
#line 1122 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 283:
#line 1126 "PSDL.yy"
{ yyval = new TAO_PSDL_Scoped_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 284:
#line 1129 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 285:
#line 1133 "PSDL.yy"
{ yyval = new TAO_PSDL_Value (yyvsp[0]); ;
    break;}
case 286:
#line 1136 "PSDL.yy"
{ yyval = new TAO_PSDL_Value (yyvsp[0]); ;
    break;}
case 287:
#line 1139 "PSDL.yy"
{ yyval = new TAO_PSDL_Value (yyvsp[0]); ;
    break;}
case 288:
#line 1142 "PSDL.yy"
{ yyval = new TAO_PSDL_Value (yyvsp[0]); ;
    break;}
case 289:
#line 1146 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Common_Base (yyvsp[0]); ;
    break;}
case 290:
#line 1150 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Forward_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 291:
#line 1153 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Forward_Dcl (yyvsp[0]); ;
    break;}
case 292:
#line 1157 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Box_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 293:
#line 1161 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Abs_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-1]); ;
    break;}
case 294:
#line 1164 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Abs_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 295:
#line 1168 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Dcl (yyvsp[-3], yyvsp[-1]); ;
    break;}
case 296:
#line 1172 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 297:
#line 1175 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 298:
#line 1178 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Header (yyvsp[-1], yyvsp[0]); ;
    break;}
case 299:
#line 1182 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
    break;}
case 300:
#line 1185 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-2], yyvsp[0]); ;
    break;}
case 301:
#line 1188 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[0]); ;
    break;}
case 302:
#line 1191 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-1], yyvsp[0]); ;
    break;}
case 303:
#line 1194 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[0]); ;
    break;}
case 304:
#line 1199 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRING, yyvsp[-1]); ;
    break;}
case 305:
#line 1202 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRING); ;
    break;}
case 306:
#line 1206 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (yyvsp[-1]); ;
    break;}
case 307:
#line 1209 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 308:
#line 1213 "PSDL.yy"
{ yyval = new TAO_PSDL_Array_Declarator (yyvsp[-1], yyvsp[0]); ;
    break;}
case 309:
#line 1217 "PSDL.yy"
{ yyval = new TAO_PSDL_Fixed_Array_Size (yyvsp[-1]); ;
    break;}
case 310:
#line 1221 "PSDL.yy"
{ yyval = new TAO_PSDL_Attr_Dcl (TAO_PSDL_READONLY, yyvsp[-1], yyvsp[0]); ;
    break;}
case 311:
#line 1224 "PSDL.yy"
{ yyval = new TAO_PSDL_Attr_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 312:
#line 1228 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ENUM, yyvsp[-3], yyvsp[-1]); ;
    break;}
case 313:
#line 1232 "PSDL.yy"
{ yyval = new TAO_PSDL_Enumerator (yyvsp[0]); ;
    break;}
case 314:
#line 1235 "PSDL.yy"
{ yyval = new TAO_PSDL_Enumerator (yyvsp[-2], yyvsp[0]); ;
    break;}
case 315:
#line 1239 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SEQUENCE, yyvsp[-3], yyvsp[-1]); ;
    break;}
case 316:
#line 1242 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SEQUENCE, yyvsp[-1]); ;
    break;}
case 317:
#line 1246 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 318:
#line 1249 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 319:
#line 1252 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 320:
#line 1255 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 321:
#line 1258 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 322:
#line 1261 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 323:
#line 1264 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 324:
#line 1267 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 325:
#line 1271 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 326:
#line 1274 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 327:
#line 1278 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 328:
#line 1282 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 329:
#line 1286 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 330:
#line 1290 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 331:
#line 1294 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 332:
#line 1298 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 333:
#line 1302 "PSDL.yy"
{ yyval = yyvsp[0]; ;
    break;}
case 334:
#line 1306 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Name (yyvsp[0]); ;
    break;}
case 335:
#line 1309 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Name (yyvsp[-2], yyvsp[0]); ;
    break;}
case 336:
#line 1313 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
    break;}
case 337:
#line 1316 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
    break;}
case 338:
#line 1319 "PSDL.yy"
{ yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
    break;}
case 339:
#line 1323 "PSDL.yy"
{ yyval = new TAO_PSDL_State_Member (yyvsp[-3], yyvsp[-2], yyvsp[-1]); ;
    break;}
case 340:
#line 1326 "PSDL.yy"
{ yyval = new TAO_PSDL_State_Member (yyvsp[-3], yyvsp[-2], yyvsp[-1]); ;
    break;}
case 341:
#line 1330 "PSDL.yy"
{ yyval = new TAO_PSDL_Init_Dcl (yyvsp[-4], yyvsp[-2]); ;
    break;}
case 342:
#line 1333 "PSDL.yy"
{ yyval = new TAO_PSDL_Init_Dcl (yyvsp[-3]); ;
    break;}
case 343:
#line 1337 "PSDL.yy"
{ yyval = new TAO_PSDL_Init_Param_Decls (yyvsp[0]); ;
    break;}
case 344:
#line 1340 "PSDL.yy"
{ yyval = new TAO_PSDL_Init_Param_Decls (yyvsp[-2], yyvsp[-1]); ;
    break;}
case 345:
#line 1344 "PSDL.yy"
{ yyval = new TAO_PSDL_Init_Param_Decl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
    break;}
case 346:
#line 1348 "PSDL.yy"
{ yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_IN); ;
    break;}
case 347:
#line 1352 "PSDL.yy"
{ yyval = new TAO_PSDL_Positive_Int_Const (yyvsp[0]); ;
    break;}
case 348:
#line 1356 "PSDL.yy"
{ yyval = new TAO_PSDL_Factory_Dcl (yyvsp[-1], yyvsp[0]); ;
    break;}
case 349:
#line 1360 "PSDL.yy"
{ yyval = new TAO_PSDL_Factory_Parameters (yyvsp[-1]); ;
    break;}
case 350:
#line 1363 "PSDL.yy"
{ yyval = new TAO_PSDL_Factory_Parameters (); ;
    break;}
}

#line 705 "/usr/share/bison/bison.simple"


  yyvsp -= yylen;
  yyssp -= yylen;
#if YYLSP_NEEDED
  yylsp -= yylen;
#endif

#if YYDEBUG
  if (yydebug)
    {
      short *yyssp1 = yyss - 1;
      YYFPRINTF (stderr, "state stack now");
      while (yyssp1 != yyssp)
  YYFPRINTF (stderr, " %d", *++yyssp1);
      YYFPRINTF (stderr, "\n");
    }
#endif

  *++yyvsp = yyval;
#if YYLSP_NEEDED
  *++yylsp = yyloc;
#endif

  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTBASE];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
  {
    YYSIZE_T yysize = 0;
    char *yymsg;
    int yyx, yycount;

    yycount = 0;
    /* Start YYX at -YYN if negative to avoid negative indexes in
       YYCHECK.  */
    for (yyx = yyn < 0 ? -yyn : 0;
         yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
      if (yycheck[yyx + yyn] == yyx)
        yysize += yystrlen (yytname[yyx]) + 15, yycount++;
    yysize += yystrlen ("parse error, unexpected ") + 1;
    yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
    yymsg = (char *) YYSTACK_ALLOC (yysize);
    if (yymsg != 0)
      {
        char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
        yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);

        if (yycount < 5)
    {
      yycount = 0;
      for (yyx = yyn < 0 ? -yyn : 0;
           yyx < (int) (sizeof (yytname) / sizeof (char *));
           yyx++)
        if (yycheck[yyx + yyn] == yyx)
          {
      const char *yyq = ! yycount ? ", expecting " : " or ";
      yyp = yystpcpy (yyp, yyq);
      yyp = yystpcpy (yyp, yytname[yyx]);
      yycount++;
          }
    }
        yyerror (yymsg);
        YYSTACK_FREE (yymsg);
      }
    else
      yyerror ("parse error; also virtual memory exhausted");
  }
      else
#endif /* defined (YYERROR_VERBOSE) */
  yyerror ("parse error");
    }
  goto yyerrlab1;


/*--------------------------------------------------.
| yyerrlab1 -- error raised explicitly by an action |
`--------------------------------------------------*/
yyerrlab1:
  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
   error, discard it.  */

      /* return failure if at end of input */
      if (yychar == YYEOF)
  YYABORT;
      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
      yychar, yytname[yychar1]));
      yychar = YYEMPTY;
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */

  yyerrstatus = 3;    /* Each real token shifted decrements this */

  goto yyerrhandle;


/*-------------------------------------------------------------------.
| yyerrdefault -- current state does not do anything special for the |
| error token.                                                       |
`-------------------------------------------------------------------*/
yyerrdefault:
#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */

  /* If its default is to accept any token, ok.  Otherwise pop it.  */
  yyn = yydefact[yystate];
  if (yyn)
    goto yydefault;
#endif


/*---------------------------------------------------------------.
| yyerrpop -- pop the current state because it cannot handle the |
| error token                                                    |
`---------------------------------------------------------------*/
yyerrpop:
  if (yyssp == yyss)
    YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#if YYLSP_NEEDED
  yylsp--;
#endif

#if YYDEBUG
  if (yydebug)
    {
      short *yyssp1 = yyss - 1;
      YYFPRINTF (stderr, "Error: state stack now");
      while (yyssp1 != yyssp)
  YYFPRINTF (stderr, " %d", *++yyssp1);
      YYFPRINTF (stderr, "\n");
    }
#endif

/*--------------.
| yyerrhandle.  |
`--------------*/
yyerrhandle:
  yyn = yypact[yystate];
  if (yyn == YYFLAG)
    goto yyerrdefault;

  yyn += YYTERROR;
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    goto yyerrdefault;

  yyn = yytable[yyn];
  if (yyn < 0)
    {
      if (yyn == YYFLAG)
  goto yyerrpop;
      yyn = -yyn;
      goto yyreduce;
    }
  else if (yyn == 0)
    goto yyerrpop;

  if (yyn == YYFINAL)
    YYACCEPT;

  YYDPRINTF ((stderr, "Shifting error token, "));

  *++yyvsp = yylval;
#if YYLSP_NEEDED
  *++yylsp = yylloc;
#endif

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

/*---------------------------------------------.
| yyoverflowab -- parser overflow comes here.  |
`---------------------------------------------*/
yyoverflowlab:
  yyerror ("parser stack overflow");
  yyresult = 2;
  /* Fall through.  */

yyreturn:
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
  return yyresult;
}
#line 1365 "PSDL.yy"