Logo Search packages:      
Sourcecode: opencascade version File versions  Download package

CDL.tab.c

/*  A Bison parser, made from /adv_20/KAS/C40/ros/src/CDLFront/CDL.yacc
 by  GNU Bison version 1.25
  */

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

#define yyparse CDLparse
#define yylex CDLlex
#define yyerror CDLerror
#define yylval CDLlval
#define yychar CDLchar
#define yydebug CDLdebug
#define yynerrs CDLnerrs
#define     krc   258
#define     cpp   259
#define     fortran     260
#define     object      261
#define     library     262
#define     external    263
#define     alias 264
#define     any   265
#define     asynchronous      266
#define     as    267
#define     class 268
#define     client      269
#define     component   270
#define     deferred    271
#define     schema      272
#define     end   273
#define     engine      274
#define     enumeration 275
#define     exception   276
#define     executable  277
#define     execfile    278
#define     extends     279
#define     fields      280
#define     friends     281
#define     CDL_from    282
#define     generic     283
#define     immutable   284
#define     imported    285
#define     in    286
#define     inherits    287
#define     instantiates      288
#define     interface   289
#define     is    290
#define     like  291
#define     me    292
#define     mutable     293
#define     myclass     294
#define     out   295
#define     package     296
#define     pointer     297
#define     private     298
#define     primitive   299
#define     protected   300
#define     raises      301
#define     redefined   302
#define     returns     303
#define     statiC      304
#define     CDL_to      305
#define     uses  306
#define     virtual     307
#define     IDENTIFIER  308
#define     JAVAIDENTIFIER    309
#define     INTEGER     310
#define     LITERAL     311
#define     REAL  312
#define     STRING      313
#define     INVALID     314


/* all parser must define this variable */

#define yyv CDLv

#define MAX_CHAR     256              /* The limit of a identifier.  */
#define MAX_STRING   (MAX_CHAR * 10)  /* The limit of a string.      */
#define MAX_COMMENT  (MAX_CHAR * 300) /* The limit of comment line   */
#define ENDOFCOMMENT "\n%\n"          /* The marque of end of coment */

#define CDL_CPP      1
#define CDL_FOR      2
#define CDL_C        3
#define CDL_OBJ      4
#define CDL_LIBRARY  5
#define CDL_EXTERNAL 6

#include <stdlib.h>
#include <cdl_rules.h>

extern void CDLerror ( char* );
extern int  CDLlex   ( void  );


typedef union {
 char str[MAX_STRING];
} YYSTYPE;
#include <stdio.h>

#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif



#define     YYFINAL           714
#define     YYFLAG            -32768
#define     YYNTBASE    68

#define YYTRANSLATE(x) ((unsigned)(x) <= 314 ? yytranslate[x] : 320)

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,    54,
    53,     2,     2,    59,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,    57,    58,     2,
    60,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    56,     2,    55,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
    36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
    46,    47,    48,    49,    50,    51,    52,    61,    62,    63,
    64,    65,    66,    67
};

#if YYDEBUG != 0
static const short yyprhs[] = {     0,
     0,     2,     4,     6,     9,    11,    13,    15,    17,    19,
    21,    23,    25,    27,    28,    38,    40,    42,    44,    46,
    49,    51,    55,    58,    59,    70,    72,    74,    76,    78,
    81,    83,    87,    89,    91,    93,    96,   100,   105,   108,
   111,   112,   118,   124,   127,   130,   133,   135,   138,   139,
   148,   150,   152,   154,   156,   158,   160,   163,   167,   171,
   172,   183,   185,   187,   189,   191,   195,   197,   199,   201,
   203,   205,   208,   212,   213,   222,   224,   226,   228,   230,
   232,   234,   237,   243,   244,   254,   256,   258,   260,   263,
   265,   269,   271,   273,   275,   277,   279,   281,   284,   288,
   292,   293,   299,   305,   313,   316,   321,   324,   329,   332,
   337,   339,   342,   343,   352,   354,   356,   358,   360,   362,
   365,   366,   377,   379,   381,   383,   385,   389,   391,   394,
   396,   400,   404,   406,   408,   410,   412,   414,   417,   421,
   423,   425,   427,   429,   431,   433,   435,   437,   439,   442,
   444,   448,   450,   452,   454,   456,   458,   460,   462,   464,
   468,   470,   474,   476,   478,   480,   482,   486,   488,   490,
   492,   499,   507,   508,   509,   529,   544,   545,   546,   563,
   565,   569,   573,   575,   577,   579,   583,   585,   589,   590,
   595,   599,   602,   610,   612,   615,   617,   620,   622,   626,
   628,   630,   633,   637,   639,   641,   643,   647,   649,   650,
   655,   665,   676,   687,   695,   704,   715,   717,   719,   721,
   724,   726,   730,   732,   734,   736,   739,   742,   744,   746,
   748,   750,   752,   754,   756,   759,   762,   764,   771,   778,
   785,   792,   795,   800,   804,   809,   817,   823,   826,   831,
   835,   840,   848,   854,   856,   859,   861,   865,   871,   873,
   876,   880,   882,   885,   887,   891,   893,   895,   898,   901,
   904,   907,   911,   915,   919,   923,   927,   929,   932,   934,
   936,   938,   940,   942,   944,   947,   949,   952,   954,   958,
   961,   964,   966,   969,   971,   975,   978,   980,   983,   987,
   990,   992,   995,   997,  1000,  1008,  1010,  1014,  1016,  1020,
  1022,  1023,  1027,  1029,  1033,  1035,  1039,  1042,  1043,  1049,
  1054,  1057,  1060,  1063,  1065,  1067,  1069,  1072,  1074,  1078,
  1080,  1082,  1085,  1088,  1090,  1094,  1095,  1096,  1097,  1098,
  1099,  1100,  1101,  1102,  1103,  1104,  1105,  1106,  1107,  1108,
  1109,  1110,  1111,  1112,  1113,  1114,  1115,  1116,  1117,  1118,
  1119,  1120,  1121,  1122,  1123,  1124,  1125,  1126,  1127,  1128,
  1129,  1130,  1131,  1132,  1133,  1134,  1135,  1136,  1137,  1138,
  1139,  1140,  1141,  1142,  1143,  1144,  1145,  1146,  1147,  1148,
  1149,  1150,  1151,  1152,  1153,  1154,  1155,  1156,  1157,  1158,
  1159,  1160,  1161
};

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

#endif

#if YYDEBUG != 0
static const short yyrline[] = { 0,
   112,   113,   115,   116,   118,   119,   120,   121,   122,   123,
   124,   125,   128,   133,   135,   139,   140,   142,   144,   145,
   147,   148,   150,   156,   158,   163,   164,   166,   168,   169,
   171,   172,   174,   175,   177,   178,   180,   181,   182,   185,
   187,   188,   188,   191,   192,   193,   196,   197,   201,   203,
   206,   207,   209,   211,   212,   214,   215,   217,   218,   223,
   224,   230,   231,   234,   237,   238,   240,   241,   243,   244,
   246,   247,   249,   254,   256,   261,   262,   265,   268,   269,
   271,   272,   274,   280,   282,   287,   288,   291,   292,   295,
   296,   299,   300,   301,   304,   305,   308,   309,   311,   312,
   315,   316,   316,   317,   320,   321,   322,   323,   324,   325,
   328,   329,   333,   335,   337,   338,   341,   342,   345,   346,
   349,   350,   356,   357,   360,   363,   364,   367,   368,   371,
   372,   375,   378,   379,   382,   383,   386,   387,   390,   392,
   393,   396,   397,   398,   399,   405,   406,   408,   409,   411,
   412,   414,   415,   416,   417,   418,   419,   420,   422,   423,
   428,   429,   431,   432,   433,   435,   436,   438,   439,   440,
   443,   446,   449,   452,   454,   461,   468,   470,   472,   478,
   479,   480,   482,   483,   484,   487,   492,   493,   496,   496,
   499,   500,   501,   504,   505,   507,   508,   510,   511,   513,
   514,   516,   517,   519,   520,   522,   523,   525,   526,   526,
   532,   542,   552,   562,   568,   577,   584,   585,   587,   588,
   590,   591,   596,   597,   599,   600,   602,   604,   606,   607,
   608,   610,   611,   613,   614,   616,   618,   621,   628,   635,
   642,   650,   651,   653,   654,   656,   659,   662,   663,   665,
   666,   668,   671,   678,   679,   681,   682,   684,   688,   689,
   690,   692,   693,   695,   696,   698,   699,   701,   702,   703,
   712,   713,   715,   717,   718,   720,   722,   723,   725,   726,
   727,   728,   729,   732,   733,   735,   736,   738,   739,   741,
   742,   744,   745,   747,   748,   750,   751,   753,   754,   755,
   761,   762,   765,   766,   768,   773,   774,   777,   778,   783,
   784,   784,   786,   787,   789,   790,   792,   794,   795,   795,
   799,   800,   801,   803,   804,   810,   811,   813,   814,   816,
   817,   819,   820,   825,   826,   828,   830,   837,   838,   840,
   841,   843,   845,   846,   847,   849,   850,   851,   853,   854,
   856,   857,   859,   860,   862,   863,   865,   866,   868,   869,
   870,   871,   872,   874,   875,   876,   877,   878,   880,   881,
   883,   884,   885,   886,   888,   889,   890,   891,   892,   893,
   894,   895,   896,   897,   898,   899,   900,   902,   904,   905,
   906,   907,   908,   909,   910,   911,   912,   913,   914,   915,
   916,   917,   918
};
#endif


#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

static const char * const yytname[] = {   "$","error","$undefined.","krc","cpp",
"fortran","object","library","external","alias","any","asynchronous","as","class",
"client","component","deferred","schema","end","engine","enumeration","exception",
"executable","execfile","extends","fields","friends","CDL_from","generic","immutable",
"imported","in","inherits","instantiates","interface","is","like","me","mutable",
"myclass","out","package","pointer","private","primitive","protected","raises",
"redefined","returns","statiC","CDL_to","uses","virtual","')'","'('","']'","'['",
"':'","';'","','","'='","IDENTIFIER","JAVAIDENTIFIER","INTEGER","LITERAL","REAL",
"STRING","INVALID","__Cdl_Declaration_List","Cdl_Declaration_List","Cdl_Declaration",
"Package_Declaration","@1","__Package_Name","Package_Name","__Packages_Uses",
"Package_List","Package_Definition","Interface_Declaration","@2","__Interface_Name",
"Interface_Name","__Interfaces_Uses","InterfaceUse_List","__Interface_Definitions",
"Interface_Definitions","Interface_Definition","Interface_Method_Dec","Interface_Method",
"@3","Interface_Method_Class_Dec","Interface_returns_error","Schema_Declaration",
"@4","__Schema_Name","Schema_Name","__Schema_Packages","Schema_Packages","Schema_Package",
"Engine_Declaration","@5","__Engine_Name","Engine_Name","__Engine_Schema","__schema",
"__Engine_Interfaces","Engine_Interfaces","Engine_Interface","Component_Declaration",
"@6","__Component_Name","Component_Name","__Component_Interfaces","Component_Interfaces",
"Component_Interface","Client_Declaration","@7","Client_Name","__Client_Uses",
"ClientUse_List","__Client_End","__Client_Definitions","Client_Definitions",
"Client_Definition","Client_Method","@8","Client_Method_Class_Dec","Client_returns_error",
"Executable_Declaration","@9","__ExecFileDeclaration","__ExecutableName","ExecFile_DeclarationList",
"ExecFile_Declaration","@10","__ExecFile_Name","ExecFile_Name","__ExecFile_Schema",
"__ExecFile_Uses","ExecFile_List","ExecFile_Use","ExecFile_UseType","__ExecFile_Components",
"ExecFile_Components","ExecFile_Component","__ExecFile_ComponentType","ExecFile_ComponentType",
"__Pack_Declaration_List","Pack_Declaration_List","Pack_Declaration","Pack_Declaration_1",
"Separated_Declaration","Seper_Class_Declaration","Sep_Class_Declaration_1",
"Pack_Class_Declaration","Pac_Class_Declaration_1","Inc_NoGeneric_Class","Inc_Generic_Class",
"Generic_C_Declaration","@11","@12","Generic_C_Instanciation","NoGeneric_C_Declaration",
"@13","@14","Embeded_C_Declaration","Embeded_C_Declaration_1","Class_Definition",
"Generic_Type_List","Generic_Type","@15","Type_Constraint","__Inherits_Classes",
"__Uses_Classes","__Raises_Exception","__Embeded_Class_List","Embeded_Class_List",
"__Class_Name","Type_List","Type_Name","@16","Exception_Declaration","Alias_Declaration",
"Pointer_Declaration","Imported_Declaration","Primitive_Declaration","Enumeration_Declaration",
"__Enumeration_End","Enumeration_End","Enum_Item_List","__Member_Method_List",
"Member_Method_List","Member_Method","Method_Name","Method_Definition","__Extern_Method_List",
"Extern_Method_List","Extern_Method","Extern_Met_Definition","Constructor","Instance_Method",
"Class_Method","Extern_Met","Constructor_Header","Extern_Method_Header","Instance_Method_Header",
"Class_Method_Header","Friend_Const_Header","Friend_ExtMet_Header","Friend_InstMet_Header",
"Friend_ClassMet_Header","__S_Parameter_List","Parameter_List","Parameter","Passage_Mode",
"__In","__Me_Mode","__Acces_Mode","Acces_Mode","Transmeted_Type","Constructed_Type",
"Returned_Type","Associated_Type","__Initial_Value","Initial_Value","__Returnrd_Type_Dec",
"__Constructed_Type_Dec","__Errors_Declaration","__Inst_Met_Attr_Dec","Inst_Met_Attr_Dec",
"Definition_Level","__Redefinition","Redefinition","__Field_Declaration","Field_List",
"Field","__Field_Dimension","Integer_List","__Friends_Declaration","@17","Friend_List",
"Friend","Friend_Method_Dec","Friend_Method","@18","Friend_Method_Type_Dec",
"__Class","__Scoop_Declaration","__Scoop_Pro_Declaration","__Scoop","Scoop",
"Name_List","Empty","Empty_Str","dollardset_inc_state","dollardrestore_state",
"dollardInterface_Class","dollardInterface_End","dollardEngine_End","dollardAlias_Begin",
"dollardAlias_Type","dollardAlias_End","dollardPointer_Begin","dollardPointer_Type",
"dollardPointer_End","dollardImported_Begin","dollardImported_End","dollardPrim_Begin",
"dollardPrim_End","dollardExcept_Begin","dollardExcept_End","dollardEnum_Begin",
"dollardEnum_End","dollardInc_Class_Dec","dollardInc_GenClass_Dec","dollardGenClass_Begin",
"dollardAdd_GenType","dollardAdd_DynaGenType","dollardAdd_Embeded","dollardGenClass_End",
"dollardInstClass_Begin","dollardAdd_Gen_Class","dollardAdd_InstType","dollardInstClass_End",
"dollardDynaType_Begin","dollardStdClass_Begin","dollardStdClass_End","dollardAdd_Raises",
"dollardAdd_Field","dollardAdd_FriendMet","dollardAdd_Friend_Class","dollardConstruct_Begin",
"dollardInstMet_Begin","dollardClassMet_Begin","dollardExtMet_Begin","dollardFriend_Construct_Begin",
"dollardFriend_InstMet_Begin","dollardFriend_ClassMet_Begin","dollardFriend_ExtMet_Begin",
"dollardAdd_Me","dollardAdd_MetRaises","dollardAdd_Returns","dollardMemberMet_End",
"dollardExternMet_End","dollardParam_Begin","dollardEnd","dollardSet_In","dollardSet_Out",
"dollardSet_InOut","dollardSet_Mutable","dollardSet_Mutable_Any","dollardSet_Immutable",
"dollardSet_Priv","dollardSet_Defe","dollardSet_Redefined","dollardSet_Prot",
"dollardSet_Static","dollardSet_Virtual","dollardSet_Like_Me","dollardSet_Any", NULL
};
#endif

static const short yyr1[] = {     0,
    68,    68,    69,    69,    70,    70,    70,    70,    70,    70,
    70,    70,    70,    72,    71,    73,    73,    74,    75,    75,
    76,    76,    77,    79,    78,    80,    80,    81,    82,    82,
    83,    83,    84,    84,    85,    85,    86,    86,    86,    87,
    89,    88,    88,    90,    90,    90,    91,    91,    93,    92,
    94,    94,    95,    96,    96,    97,    97,    98,    98,   100,
    99,   101,   101,   102,   103,   103,   104,   104,   105,   105,
   106,   106,   107,   109,   108,   110,   110,   111,   112,   112,
   113,   113,   114,   116,   115,   117,   117,   118,   118,   119,
   119,   120,   120,   120,   121,   121,   122,   122,   123,   123,
   125,   124,   124,   124,   126,   126,   126,   126,   126,   126,
   127,   127,   129,   128,   130,   130,   131,   131,   132,   132,
   134,   133,   135,   135,   136,   137,   137,   138,   138,   139,
   139,   140,   141,   141,   142,   142,   143,   143,   144,   145,
   145,   146,   146,   146,   146,   147,   147,   148,   148,   149,
   149,   150,   150,   150,   150,   150,   150,   150,   151,   151,
   152,   152,   153,   153,   153,   154,   154,   155,   155,   155,
   156,   157,   159,   160,   158,   161,   163,   164,   162,   165,
   165,   165,   166,   166,   166,   167,   168,   168,   170,   169,
   171,   171,   171,   172,   172,   173,   173,   174,   174,   175,
   175,   176,   176,   177,   177,   178,   178,   179,   180,   179,
   181,   182,   183,   184,   185,   186,   187,   187,   188,   188,
   189,   189,   190,   190,   191,   191,   192,   193,   194,   194,
   194,   195,   195,   196,   196,   197,   198,   199,   200,   201,
   202,   203,   203,   204,   204,   205,   206,   207,   207,   208,
   208,   209,   210,   211,   211,   212,   212,   213,   214,   214,
   214,   215,   215,   216,   216,   217,   217,   218,   218,   218,
   219,   219,   220,   221,   221,   222,   223,   223,   224,   224,
   224,   224,   224,   225,   225,   226,   226,   227,   227,   228,
   228,   229,   229,   230,   230,   231,   231,   232,   232,   232,
   233,   233,   234,   234,   235,   236,   236,   237,   237,   238,
   239,   238,   240,   240,   241,   241,   242,   244,   243,   243,
   245,   245,   245,   246,   246,   247,   247,   248,   248,   249,
   249,   250,   250,   251,   251,   252,   253,   254,   255,   256,
   257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
   267,   268,   269,   270,   271,   272,   273,   274,   275,   276,
   277,   278,   279,   280,   281,   282,   283,   284,   285,   286,
   287,   288,   289,   290,   291,   292,   293,   294,   295,   296,
   297,   298,   299,   300,   301,   302,   303,   304,   305,   306,
   307,   308,   309,   310,   311,   312,   313,   314,   315,   316,
   317,   318,   319
};

static const short yyr2[] = {     0,
     1,     1,     1,     2,     1,     1,     1,     1,     1,     1,
     1,     1,     1,     0,     9,     1,     1,     1,     1,     2,
     1,     3,     2,     0,    10,     1,     1,     1,     1,     2,
     1,     3,     1,     1,     1,     2,     3,     4,     2,     2,
     0,     5,     5,     2,     2,     2,     1,     2,     0,     8,
     1,     1,     1,     1,     1,     1,     2,     3,     3,     0,
    10,     1,     1,     1,     1,     3,     1,     1,     1,     1,
     1,     2,     3,     0,     8,     1,     1,     1,     1,     1,
     1,     2,     5,     0,     9,     1,     1,     1,     2,     1,
     3,     1,     1,     1,     1,     1,     1,     2,     3,     3,
     0,     5,     5,     7,     2,     4,     2,     4,     2,     4,
     1,     2,     0,     8,     1,     1,     1,     1,     1,     2,
     0,    10,     1,     1,     1,     1,     3,     1,     2,     1,
     3,     3,     1,     1,     1,     1,     1,     2,     3,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     2,     1,
     3,     1,     1,     1,     1,     1,     1,     1,     1,     3,
     1,     3,     1,     1,     1,     1,     3,     1,     1,     1,
     6,     7,     0,     0,    19,    14,     0,     0,    16,     1,
     3,     3,     1,     1,     1,     3,     1,     3,     0,     4,
     3,     2,     7,     1,     2,     1,     2,     1,     3,     1,
     1,     2,     3,     1,     1,     1,     3,     1,     0,     4,
     9,    10,    10,     7,     8,    10,     1,     1,     1,     2,
     1,     3,     1,     1,     1,     2,     2,     1,     1,     1,
     1,     1,     1,     1,     2,     2,     1,     6,     6,     6,
     6,     2,     4,     3,     4,     7,     5,     2,     4,     3,
     4,     7,     5,     1,     2,     1,     3,     5,     1,     2,
     3,     1,     2,     1,     3,     1,     1,     2,     2,     2,
     2,     3,     3,     3,     3,     3,     1,     2,     1,     1,
     1,     1,     1,     1,     2,     1,     2,     1,     3,     2,
     2,     1,     2,     1,     3,     2,     1,     2,     3,     2,
     1,     2,     1,     2,     7,     1,     3,     1,     3,     1,
     0,     3,     1,     3,     1,     3,     2,     0,     5,     4,
     2,     2,     2,     1,     1,     1,     2,     1,     3,     1,
     1,     2,     2,     1,     3,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0
};

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

static const short yydefgoto[] = {   712,
    13,    14,    15,    58,   282,    45,    76,   109,   164,    16,
    57,   268,    43,    73,   106,   147,   148,   149,   150,   217,
   346,   397,   395,    17,    53,   197,    37,    91,    92,    93,
    18,    54,   256,    39,    68,    96,   133,   134,   135,    19,
    51,   193,    34,    85,    86,    87,    20,    50,    32,    63,
    82,   244,   119,   120,   121,   190,   333,   379,   375,    21,
    70,   100,   205,   101,   102,   203,   508,   138,   259,   302,
   337,   338,   444,   387,   388,   389,   450,   451,   165,   166,
   167,   168,    22,    23,    24,   169,   170,   171,   172,    25,
   307,   393,    26,    27,   184,   294,   518,   519,   425,   142,
   143,   207,   305,   114,   239,   328,   520,   521,   542,   182,
   183,    78,   174,   175,   176,   177,   178,   179,   526,   527,
   463,   426,   427,   428,   429,   491,   231,   232,   233,   286,
   492,   493,   494,   287,   495,   288,   496,   497,   380,   331,
   381,   382,   564,   356,   357,   472,   473,   561,   362,   363,
   536,   596,   364,   418,   614,   641,   323,   555,   367,   629,
   657,   658,   695,   659,   487,   545,   546,   643,   667,   549,
   591,   620,   621,   622,   647,   703,   708,   248,   421,   669,
   681,   482,   358,   365,   194,    29,    61,   308,   344,   334,
   347,   523,   610,   353,   530,   612,   352,   466,   354,   531,
   350,   582,   349,   611,   402,   465,    71,   342,   604,   575,
   698,   112,   236,   423,   541,   392,    80,   616,   424,   701,
   709,   671,   553,   592,   593,   321,   437,   501,   502,   373,
   601,   479,   477,   676,   540,   587,   369,   533,   534,   584,
   415,   413,   414,    46,    35,   678,   539,   662,   680,   537,
   340
};

static const short yypact[] = {   116,
-32768,-32768,   174,   -10,-32768,    51,    84,   102,   154,   161,
   164,-32768,   252,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   167,-32768,
-32768,-32768,-32768,-32768,    34,-32768,-32768,-32768,-32768,   159,
   167,-32768,-32768,-32768,-32768,   145,-32768,   163,-32768,   131,
   180,-32768,   210,   224,-32768,-32768,   219,   250,-32768,-32768,
   254,   174,   267,-32768,   251,   106,   286,   269,-32768,   283,
   255,   164,   271,-32768,   164,   273,-32768,   164,-32768,   279,
-32768,   256,    61,   257,   294,   251,-32768,-32768,   167,   164,
   295,   106,-32768,-32768,-32768,   258,-32768,   280,   259,   298,
   283,-32768,-32768,   260,-32768,   263,    28,-32768,   265,   155,
-32768,   167,   167,-32768,-32768,   174,   264,-32768,   299,    61,
-32768,   300,-32768,   301,   268,-32768,   272,   274,    51,-32768,
-32768,   275,   308,   280,-32768,-32768,-32768,-32768,   276,-32768,
-32768,    46,-32768,   164,   167,   164,   316,    28,-32768,   282,
   311,-32768,   164,-32768,-32768,-32768,-32768,-32768,   328,-32768,
-32768,-32768,-32768,   324,   288,   155,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   284,-32768,   293,-32768,   289,   195,-32768,   107,   297,
   290,-32768,   302,-32768,-32768,-32768,   303,-32768,-32768,   306,
   292,-32768,   329,-32768,   312,-32768,   345,   279,   260,-32768,
   313,   315,   317,-32768,-32768,   128,-32768,-32768,   167,   167,
   123,   167,   167,-32768,   167,   167,   234,   167,   164,   304,
-32768,   288,-32768,-32768,-32768,   305,   167,   167,-32768,-32768,
-32768,-32768,-32768,   318,-32768,-32768,   322,   167,-32768,-32768,
   319,-32768,-32768,-32768,-32768,   321,-32768,   286,   323,-32768,
-32768,    27,-32768,-32768,-32768,-32768,-32768,   326,-32768,   327,
   167,-32768,-32768,-32768,-32768,-32768,   167,-32768,-32768,-32768,
-32768,   331,-32768,-32768,-32768,-32768,-32768,   337,-32768,-32768,
   167,-32768,   284,   344,-32768,   338,-32768,-32768,-32768,    51,
   330,   359,-32768,-32768,-32768,   342,   293,-32768,-32768,   338,
-32768,-32768,    53,-32768,-32768,   284,-32768,-32768,-32768,-32768,
   336,    99,   355,-32768,-32768,    -4,   167,   368,-32768,-32768,
   356,-32768,   351,-32768,-32768,   394,   348,-32768,   349,-32768,
-32768,-32768,-32768,-32768,   361,   351,   377,-32768,   378,   382,
   358,   360,   367,   279,-32768,   121,-32768,   147,-32768,-32768,
-32768,    82,-32768,-32768,-32768,   167,   384,-32768,-32768,-32768,
   284,   288,   336,   167,   385,-32768,-32768,   205,-32768,   356,
   356,   356,-32768,   253,   330,   228,   403,   349,-32768,-32768,
-32768,   167,   344,   167,-32768,-32768,-32768,   361,   361,   361,
   167,-32768,   362,   167,-32768,-32768,   167,   364,-32768,   336,
   109,   363,-32768,-32768,-32768,   388,-32768,-32768,   284,   203,
   369,-32768,   370,-32768,   412,   406,   288,-32768,   379,-32768,
   133,-32768,   423,-32768,-32768,-32768,   336,   400,   401,   402,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   380,
-32768,-32768,   259,-32768,   113,    39,-32768,-32768,-32768,-32768,
-32768,-32768,    43,   231,-32768,-32768,-32768,-32768,-32768,   399,
-32768,    99,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,   167,   336,   414,-32768,-32768,   236,
-32768,-32768,-32768,-32768,   393,   337,   337,-32768,-32768,-32768,
   386,   387,   143,   431,   433,   435,-32768,   389,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   413,
    39,-32768,   391,   167,   390,   392,-32768,-32768,-32768,   395,
-32768,-32768,-32768,-32768,    82,-32768,-32768,-32768,-32768,-32768,
-32768,   396,-32768,-32768,   336,-32768,   220,-32768,-32768,-32768,
-32768,-32768,   336,    99,   355,-32768,   355,   355,-32768,   109,
-32768,-32768,   336,   404,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   167,   439,   439,-32768,   288,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,   398,-32768,-32768,-32768,-32768,   167,
    33,   386,   387,   149,   167,-32768,   384,   420,   384,    99,
   387,   407,-32768,-32768,-32768,-32768,-32768,   441,-32768,-32768,
-32768,-32768,   148,-32768,-32768,-32768,   405,   167,   437,   410,
-32768,-32768,-32768,   409,-32768,-32768,   408,    29,   415,-32768,
   416,-32768,   417,    53,   167,-32768,-32768,-32768,-32768,-32768,
-32768,   397,   436,-32768,-32768,   129,-32768,    33,   387,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   203,-32768,-32768,
-32768,-32768,-32768,-32768,   418,-32768,   -11,   427,   419,-32768,
-32768,   421,   167,-32768,   422,-32768,-32768,    48,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   425,-32768,-32768,
   338,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,   351,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   478,   479,-32768
};

static const short yypgoto[] = {-32768,
-32768,   467,-32768,-32768,-32768,   -19,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   333,-32768,-32768,
-32768,-32768,  -181,-32768,-32768,-32768,  -108,-32768,-32768,   411,
-32768,-32768,-32768,-32768,-32768,   225,-32768,-32768,   350,-32768,
-32768,-32768,-32768,-32768,-32768,   424,-32768,-32768,   -23,-32768,
-32768,-32768,-32768,-32768,   371,-32768,-32768,-32768,  -141,-32768,
-32768,-32768,-32768,-32768,   426,-32768,-32768,    36,-32768,-32768,
-32768,   105,-32768,-32768,-32768,   104,-32768,-32768,-32768,-32768,
   334,   266,-32768,   448,   464,-32768,   285,  -420,-32768,-32768,
-32768,-32768,  -106,  -418,-32768,-32768,   -17,  -282,   -71,-32768,
   307,-32768,-32768,  -177,   200,   115,-32768,-32768,  -126,  -204,
     1,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,    85,   -80,-32768,-32768,-32768,   281,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,  -341,  -304,
  -337,  -334,  -558,  -358,   108,   -46,-32768,   -77,  -440,-32768,
-32768,-32768,-32768,   -18,-32768,-32768,  -199,-32768,  -377,-32768,
-32768,-32768,-32768,  -159,-32768,-32768,   -25,-32768,-32768,-32768,
-32768,-32768,  -127,-32768,-32768,-32768,-32768,  -214,  -316,-32768,
-32768,  -553,  -453,     0,  -105,  -147,  -253,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   182,-32768,   -54,
-32768,-32768,-32768,    13,-32768,-32768,-32768,-32768,-32768,-32768,
  -407,-32768,    30,-32768,-32768,   237,   146,-32768,-32768,   198,
   -92,-32768,  -389,  -379,-32768,-32768,   156,-32768,-32768,-32768,
-32768,-32768,-32768,  -145,  -155,-32768,  -496,  -123,  -571,-32768,
-32768
};


#define     YYLAST            703


static const short yytable[] = {    28,
   221,   271,   122,   173,   398,   345,   219,   220,   399,   222,
   223,   400,   225,   226,   431,   228,   227,   574,   312,   313,
   198,   314,   315,   199,   317,   318,   151,   319,   478,    49,
   263,   535,   547,   293,   624,   515,   304,   517,    81,   122,
   145,    56,   633,   687,   653,   618,     2,   688,   370,    64,
    33,   512,   105,    69,   237,   108,    74,    77,   111,   173,
   524,     9,   351,   653,    88,    94,    97,   151,   146,   103,
   128,   480,   316,   481,   660,   654,   277,   655,   503,   115,
   656,   513,   123,   514,   230,    79,   326,    48,   118,   127,
   675,   547,   185,   118,   117,   257,   655,   136,   208,   656,
   515,   525,   517,   209,   682,   694,   152,   269,   359,   180,
   348,    36,   181,   595,   173,  -336,     1,   416,    89,   246,
   173,   118,   371,   284,   210,   704,   212,   360,     2,     3,
     4,     5,     6,   218,     7,   155,   361,     8,   206,   470,
   246,   246,    48,     9,    38,   211,    90,   247,   471,    10,
   159,   230,   515,   515,   517,   517,    11,     2,    12,   632,
     5,   419,    40,   154,   234,   511,    41,   155,   270,   672,
   156,   237,     9,   409,   157,   158,   408,   597,   410,   598,
   599,    62,   159,   240,   160,   499,   245,   455,   249,    60,
   410,   335,   700,    55,   594,   566,   161,   162,   163,   464,
   410,   625,   260,   411,   602,   412,   410,   115,   636,   283,
   637,   638,   639,   640,    65,   249,   458,   459,   460,   272,
   273,    42,   275,   276,    44,   278,   279,    48,   281,   289,
   446,   447,   448,   449,    30,    31,   651,   292,   438,   439,
   440,   435,   154,   436,    66,   480,   155,   481,   297,   156,
    67,    -2,     1,   157,   158,   242,   243,    97,   303,   442,
   443,   159,   306,   160,     2,     3,     4,     5,     6,    72,
     7,   311,   551,     8,   552,   161,   590,   163,   412,     9,
   627,   684,   631,   685,    84,    10,    79,   324,   529,   237,
   606,   607,    11,   329,    12,   332,   557,   558,   710,   711,
    75,    83,    95,    98,    99,   107,   240,   110,   104,   332,
   113,   125,   129,   132,   116,   139,   187,   124,   131,   137,
   141,   144,   368,   153,   186,   201,   189,   191,   192,   195,
   376,   196,   383,   213,   538,   200,   204,   216,   390,   215,
   224,   229,   237,   238,   396,   383,   241,   510,   118,   516,
   251,   634,   255,   115,   250,   258,   262,   285,   291,   252,
   253,   705,   417,   254,   572,   706,   422,   573,   707,   261,
   265,   430,   266,   301,   432,   295,   298,   267,   299,   376,
   376,   376,   296,   309,   322,   452,   702,   310,   320,   327,
   336,   330,   329,   339,   457,   341,   355,   396,   396,   396,
   366,   461,   372,   374,   378,   384,   385,   467,   394,   386,
   474,   401,   403,   404,   516,   405,   407,   406,   420,   433,
   453,   468,   462,   475,   476,   488,   483,   484,   498,   485,
   486,   673,   490,   500,   504,   505,   506,   507,   532,   548,
   554,   567,   560,   568,   563,   569,   570,   576,   578,   581,
   580,   512,   583,   588,   628,   522,   603,   613,   635,   666,
   642,   650,   528,   646,   410,   652,   516,   516,   648,   664,
   668,   689,   661,   663,   693,   686,   690,   713,   714,    47,
   214,   691,   300,   202,   544,   543,   550,   699,   509,   445,
   188,   454,   280,    59,   556,   324,   324,   677,    52,   235,
   562,   565,   130,   577,   608,   274,   343,   456,   665,   126,
   619,   489,   290,   600,   623,   264,   586,   469,   696,   589,
   674,   391,   609,   571,   579,   325,   140,   559,   441,   377,
   649,   679,   434,     0,     0,   585,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,   368,     0,   368,   368,     0,   474,
     0,     0,     0,     0,     0,     0,     0,   619,     0,     0,
     0,     0,   605,     0,     0,   430,     0,     0,     0,     0,
     0,     0,     0,     0,   615,     0,     0,     0,     0,     0,
   617,   562,   565,     0,     0,   626,   422,   630,   422,     0,
   565,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,   644,     0,   645,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,   544,   543,     0,     0,     0,     0,
     0,     0,   670,     0,     0,   249,     0,     0,   565,     0,
     0,     0,     0,     0,     0,     0,     0,   683,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,   692,     0,     0,     0,   697,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
   332,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,   383
};

static const short yycheck[] = {     0,
   156,   216,    83,   110,   346,   310,   154,   155,   346,   157,
   158,   346,   160,   161,   373,   163,   162,   514,   272,   273,
   129,   275,   276,   129,   278,   279,   107,   281,   418,    29,
   208,   472,   486,   238,   593,   456,    10,   456,    62,   120,
    13,    41,   601,    55,    16,    13,    13,    59,    53,    50,
    61,    13,    72,    54,    59,    75,    57,    58,    78,   166,
    18,    28,   316,    16,    65,    66,    67,   148,    41,    70,
    90,    43,   277,    45,   628,    47,   224,    49,   437,    80,
    52,    43,    83,    45,   165,    33,   291,    61,    61,    89,
   649,   545,   116,    61,    34,   201,    49,    98,    53,    52,
   521,    59,   521,    58,   658,   677,   107,   213,    10,   110,
    58,    61,   112,   554,   221,     0,     1,    36,    13,    13,
   227,    61,   327,   229,   144,   697,   146,    29,    13,    14,
    15,    16,    17,   153,    19,    13,    38,    22,   139,    31,
    13,    13,    61,    28,    61,   145,    41,    41,    40,    34,
    28,   232,   573,   574,   573,   574,    41,    13,    43,   600,
    16,   366,    61,     9,   165,    53,    13,    13,    41,    41,
    16,    59,    28,    53,    20,    21,   354,   555,    58,   557,
   558,    51,    28,   184,    30,    53,   187,   392,   189,    27,
    58,   300,   689,    35,   553,    53,    42,    43,    44,   404,
    58,    53,   203,    57,   563,    59,    58,   208,    61,   229,
    63,    64,    65,    66,    35,   216,   398,   399,   400,   219,
   220,    61,   222,   223,    61,   225,   226,    61,   228,   230,
     3,     4,     5,     6,    61,    62,   626,   237,   380,   381,
   382,    37,     9,    39,    35,    43,    13,    45,   248,    16,
    27,     0,     1,    20,    21,    61,    62,   258,   259,     7,
     8,    28,   262,    30,    13,    14,    15,    16,    17,    51,
    19,   271,    37,    22,    39,    42,    57,    44,    59,    28,
   597,   661,   599,   663,    34,    34,    33,   288,    58,    59,
   573,   574,    41,   294,    43,   296,   496,   497,   706,   707,
    51,    35,    17,    35,    22,    35,   307,    35,    54,   310,
    32,    18,    18,    34,    59,    18,    18,    61,    61,    61,
    61,    59,   323,    59,    61,    18,    27,    27,    61,    58,
   331,    58,   333,    18,   480,    61,    61,    27,   339,    58,
    13,    18,    59,    51,   345,   346,    58,   453,    61,   456,
    61,   605,    61,   354,    58,    27,    12,    54,    54,    58,
    58,   703,   362,    58,   512,   703,   367,   513,   703,    58,
    58,   372,    58,    51,   374,    58,    58,    61,    58,   380,
   381,   382,    61,    58,    48,   386,   691,    61,    58,    46,
    61,    54,   393,    35,   394,    54,    61,   398,   399,   400,
    46,   401,    35,    48,    54,    12,    59,   407,    48,    61,
   411,    35,    35,    32,   521,    58,    50,    58,    35,    35,
    18,    58,    61,    61,    37,   426,    58,    58,   429,    18,
    25,   646,    54,    11,    35,    35,    35,    58,    40,    26,
    48,    11,    57,    11,    58,    11,    58,    35,    58,    58,
    61,    13,    58,    58,    35,   456,    53,    60,    18,    63,
    56,    53,   463,    27,    58,    58,   573,   574,    59,    53,
    35,    45,    58,    58,    53,    58,    58,     0,     0,    13,
   148,    61,   258,   134,   485,   485,   487,    63,   453,   385,
   120,   388,   227,    46,   495,   496,   497,   653,    35,   166,
   501,   502,    92,   521,   576,   221,   307,   393,   635,    86,
   591,   427,   232,   560,   592,   209,   535,   410,   678,   545,
   648,   340,   577,   511,   524,   289,   101,   498,   383,   332,
   623,   655,   377,    -1,    -1,   535,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,   555,    -1,   557,   558,    -1,   560,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,   648,    -1,    -1,
    -1,    -1,   572,    -1,    -1,   576,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,   585,    -1,    -1,    -1,    -1,    -1,
   590,   592,   593,    -1,    -1,   595,   597,   598,   599,    -1,
   601,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,   617,    -1,   618,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,   635,   635,    -1,    -1,    -1,    -1,
    -1,    -1,   643,    -1,    -1,   646,    -1,    -1,   649,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,   658,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,   673,    -1,    -1,    -1,   678,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
   691,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    -1,    -1,   703
};
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/PRODUCTS/flexbis-253-125/share/bison.simple"

/* Skeleton output parser for bison,
   Copyright (C) 1984, 1989, 1990 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., 675 Mass Ave, Cambridge, MA 02139, 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.  */

#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C.  */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
#if (  defined( MSDOS ) || defined( WNT )  ) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
 #pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc.  */
#endif /* not GNU C.  */
#endif /* alloca not defined.  */

/* 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.  */

/* Note: there must be only one dollar sign in this file.
   It is replaced by the list of actions, each action
   as one case of the switch.  */

#define yyerrok         (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY         -2
#define YYEOF           0
#define YYACCEPT  return(0)
#define YYABORT   return(1)
#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

#ifndef YYPURE
#define YYLEX           yylex()
#endif

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

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int   yychar;                 /*  the lookahead symbol            */
YYSTYPE     yylval;                 /*  the semantic value of the       */
                        /*  lookahead symbol                */

#ifdef YYLSP_NEEDED
YYLTYPE yylloc;               /*  location data for the lookahead */
                        /*  symbol                    */
#endif

int yynerrs;                  /*  number of parse errors so far       */
#endif  /* not YYPURE */

#if YYDEBUG != 0
int yydebug;                  /*  nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
   from coexisting.  */
#endif

/*  YYINITDEPTH indicates the initial size of the parser's stacks */

#ifndef     YYINITDEPTH
#define YYINITDEPTH 200
#endif

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

#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
int yyparse (void);
#endif

#if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
#ifdef WNT
#define __yy_bcopy(FROM,TO,COUNT)   __builtin_memcpy(TO,FROM,COUNT)
#else
#define __yy_memcpy(TO,FROM,COUNT)  __builtin_memcpy(TO,FROM,COUNT)
#endif
#else                   /* not GNU C or C++ */
#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
#ifdef WNT
__yy_bcopy (__from, __to, __count)
     char *__from;
     char *__to;
     int __count;
#else
__yy_memcpy (to, from, count)
     char *to;
     char *from;
     int count;
#endif
{
#ifdef WNT
  register char *f = __from;
  register char *t = __to;
  register int i = __count;
#else
  register char *f = from;
  register char *t = to;
  register int i = count;
#endif

  while (i-- > 0)
    *t++ = *f++;
}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
#ifdef WNT
__yy_bcopy (char *__from, char *__to, int __count)
#else
__yy_memcpy (char *to, char *from, int count)
#endif
{
#ifdef WNT
  register char *f = __from;
  register char *t = __to;
  register int i = __count;
#else
  register char *f = from;
  register char *t = to;
  register int i = count;
#endif

  while (i-- > 0)
    *t++ = *f++;
}

#endif
#endif

#line 196 "/PRODUCTS/flexbis-253-125/share/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
#ifdef __cplusplus
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#else /* not __cplusplus */
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#endif /* not __cplusplus */
#else /* not YYPARSE_PARAM */
#define YYPARSE_PARAM_ARG
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */

int
#ifdef WNT
yyparse()
#else
yyparse(YYPARSE_PARAM_ARG)
     YYPARSE_PARAM_DECL
#endif
{
  register int yystate;
  register int yyn;
  register short *yyssp;
  register YYSTYPE *yyvsp;
  int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
  int yychar1 = 0;            /*  lookahead token as an internal (translated) token number */

  short     yyssa[YYINITDEPTH];     /*  the state stack                 */
  YYSTYPE yyvsa[YYINITDEPTH]; /*  the semantic value stack        */

  short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  YYSTYPE *yyvs = yyvsa;      /*  to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED
  YYLTYPE yylsa[YYINITDEPTH]; /*  the location stack              */
  YYLTYPE *yyls = yylsa;
  YYLTYPE *yylsp;

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

  int yystacksize = YYINITDEPTH;

#ifdef YYPURE
  int yychar;
  YYSTYPE yylval;
  int yynerrs;
#ifdef YYLSP_NEEDED
  YYLTYPE yylloc;
#endif
#endif

  YYSTYPE yyval;        /*  the variable used to return           */
                        /*  semantic values from the action */
                        /*  routines                        */

  int yylen;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Starting parse\n");
#endif

  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 - 1;
  yyvsp = yyvs;
#ifdef YYLSP_NEEDED
  yylsp = yyls;
#endif

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

  *++yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* 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;
#ifdef YYLSP_NEEDED
      YYLTYPE *yyls1 = yyls;
#endif

      /* Get the current used size of the three stacks, in elements.  */
      int size = yyssp - yyss + 1;

#ifdef yyoverflow
      /* Each stack pointer address is followed by the size of
       the data in use in that stack, in bytes.  */
#ifdef YYLSP_NEEDED
      /* 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, size * sizeof (*yyssp),
             &yyvs1, size * sizeof (*yyvsp),
             &yyls1, size * sizeof (*yylsp),
             &yystacksize);
#else
      yyoverflow("parser stack overflow",
             &yyss1, size * sizeof (*yyssp),
             &yyvs1, size * sizeof (*yyvsp),
             &yystacksize);
#endif

      yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
      yyls = yyls1;
#endif
#else /* no yyoverflow */
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
      {
        yyerror("parser stack overflow");
        return 2;
      }
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
      yystacksize = YYMAXDEPTH;
      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
#ifdef WNT
      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
#else
      __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
#endif
      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
#ifdef WNT
      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
#else
      __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
#endif
#ifdef YYLSP_NEEDED
      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
#ifdef WNT
      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
#else
      __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
#endif
#endif
#endif /* no yyoverflow */

      yyssp = yyss + size - 1;
      yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
      yylsp = yyls + size - 1;
#endif

#if YYDEBUG != 0
      if (yydebug)
      fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif

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

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Entering state %d\n", yystate);
#endif

  goto 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)
    {
#if YYDEBUG != 0
      if (yydebug)
      fprintf(stderr, "Reading a token: ");
#endif
      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 */

#if YYDEBUG != 0
      if (yydebug)
      fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0
      if (yydebug)
      {
        fprintf (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
        fprintf (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.  */

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif

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

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

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

  yystate = yyn;
  goto yynewstate;

/* Do the default action for the current state.  */
yydefault:

  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;

/* Do a reduction.  yyn is the number of a rule to reduce with.  */
yyreduce:
  yylen = yyr2[yyn];
  if (yylen > 0)
    yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
  if (yydebug)
    {
      int i;

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

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


  switch (yyn) {

case 14:
{ Pack_Begin(yyvsp[0].str); ;
    break;}
case 15:
{ Pack_End(); ;
    break;}
case 21:
{ Pack_Use(yyvsp[0].str); ;
    break;}
case 22:
{ Pack_Use(yyvsp[0].str); ;
    break;}
case 24:
{ Interface_Begin(yyvsp[0].str); ;
    break;}
case 31:
{Interface_Use(yyvsp[0].str);;
    break;}
case 32:
{ Interface_Use(yyvsp[0].str); ;
    break;}
case 37:
{ Interface_Package(yyvsp[-1].str); ;
    break;}
case 41:
{ Method_TypeName(); ;
    break;}
case 43:
{Interface_Method(yyvsp[-2].str);;
    break;}
case 44:
{Interface_Method("");;
    break;}
case 45:
{Interface_Method("");;
    break;}
case 46:
{Interface_Method("");;
    break;}
case 48:
{ CDLerror("in interface, method declaration can not have a 'returns' clause"); ;
    break;}
case 49:
{ Schema_Begin(yyvsp[0].str); ;
    break;}
case 50:
{ Schema_End(); ;
    break;}
case 58:
{ Schema_Package(yyvsp[-1].str); ;
    break;}
case 59:
{ Schema_Class(); ;
    break;}
case 60:
{ Engine_Begin(yyvsp[0].str); ;
    break;}
case 66:
{ Engine_Schema(yyvsp[0].str); ;
    break;}
case 73:
{ Engine_Interface(yyvsp[-1].str); ;
    break;}
case 74:
{ Component_Begin(yyvsp[0].str); ;
    break;}
case 75:
{ Component_End(); ;
    break;}
case 83:
{ Component_Interface(yyvsp[-3].str,yyvsp[-1].str); ;
    break;}
case 84:
{ Client_Begin(yyvsp[0].str); ;
    break;}
case 90:
{ Client_Use ( yyvsp[0].str ); ;
    break;}
case 91:
{ Client_Use ( yyvsp[0].str ); ;
    break;}
case 93:
{ Client_End(); ;
    break;}
case 94:
{ Client_End(); ;
    break;}
case 99:
{ Client_Interface(yyvsp[-1].str); ;
    break;}
case 101:
{ Method_TypeName(); ;
    break;}
case 103:
{Client_Method(yyvsp[-2].str,1);;
    break;}
case 104:
{Client_Method(yyvsp[-4].str,1);;
    break;}
case 105:
{Client_Method("",1);;
    break;}
case 106:
{Client_Method("",1);;
    break;}
case 107:
{Client_Method("",1);;
    break;}
case 108:
{Client_Method("",1);;
    break;}
case 109:
{Client_Method("",-1);;
    break;}
case 110:
{Client_Method("",-1);;
    break;}
case 112:
{ CDLerror("in client, method declaration can not have a 'returns' clause"); ;
    break;}
case 113:
{ Executable_Begin(yyvsp[-1].str); ;
    break;}
case 117:
{  Executable_End(); ;
    break;}
case 118:
{ Executable_End(); ;
    break;}
case 121:
{ ExecFile_Begin(yyvsp[0].str); ;
    break;}
case 122:
{ ExecFile_End(); ;
    break;}
case 127:
{ ExecFile_Schema(yyvsp[0].str); ;
    break;}
case 132:
{ExecFile_AddUse(yyvsp[-2].str);;
    break;}
case 133:
{ExecFile_SetUseType(CDL_LIBRARY); ;
    break;}
case 134:
{ExecFile_SetUseType(CDL_EXTERNAL); ;
    break;}
case 139:
{ ExecFile_AddComponent(yyvsp[-2].str); ;
    break;}
case 140:
{ ExecFile_SetLang(CDL_CPP); ;
    break;}
case 142:
{ ExecFile_SetLang(CDL_CPP); ;
    break;}
case 143:
{ ExecFile_SetLang(CDL_FOR); ;
    break;}
case 144:
{ ExecFile_SetLang(CDL_C); ;
    break;}
case 145:
{ ExecFile_SetLang(CDL_OBJ); ;
    break;}
case 173:
{ Add_Std_Ancestors(); ;
    break;}
case 174:
{ Add_Std_Uses(); ;
    break;}
case 177:
{ Add_Std_Ancestors(); ;
    break;}
case 178:
{ Add_Std_Uses(); ;
    break;}
case 189:
{ Set_Item(yyvsp[0].str); ;
    break;}
case 206:
{ Add_Type(); ;
    break;}
case 207:
{ Add_Type(); ;
    break;}
case 208:
{ Type_Name(yyvsp[0].str); Type_Pack_Blanc(); ;
    break;}
case 209:
{ Type_Name(yyvsp[-1].str); ;
    break;}
case 210:
{ Type_Pack(yyvsp[0].str); ;
    break;}
case 221:
{ Add_Enum(yyvsp[0].str); ;
    break;}
case 222:
{ Add_Enum(yyvsp[0].str); ;
    break;}
case 224:
{ add_cpp_comment_to_method(); ;
    break;}
case 228:
{ Set_Method(yyvsp[0].str); ;
    break;}
case 233:
{ add_cpp_comment_to_method(); ;
    break;}
case 279:
{ Add_Value(yyvsp[0].str,INTEGER); ;
    break;}
case 280:
{ Add_Value(yyvsp[0].str,REAL); ;
    break;}
case 281:
{ Add_Value(yyvsp[0].str,STRING); ;
    break;}
case 282:
{ Add_Value(yyvsp[0].str,LITERAL); ;
    break;}
case 283:
{ Add_Value(yyvsp[0].str,IDENTIFIER); ;
    break;}
case 308:
{ Begin_List_Int(yyvsp[0].str); ;
    break;}
case 309:
{ Make_List_Int(yyvsp[0].str); ;
    break;}
case 311:
{ CDL_MustNotCheckUses(); ;
    break;}
case 312:
{ CDL_MustCheckUses(); ;
    break;}
case 318:
{ Method_TypeName(); ;
    break;}
case 320:
{ Add_FriendExtMet(yyvsp[-1].str); ;
    break;}
case 334:
{ add_name_to_list(yyvsp[0].str); ;
    break;}
case 335:
{ add_name_to_list(yyvsp[0].str); ;
    break;}
case 337:
{yyval.str[0] = '\0';;
    break;}
case 338:
{set_inc_state();;
    break;}
case 339:
{restore_state();;
    break;}
case 340:
{Interface_Class();;
    break;}
case 341:
{Interface_End();;
    break;}
case 342:
{Engine_End();;
    break;}
case 343:
{Alias_Begin();;
    break;}
case 344:
{Alias_Type();;
    break;}
case 345:
{Alias_End();;
    break;}
case 346:
{Pointer_Begin();;
    break;}
case 347:
{Pointer_Type();;
    break;}
case 348:
{Pointer_End();;
    break;}
case 349:
{Imported_Begin();;
    break;}
case 350:
{Imported_End();;
    break;}
case 351:
{Prim_Begin();;
    break;}
case 352:
{Prim_End();;
    break;}
case 353:
{Except_Begin();;
    break;}
case 354:
{Except_End();;
    break;}
case 355:
{Enum_Begin();;
    break;}
case 356:
{Enum_End();;
    break;}
case 357:
{Inc_Class_Dec();;
    break;}
case 358:
{Inc_GenClass_Dec();;
    break;}
case 359:
{GenClass_Begin();;
    break;}
case 360:
{Add_GenType();;
    break;}
case 361:
{Add_DynaGenType();;
    break;}
case 362:
{Add_Embeded();;
    break;}
case 363:
{GenClass_End();;
    break;}
case 364:
{InstClass_Begin();;
    break;}
case 365:
{Add_Gen_Class();;
    break;}
case 366:
{Add_InstType();;
    break;}
case 367:
{InstClass_End();;
    break;}
case 368:
{DynaType_Begin();;
    break;}
case 369:
{StdClass_Begin();;
    break;}
case 370:
{StdClass_End();;
    break;}
case 371:
{Add_Raises();;
    break;}
case 372:
{Add_Field();;
    break;}
case 373:
{Add_FriendMet();;
    break;}
case 374:
{Add_Friend_Class();;
    break;}
case 375:
{Construct_Begin();;
    break;}
case 376:
{InstMet_Begin();;
    break;}
case 377:
{ClassMet_Begin();;
    break;}
case 378:
{ExtMet_Begin();;
    break;}
case 379:
{Friend_Construct_Begin();;
    break;}
case 380:
{Friend_InstMet_Begin();;
    break;}
case 381:
{Friend_ClassMet_Begin();;
    break;}
case 382:
{Friend_ExtMet_Begin();;
    break;}
case 383:
{Add_Me();;
    break;}
case 384:
{Add_MetRaises();;
    break;}
case 385:
{Add_Returns();;
    break;}
case 386:
{MemberMet_End();;
    break;}
case 387:
{ExternMet_End();;
    break;}
case 388:
{Param_Begin();;
    break;}
case 389:
{End();;
    break;}
case 390:
{Set_In();;
    break;}
case 391:
{Set_Out();;
    break;}
case 392:
{Set_InOut();;
    break;}
case 393:
{Set_Mutable();;
    break;}
case 394:
{Set_Mutable_Any();;
    break;}
case 395:
{Set_Immutable();;
    break;}
case 396:
{Set_Priv();;
    break;}
case 397:
{Set_Defe();;
    break;}
case 398:
{Set_Redefined();;
    break;}
case 399:
{Set_Prot();;
    break;}
case 400:
{Set_Static();;
    break;}
case 401:
{Set_Virtual();;
    break;}
case 402:
{Set_Like_Me();;
    break;}
case 403:
{Set_Any();;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 498 "/PRODUCTS/flexbis-253-125/share/bison.simple"

  yyvsp -= yylen;
  yyssp -= yylen;
#ifdef YYLSP_NEEDED
  yylsp -= yylen;
#endif

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

  *++yyvsp = yyval;

#ifdef YYLSP_NEEDED
  yylsp++;
  if (yylen == 0)
    {
      yylsp->first_line = yylloc.first_line;
      yylsp->first_column = yylloc.first_column;
      yylsp->last_line = (yylsp-1)->last_line;
      yylsp->last_column = (yylsp-1)->last_column;
      yylsp->text = 0;
    }
  else
    {
      yylsp->last_line = (yylsp+yylen-1)->last_line;
      yylsp->last_column = (yylsp+yylen-1)->last_column;
    }
#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 */

  if (! yyerrstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++yynerrs;

#ifdef YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (yyn > YYFLAG && yyn < YYLAST)
      {
        int size = 0;
        char *msg;
        int x, count;

        count = 0;
        /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
        for (x = (yyn < 0 ? -yyn : 0);
             x < (sizeof(yytname) / sizeof(char *)); x++)
          if (yycheck[x + yyn] == x)
            size += strlen(yytname[x]) + 15, count++;
        msg = (char *) malloc(size + 15);
        if (msg != 0)
          {
            strcpy(msg, "parse error");

            if (count < 5)
            {
              count = 0;
              for (x = (yyn < 0 ? -yyn : 0);
                   x < (sizeof(yytname) / sizeof(char *)); x++)
                if (yycheck[x + yyn] == x)
                  {
                  strcat(msg, count == 0 ? ", expecting `" : " or `");
                  strcat(msg, yytname[x]);
                  strcat(msg, "'");
                  count++;
                  }
            }
            yyerror(msg);
            free(msg);
          }
        else
          yyerror ("parse error; also virtual memory exceeded");
      }
      else
#endif /* YYERROR_VERBOSE */
      yyerror("parse error");
    }

  goto yyerrlab1;
yyerrlab1:   /* here on error raised explicitly by an action */

  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;

#if YYDEBUG != 0
      if (yydebug)
      fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

      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. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (yyn) goto yydefault;
#endif

yyerrpop:   /* pop the current state because it cannot handle the error token */

  if (yyssp == yyss) YYABORT;
  yyvsp--;
  yystate = *--yyssp;
#ifdef YYLSP_NEEDED
  yylsp--;
#endif

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

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;

#if YYDEBUG != 0
  if (yydebug)
    fprintf(stderr, "Shifting error token, ");
#endif

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

  yystate = yyn;
  goto yynewstate;
}


Generated by  Doxygen 1.6.0   Back to index