src/comerr/error_table_nt.c

   1
   2 /*  A Bison parser, made from error_table.y with Bison version GNU Bison version 1.24
   3   */
   4
   5 #define YYBISON 1  /* Identify Bison output.  */
   6
   7 #define ERROR_TABLE     258
   8 #define ERROR_CODE_ENTRY        259
   9 #define END     260
  10 #define STRING  261
  11 #define QUOTED_STRING   262
  12
  13 #line 1 "error_table.y"
  14
  15 #include <afsconfig.h>
  16 #include <afs/param.h>
  17
  18 RCSID("$Header$");
  19
  20
  21 /*
  22  * If __STDC__ is defined, function prototypes in the SunOS 5.5.1 lex
  23  * and yacc templates are visible.  We turn this on explicitly on
  24  * NT because the prototypes help supress certain warning from the
  25  * Microsoft C compiler.
  26  */
  27
  28 #ifdef AFS_NT40_ENV
  29 #include <malloc.h>
  30 # ifndef __STDC__
  31 #  define __STDC__ 1
  32 # endif
  33 #endif
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include "internal.h"
  40
  41 char *current_token = (char *)NULL;
  42 extern char *table_name;
  43
  44 char *ds(const char *string);
  45 char *quote(const char *string);
  46 void set_table_1num(char *string);
  47 int char_to_1num(char c);
  48 void add_ec(const char *name, const char *description);
  49 void add_ec_val(const char *name, const char *val, const char *description);
  50 void put_ecs(void);
  51 void set_table_num(char *string);
  52 void set_table_fun(char *astring);
  53
  54
  55 #line 38 "error_table.y"
  56 typedef union {
  57         char *dynstr;
  58 } YYSTYPE;
  59 #line 45 "error_table.y"
  60
  61
  62 #ifndef YYLTYPE
  63 typedef
  64   struct yyltype
  65     {
  66       int timestamp;
  67       int first_line;
  68       int first_column;
  69       int last_line;
  70       int last_column;
  71       char *text;
  72    }
  73   yyltype;
  74
  75 #define YYLTYPE yyltype
  76 #endif
  77
  78 #include <stdio.h>
  79
  80 #ifndef __cplusplus
  81 #ifndef __STDC__
  82 #define const
  83 #endif
  84 #endif
  85
  86
  87
  88 #define YYFINAL         24
  89 #define YYFLAG          -32768
  90 #define YYNTBASE        10
  91
  92 #define YYTRANSLATE(x) ((unsigned)(x) <= 262 ? yytranslate[x] : 18)
  93
  94 static const char yytranslate[] = {     0,
  95      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  96      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  97      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  98      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  99      2,     2,     2,     8,     2,     2,     2,     2,     2,     2,
 100      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 101      9,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 102      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 103      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 104      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 105      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 106      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 107      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 108      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 109      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 110      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 112      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 114      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 115      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 116      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 120      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
 121      6,     7
 122 };
 123
 124 #if YYDEBUG != 0
 125 static const short yyprhs[] = {     0,
 126      0,     5,     8,    10,    12,    14,    17,    19,    24,    31,
 127     33
 128 };
 129
 130 static const short yyrhs[] = {     3,
 131     11,    14,     5,     0,    12,    13,     0,    13,     0,     6,
 132      0,     6,     0,    14,    15,     0,    15,     0,     4,    16,
 133      8,    17,     0,     4,    16,     9,     6,     8,    17,     0,
 134      6,     0,     7,     0
 135 };
 136
 137 #endif
 138
 139 #if YYDEBUG != 0
 140 static const short yyrline[] = { 0,
 141     50,    56,    59,    66,    73,    79,    80,    83,    87,    95,
 142    100
 143 };
 144
 145 static const char * const yytname[] = {   "$","error","$undefined.","ERROR_TABLE",
 146 "ERROR_CODE_ENTRY","END","STRING","QUOTED_STRING","','","'='","error_table",
 147 "header","table_fun","table_id","error_codes","ec_entry","ec_name","description",
 148 ""
 149 };
 150 #endif
 151
 152 static const short yyr1[] = {     0,
 153     10,    11,    11,    12,    13,    14,    14,    15,    15,    16,
 154     17
 155 };
 156
 157 static const short yyr2[] = {     0,
 158      4,     2,     1,     1,     1,     2,     1,     4,     6,     1,
 159      1
 160 };
 161
 162 static const short yydefact[] = {     0,
 163      0,     4,     0,     0,     3,     0,     0,     7,     5,     2,
 164     10,     0,     1,     6,     0,     0,    11,     8,     0,     0,
 165      9,     0,     0,     0
 166 };
 167
 168 static const short yydefgoto[] = {    22,
 169      3,     4,     5,     7,     8,    12,    18
 170 };
 171
 172 static const short yypact[] = {     1,
 173     -1,     2,     3,     4,-32768,     5,    -4,-32768,-32768,-32768,
 174 -32768,    -6,-32768,-32768,     6,     8,-32768,-32768,     0,     6,
 175 -32768,     9,    12,-32768
 176 };
 177
 178 static const short yypgoto[] = {-32768,
 179 -32768,-32768,    11,-32768,    10,-32768,    -2
 180 };
 181
 182
 183 #define YYLAST          18
 184
 185
 186 static const short yytable[] = {     6,
 187     13,    15,    16,     1,     2,    -5,     6,    20,    23,     9,
 188     11,    24,    17,    19,    10,     0,    14,    21
 189 };
 190
 191 static const short yycheck[] = {     4,
 192      5,     8,     9,     3,     6,     4,     4,     8,     0,     6,
 193      6,     0,     7,     6,     4,    -1,     7,    20
 194 };
 195 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 196 #line 3 "bison.simple"
 197
 198 /* Skeleton output parser for bison,
 199    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 200
 201    This program is free software; you can redistribute it and/or modify
 202    it under the terms of the GNU General Public License as published by
 203    the Free Software Foundation; either version 2, or (at your option)
 204    any later version.
 205
 206    This program is distributed in the hope that it will be useful,
 207    but WITHOUT ANY WARRANTY; without even the implied warranty of
 208    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 209    GNU General Public License for more details.
 210
 211    You should have received a copy of the GNU General Public License
 212    along with this program; if not, write to the Free Software
 213    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 214
 215 /* As a special exception, when this file is copied by Bison into a
 216    Bison output file, you may use that output file without restriction.
 217    This special exception was added by the Free Software Foundation
 218    in version 1.24 of Bison.  */
 219
 220 #ifndef alloca
 221 #ifdef __GNUC__
 222 #define alloca __builtin_alloca
 223 #else /* not GNU C.  */
 224 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
 225 #include <alloca.h>
 226 #else /* not sparc */
 227 #if defined (MSDOS) && !defined (__TURBOC__)
 228 #include <malloc.h>
 229 #else /* not MSDOS, or __TURBOC__ */
 230 #if defined(_AIX)
 231 #include <malloc.h>
 232  #pragma alloca
 233 #else /* not MSDOS, __TURBOC__, or _AIX */
 234 #ifdef __hpux
 235 #ifdef __cplusplus
 236 extern "C" {
 237 void *alloca (unsigned int);
 238 };
 239 #else /* not __cplusplus */
 240 void *alloca ();
 241 #endif /* not __cplusplus */
 242 #endif /* __hpux */
 243 #endif /* not _AIX */
 244 #endif /* not MSDOS, or __TURBOC__ */
 245 #endif /* not sparc.  */
 246 #endif /* not GNU C.  */
 247 #endif /* alloca not defined.  */
 248
 249 /* This is the parser code that is written into each bison parser
 250   when the %semantic_parser declaration is not specified in the grammar.
 251   It was written by Richard Stallman by simplifying the hairy parser
 252   used when %semantic_parser is specified.  */
 253
 254 /* Note: there must be only one dollar sign in this file.
 255    It is replaced by the list of actions, each action
 256    as one case of the switch.  */
 257
 258 #define yyerrok         (yyerrstatus = 0)
 259 #define yyclearin       (yychar = YYEMPTY)
 260 #define YYEMPTY         -2
 261 #define YYEOF           0
 262 #define YYACCEPT        return(0)
 263 #define YYABORT         return(1)
 264 #define YYERROR         goto yyerrlab1
 265 /* Like YYERROR except do call yyerror.
 266    This remains here temporarily to ease the
 267    transition to the new meaning of YYERROR, for GCC.
 268    Once GCC version 2 has supplanted version 1, this can go.  */
 269 #define YYFAIL          goto yyerrlab
 270 #define YYRECOVERING()  (!!yyerrstatus)
 271 #define YYBACKUP(token, value) \
 272 do                                                              \
 273   if (yychar == YYEMPTY && yylen == 1)                          \
 274     { yychar = (token), yylval = (value);                       \
 275       yychar1 = YYTRANSLATE (yychar);                           \
 276       YYPOPSTACK;                                               \
 277       goto yybackup;                                            \
 278     }                                                           \
 279   else                                                          \
 280     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 281 while (0)
 282
 283 #define YYTERROR        1
 284 #define YYERRCODE       256
 285
 286 #ifndef YYPURE
 287 #define YYLEX           yylex()
 288 #endif
 289
 290 #ifdef YYPURE
 291 #ifdef YYLSP_NEEDED
 292 #ifdef YYLEX_PARAM
 293 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 294 #else
 295 #define YYLEX           yylex(&yylval, &yylloc)
 296 #endif
 297 #else /* not YYLSP_NEEDED */
 298 #ifdef YYLEX_PARAM
 299 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 300 #else
 301 #define YYLEX           yylex(&yylval)
 302 #endif
 303 #endif /* not YYLSP_NEEDED */
 304 #endif
 305
 306 /* If nonreentrant, generate the variables here */
 307
 308 #ifndef YYPURE
 309
 310 int     yychar;                 /*  the lookahead symbol                */
 311 YYSTYPE yylval;                 /*  the semantic value of the           */
 312                                 /*  lookahead symbol                    */
 313
 314 #ifdef YYLSP_NEEDED
 315 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 316                                 /*  symbol                              */
 317 #endif
 318
 319 int yynerrs;                    /*  number of parse errors so far       */
 320 #endif  /* not YYPURE */
 321
 322 #if YYDEBUG != 0
 323 int yydebug;                    /*  nonzero means print parse trace     */
 324 /* Since this is uninitialized, it does not stop multiple parsers
 325    from coexisting.  */
 326 #endif
 327
 328 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 329
 330 #ifndef YYINITDEPTH
 331 #define YYINITDEPTH 200
 332 #endif
 333
 334 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 335     (effective only if the built-in stack extension method is used).  */
 336
 337 #if YYMAXDEPTH == 0
 338 #undef YYMAXDEPTH
 339 #endif
 340
 341 #ifndef YYMAXDEPTH
 342 #define YYMAXDEPTH 10000
 343 #endif
 344
 345 /* Prevent warning if -Wstrict-prototypes.  */
 346 #ifdef __GNUC__
 347 int yyparse (void);
 348 #endif
 349 \f
 350 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 351 #define __yy_memcpy(FROM,TO,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 352 #else                           /* not GNU C or C++ */
 353 #ifndef __cplusplus
 354
 355 /* This is the most reliable way to avoid incompatibilities
 356    in available built-in functions on various systems.  */
 357 static void
 358 __yy_memcpy (from, to, count)
 359      char *from;
 360      char *to;
 361      int count;
 362 {
 363   register char *f = from;
 364   register char *t = to;
 365   register int i = count;
 366
 367   while (i-- > 0)
 368     *t++ = *f++;
 369 }
 370
 371 #else /* __cplusplus */
 372
 373 /* This is the most reliable way to avoid incompatibilities
 374    in available built-in functions on various systems.  */
 375 static void
 376 __yy_memcpy (char *from, char *to, int count)
 377 {
 378   register char *f = from;
 379   register char *t = to;
 380   register int i = count;
 381
 382   while (i-- > 0)
 383     *t++ = *f++;
 384 }
 385
 386 #endif
 387 #endif
 388 \f
 389 #line 192 "bison.simple"
 390
 391 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 392    into yyparse.  The argument should have type void *.
 393    It should actually point to an object.
 394    Grammar actions can access the variable by casting it
 395    to the proper pointer type.  */
 396
 397 #ifdef YYPARSE_PARAM
 398 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 399 #else
 400 #define YYPARSE_PARAM
 401 #define YYPARSE_PARAM_DECL
 402 #endif
 403
 404 int
 405 yyparse(YYPARSE_PARAM)
 406      YYPARSE_PARAM_DECL
 407 {
 408   register int yystate;
 409   register int yyn;
 410   register short *yyssp;
 411   register YYSTYPE *yyvsp;
 412   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
 413   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
 414
 415   short yyssa[YYINITDEPTH];     /*  the state stack                     */
 416   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
 417
 418   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
 419   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
 420
 421 #ifdef YYLSP_NEEDED
 422   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
 423   YYLTYPE *yyls = yylsa;
 424   YYLTYPE *yylsp;
 425
 426 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 427 #else
 428 #define YYPOPSTACK   (yyvsp--, yyssp--)
 429 #endif
 430
 431   int yystacksize = YYINITDEPTH;
 432
 433 #ifdef YYPURE
 434   int yychar;
 435   YYSTYPE yylval;
 436   int yynerrs;
 437 #ifdef YYLSP_NEEDED
 438   YYLTYPE yylloc;
 439 #endif
 440 #endif
 441
 442   YYSTYPE yyval;                /*  the variable used to return         */
 443                                 /*  semantic values from the action     */
 444                                 /*  routines                            */
 445
 446   int yylen;
 447
 448 #if YYDEBUG != 0
 449   if (yydebug)
 450     fprintf(stderr, "Starting parse\n");
 451 #endif
 452
 453   yystate = 0;
 454   yyerrstatus = 0;
 455   yynerrs = 0;
 456   yychar = YYEMPTY;             /* Cause a token to be read.  */
 457
 458   /* Initialize stack pointers.
 459      Waste one element of value and location stack
 460      so that they stay on the same level as the state stack.
 461      The wasted elements are never initialized.  */
 462
 463   yyssp = yyss - 1;
 464   yyvsp = yyvs;
 465 #ifdef YYLSP_NEEDED
 466   yylsp = yyls;
 467 #endif
 468
 469 /* Push a new state, which is found in  yystate  .  */
 470 /* In all cases, when you get here, the value and location stacks
 471    have just been pushed. so pushing a state here evens the stacks.  */
 472 yynewstate:
 473
 474   *++yyssp = yystate;
 475
 476   if (yyssp >= yyss + yystacksize - 1)
 477     {
 478       /* Give user a chance to reallocate the stack */
 479       /* Use copies of these so that the &'s don't force the real ones into memory. */
 480       YYSTYPE *yyvs1 = yyvs;
 481       short *yyss1 = yyss;
 482 #ifdef YYLSP_NEEDED
 483       YYLTYPE *yyls1 = yyls;
 484 #endif
 485
 486       /* Get the current used size of the three stacks, in elements.  */
 487       int size = yyssp - yyss + 1;
 488
 489 #ifdef yyoverflow
 490       /* Each stack pointer address is followed by the size of
 491          the data in use in that stack, in bytes.  */
 492 #ifdef YYLSP_NEEDED
 493       /* This used to be a conditional around just the two extra args,
 494          but that might be undefined if yyoverflow is a macro.  */
 495       yyoverflow("parser stack overflow",
 496                  &yyss1, size * sizeof (*yyssp),
 497                  &yyvs1, size * sizeof (*yyvsp),
 498                  &yyls1, size * sizeof (*yylsp),
 499                  &yystacksize);
 500 #else
 501       yyoverflow("parser stack overflow",
 502                  &yyss1, size * sizeof (*yyssp),
 503                  &yyvs1, size * sizeof (*yyvsp),
 504                  &yystacksize);
 505 #endif
 506
 507       yyss = yyss1; yyvs = yyvs1;
 508 #ifdef YYLSP_NEEDED
 509       yyls = yyls1;
 510 #endif
 511 #else /* no yyoverflow */
 512       /* Extend the stack our own way.  */
 513       if (yystacksize >= YYMAXDEPTH)
 514         {
 515           yyerror("parser stack overflow");
 516           return 2;
 517         }
 518       yystacksize *= 2;
 519       if (yystacksize > YYMAXDEPTH)
 520         yystacksize = YYMAXDEPTH;
 521       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
 522       __yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
 523       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
 524       __yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
 525 #ifdef YYLSP_NEEDED
 526       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
 527       __yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
 528 #endif
 529 #endif /* no yyoverflow */
 530
 531       yyssp = yyss + size - 1;
 532       yyvsp = yyvs + size - 1;
 533 #ifdef YYLSP_NEEDED
 534       yylsp = yyls + size - 1;
 535 #endif
 536
 537 #if YYDEBUG != 0
 538       if (yydebug)
 539         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 540 #endif
 541
 542       if (yyssp >= yyss + yystacksize - 1)
 543         YYABORT;
 544     }
 545
 546 #if YYDEBUG != 0
 547   if (yydebug)
 548     fprintf(stderr, "Entering state %d\n", yystate);
 549 #endif
 550
 551   goto yybackup;
 552  yybackup:
 553
 554 /* Do appropriate processing given the current state.  */
 555 /* Read a lookahead token if we need one and don't already have one.  */
 556 /* yyresume: */
 557
 558   /* First try to decide what to do without reference to lookahead token.  */
 559
 560   yyn = yypact[yystate];
 561   if (yyn == YYFLAG)
 562     goto yydefault;
 563
 564   /* Not known => get a lookahead token if don't already have one.  */
 565
 566   /* yychar is either YYEMPTY or YYEOF
 567      or a valid token in external form.  */
 568
 569   if (yychar == YYEMPTY)
 570     {
 571 #if YYDEBUG != 0
 572       if (yydebug)
 573         fprintf(stderr, "Reading a token: ");
 574 #endif
 575       yychar = YYLEX;
 576     }
 577
 578   /* Convert token to internal form (in yychar1) for indexing tables with */
 579
 580   if (yychar <= 0)              /* This means end of input. */
 581     {
 582       yychar1 = 0;
 583       yychar = YYEOF;           /* Don't call YYLEX any more */
 584
 585 #if YYDEBUG != 0
 586       if (yydebug)
 587         fprintf(stderr, "Now at end of input.\n");
 588 #endif
 589     }
 590   else
 591     {
 592       yychar1 = YYTRANSLATE(yychar);
 593
 594 #if YYDEBUG != 0
 595       if (yydebug)
 596         {
 597           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 598           /* Give the individual parser a way to print the precise meaning
 599              of a token, for further debugging info.  */
 600 #ifdef YYPRINT
 601           YYPRINT (stderr, yychar, yylval);
 602 #endif
 603           fprintf (stderr, ")\n");
 604         }
 605 #endif
 606     }
 607
 608   yyn += yychar1;
 609   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 610     goto yydefault;
 611
 612   yyn = yytable[yyn];
 613
 614   /* yyn is what to do for this token type in this state.
 615      Negative => reduce, -yyn is rule number.
 616      Positive => shift, yyn is new state.
 617        New state is final state => don't bother to shift,
 618        just return success.
 619      0, or most negative number => error.  */
 620
 621   if (yyn < 0)
 622     {
 623       if (yyn == YYFLAG)
 624         goto yyerrlab;
 625       yyn = -yyn;
 626       goto yyreduce;
 627     }
 628   else if (yyn == 0)
 629     goto yyerrlab;
 630
 631   if (yyn == YYFINAL)
 632     YYACCEPT;
 633
 634   /* Shift the lookahead token.  */
 635
 636 #if YYDEBUG != 0
 637   if (yydebug)
 638     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 639 #endif
 640
 641   /* Discard the token being shifted unless it is eof.  */
 642   if (yychar != YYEOF)
 643     yychar = YYEMPTY;
 644
 645   *++yyvsp = yylval;
 646 #ifdef YYLSP_NEEDED
 647   *++yylsp = yylloc;
 648 #endif
 649
 650   /* count tokens shifted since error; after three, turn off error status.  */
 651   if (yyerrstatus) yyerrstatus--;
 652
 653   yystate = yyn;
 654   goto yynewstate;
 655
 656 /* Do the default action for the current state.  */
 657 yydefault:
 658
 659   yyn = yydefact[yystate];
 660   if (yyn == 0)
 661     goto yyerrlab;
 662
 663 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 664 yyreduce:
 665   yylen = yyr2[yyn];
 666   if (yylen > 0)
 667     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 668
 669 #if YYDEBUG != 0
 670   if (yydebug)
 671     {
 672       int i;
 673
 674       fprintf (stderr, "Reducing via rule %d (line %d), ",
 675                yyn, yyrline[yyn]);
 676
 677       /* Print the symbols being reduced, and their result.  */
 678       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 679         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 680       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 681     }
 682 #endif
 683
 684
 685   switch (yyn) {
 686
 687 case 1:
 688 #line 51 "error_table.y"
 689 { table_name = ds(yyvsp[-2].dynstr);
 690                           current_token = table_name;
 691                           put_ecs(); ;
 692     break;}
 693 case 2:
 694 #line 57 "error_table.y"
 695 { current_token = yyvsp[-1].dynstr;
 696                           yyval.dynstr = yyvsp[0].dynstr; ;
 697     break;}
 698 case 3:
 699 #line 60 "error_table.y"
 700 { current_token = yyvsp[0].dynstr;
 701                           set_table_fun(ds("1"));
 702                           yyval.dynstr = yyvsp[0].dynstr;
 703                         ;
 704     break;}
 705 case 4:
 706 #line 67 "error_table.y"
 707 { current_token = yyvsp[0].dynstr;
 708                           set_table_fun(yyvsp[0].dynstr);
 709                           yyval.dynstr = yyvsp[0].dynstr; ;
 710     break;}
 711 case 5:
 712 #line 74 "error_table.y"
 713 { current_token = yyvsp[0].dynstr;
 714                           set_table_num(yyvsp[0].dynstr);
 715                           yyval.dynstr = yyvsp[0].dynstr; ;
 716     break;}
 717 case 8:
 718 #line 84 "error_table.y"
 719 { add_ec(yyvsp[-2].dynstr, yyvsp[0].dynstr);
 720                           free(yyvsp[-2].dynstr);
 721                           free(yyvsp[0].dynstr); ;
 722     break;}
 723 case 9:
 724 #line 88 "error_table.y"
 725 { add_ec_val(yyvsp[-4].dynstr, yyvsp[-2].dynstr, yyvsp[0].dynstr);
 726                           free(yyvsp[-4].dynstr);
 727                           free(yyvsp[-2].dynstr);
 728                           free(yyvsp[0].dynstr);
 729                         ;
 730     break;}
 731 case 10:
 732 #line 96 "error_table.y"
 733 { yyval.dynstr = ds(yyvsp[0].dynstr);
 734                           current_token = yyval.dynstr; ;
 735     break;}
 736 case 11:
 737 #line 101 "error_table.y"
 738 { yyval.dynstr = ds(yyvsp[0].dynstr);
 739                           current_token = yyval.dynstr; ;
 740     break;}
 741 }
 742    /* the action file gets copied in in place of this dollarsign */
 743 #line 487 "bison.simple"
 744 \f
 745   yyvsp -= yylen;
 746   yyssp -= yylen;
 747 #ifdef YYLSP_NEEDED
 748   yylsp -= yylen;
 749 #endif
 750
 751 #if YYDEBUG != 0
 752   if (yydebug)
 753     {
 754       short *ssp1 = yyss - 1;
 755       fprintf (stderr, "state stack now");
 756       while (ssp1 != yyssp)
 757         fprintf (stderr, " %d", *++ssp1);
 758       fprintf (stderr, "\n");
 759     }
 760 #endif
 761
 762   *++yyvsp = yyval;
 763
 764 #ifdef YYLSP_NEEDED
 765   yylsp++;
 766   if (yylen == 0)
 767     {
 768       yylsp->first_line = yylloc.first_line;
 769       yylsp->first_column = yylloc.first_column;
 770       yylsp->last_line = (yylsp-1)->last_line;
 771       yylsp->last_column = (yylsp-1)->last_column;
 772       yylsp->text = 0;
 773     }
 774   else
 775     {
 776       yylsp->last_line = (yylsp+yylen-1)->last_line;
 777       yylsp->last_column = (yylsp+yylen-1)->last_column;
 778     }
 779 #endif
 780
 781   /* Now "shift" the result of the reduction.
 782      Determine what state that goes to,
 783      based on the state we popped back to
 784      and the rule number reduced by.  */
 785
 786   yyn = yyr1[yyn];
 787
 788   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
 789   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 790     yystate = yytable[yystate];
 791   else
 792     yystate = yydefgoto[yyn - YYNTBASE];
 793
 794   goto yynewstate;
 795
 796 yyerrlab:   /* here on detecting error */
 797
 798   if (! yyerrstatus)
 799     /* If not already recovering from an error, report this error.  */
 800     {
 801       ++yynerrs;
 802
 803 #ifdef YYERROR_VERBOSE
 804       yyn = yypact[yystate];
 805
 806       if (yyn > YYFLAG && yyn < YYLAST)
 807         {
 808           int size = 0;
 809           char *msg;
 810           int x, count;
 811
 812           count = 0;
 813           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
 814           for (x = (yyn < 0 ? -yyn : 0);
 815                x < (sizeof(yytname) / sizeof(char *)); x++)
 816             if (yycheck[x + yyn] == x)
 817               size += strlen(yytname[x]) + 15, count++;
 818           msg = (char *) malloc(size + 15);
 819           if (msg != 0)
 820             {
 821               strcpy(msg, "parse error");
 822
 823               if (count < 5)
 824                 {
 825                   count = 0;
 826                   for (x = (yyn < 0 ? -yyn : 0);
 827                        x < (sizeof(yytname) / sizeof(char *)); x++)
 828                     if (yycheck[x + yyn] == x)
 829                       {
 830                         strcat(msg, count == 0 ? ", expecting `" : " or `");
 831                         strcat(msg, yytname[x]);
 832                         strcat(msg, "'");
 833                         count++;
 834                       }
 835                 }
 836               yyerror(msg);
 837               free(msg);
 838             }
 839           else
 840             yyerror ("parse error; also virtual memory exceeded");
 841         }
 842       else
 843 #endif /* YYERROR_VERBOSE */
 844         yyerror("parse error");
 845     }
 846
 847   goto yyerrlab1;
 848 yyerrlab1:   /* here on error raised explicitly by an action */
 849
 850   if (yyerrstatus == 3)
 851     {
 852       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
 853
 854       /* return failure if at end of input */
 855       if (yychar == YYEOF)
 856         YYABORT;
 857
 858 #if YYDEBUG != 0
 859       if (yydebug)
 860         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
 861 #endif
 862
 863       yychar = YYEMPTY;
 864     }
 865
 866   /* Else will try to reuse lookahead token
 867      after shifting the error token.  */
 868
 869   yyerrstatus = 3;              /* Each real token shifted decrements this */
 870
 871   goto yyerrhandle;
 872
 873 yyerrdefault:  /* current state does not do anything special for the error token. */
 874
 875 #if 0
 876   /* This is wrong; only states that explicitly want error tokens
 877      should shift them.  */
 878   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
 879   if (yyn) goto yydefault;
 880 #endif
 881
 882 yyerrpop:   /* pop the current state because it cannot handle the error token */
 883
 884   if (yyssp == yyss) YYABORT;
 885   yyvsp--;
 886   yystate = *--yyssp;
 887 #ifdef YYLSP_NEEDED
 888   yylsp--;
 889 #endif
 890
 891 #if YYDEBUG != 0
 892   if (yydebug)
 893     {
 894       short *ssp1 = yyss - 1;
 895       fprintf (stderr, "Error: state stack now");
 896       while (ssp1 != yyssp)
 897         fprintf (stderr, " %d", *++ssp1);
 898       fprintf (stderr, "\n");
 899     }
 900 #endif
 901
 902 yyerrhandle:
 903
 904   yyn = yypact[yystate];
 905   if (yyn == YYFLAG)
 906     goto yyerrdefault;
 907
 908   yyn += YYTERROR;
 909   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
 910     goto yyerrdefault;
 911
 912   yyn = yytable[yyn];
 913   if (yyn < 0)
 914     {
 915       if (yyn == YYFLAG)
 916         goto yyerrpop;
 917       yyn = -yyn;
 918       goto yyreduce;
 919     }
 920   else if (yyn == 0)
 921     goto yyerrpop;
 922
 923   if (yyn == YYFINAL)
 924     YYACCEPT;
 925
 926 #if YYDEBUG != 0
 927   if (yydebug)
 928     fprintf(stderr, "Shifting error token, ");
 929 #endif
 930
 931   *++yyvsp = yylval;
 932 #ifdef YYLSP_NEEDED
 933   *++yylsp = yylloc;
 934 #endif
 935
 936   yystate = yyn;
 937   goto yynewstate;
 938 }
 939 #line 105 "error_table.y"
 940
 941 /*
 942  *
 943  * Copyright 1986, 1987 by the MIT Student Information Processing Board
 944  *
 945  * For copyright info, see mit-sipb-cr.h.
 946  */
 947 #ifndef AFS_NT40_ENV
 948 #include <unistd.h>
 949 #endif
 950 #include <afs/param.h>
 951 #include <string.h>
 952 #include <assert.h>
 953 #include <ctype.h>
 954 #ifdef AFS_NT40_ENV
 955 #include <sys/types.h>
 956 #include <afs/afsutil.h>
 957 #else
 958 #include <sys/time.h>
 959 #endif
 960 #include <sys/timeb.h>
 961 #include "error_table.h"
 962 #include "mit-sipb-cr.h"
 963 #include <stdio.h>
 964
 965 /*
 966  * Copyright 2000, International Business Machines Corporation and others.
 967  * All Rights Reserved.
 968  *
 969  * This software has been released under the terms of the IBM Public
 970  * License.  For details, see the LICENSE file in the top-level source
 971  * directory or online at http://www.openafs.org/dl/license10.html
 972  */
 973
 974 extern FILE *hfile, *cfile, *msfile;
 975 extern int use_msf;
 976
 977 static afs_int32 gensym_n = 0;
 978
 979 char *gensym(const char *x)
 980 {
 981         char *symbol;
 982         if (!gensym_n) {
 983                 struct timeval tv;
 984                 gettimeofday(&tv, (void *)0);
 985                 gensym_n = (tv.tv_sec%10000)*100 + tv.tv_usec/10000;
 986         }
 987         symbol = (char *)malloc(32 * sizeof(char));
 988         gensym_n++;
 989         sprintf(symbol, "et%ld", gensym_n);
 990         return(symbol);
 991 }
 992
 993 char *
 994 ds(const char *string)
 995 {
 996         char *rv;
 997         rv = (char *)malloc(strlen(string)+1);
 998         strcpy(rv, string);
 999         return(rv);
1000 }
1001
1002 char *
1003 quote(const char *string)
1004 {
1005         char *rv;
1006         rv = (char *)malloc(strlen(string)+3);
1007         strcpy(rv, "\"");
1008         strcat(rv, string);
1009         strcat(rv, "\"");
1010         return(rv);
1011 }
1012
1013 afs_int32 table_number = 0;
1014 int current = 0;
1015 char **error_codes = (char **)NULL;
1016
1017 void add_ec(const char *name, const char *description)
1018 {
1019         if (msfile) {
1020             if (current > 0)
1021 #ifndef sun
1022                 fprintf(msfile, "%d\t%s\n", current, description);
1023 #else
1024                 fprintf(msfile, "%d %s\n", current, description);
1025 #endif /* !sun */
1026         } else {
1027             fprintf(cfile, "\t\"%s\",\n", description);
1028         }
1029         if (error_codes == (char **)NULL) {
1030                 error_codes = (char **)malloc(sizeof(char *));
1031                 *error_codes = (char *)NULL;
1032         }
1033         error_codes = (char **)realloc((char *)error_codes,
1034                                        (current + 2)*sizeof(char *));
1035         error_codes[current++] = ds(name);
1036         error_codes[current] = (char *)NULL;
1037 }
1038
1039 void add_ec_val(const char *name, const char *val, const char *description)
1040 {
1041         const int ncurrent = atoi(val);
1042         if (ncurrent < current) {
1043                 printf("Error code %s (%d) out of order", name,
1044                        current);
1045                 return;
1046         }
1047
1048         while (ncurrent > current) {
1049              if (!msfile)
1050                  fputs("\t(char *)NULL,\n", cfile);
1051              current++;
1052          }
1053         if (msfile) {
1054             if (current > 0)
1055 #ifndef sun
1056                 fprintf(msfile, "%d\t%s\n", current, description);
1057 #else
1058                 fprintf(msfile, "%d %s\n", current, description);
1059 #endif /* ! sun */
1060         } else {
1061             fprintf(cfile, "\t\"%s\",\n", description);
1062         }
1063         if (error_codes == (char **)NULL) {
1064                 error_codes = (char **)malloc(sizeof(char *));
1065                 *error_codes = (char *)NULL;
1066         }
1067         error_codes = (char **)realloc((char *)error_codes,
1068                                        (current + 2)*sizeof(char *));
1069         error_codes[current++] = ds(name);
1070         error_codes[current] = (char *)NULL;
1071 }
1072
1073 void put_ecs(void)
1074 {
1075         int i;
1076         for (i = 0; i < current; i++) {
1077              if (error_codes[i] != (char *)NULL)
1078                   fprintf(hfile, "#define %-40s (%ldL)\n",
1079                           error_codes[i], table_number + i);
1080         }
1081 }
1082
1083 /*
1084  * char_to_num -- maps letters and numbers into a small numbering space
1085  *      uppercase ->  1-26
1086  *      lowercase -> 27-52
1087  *      digits    -> 53-62
1088  *      underscore-> 63
1089  */
1090
1091 static const char char_set[] =
1092         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
1093
1094 int char_to_num(char c)
1095 {
1096         const char *where;
1097         int diff;
1098
1099         where = strchr (char_set, c);
1100         if (where) {
1101                 diff = where - char_set + 1;
1102                 assert (diff < (1 << ERRCODE_RANGE));
1103                 return diff;
1104         }
1105         else if (isprint (c))
1106                 fprintf (stderr,
1107                          "Illegal character `%c' in error table name\n",
1108                          c);
1109         else
1110                 fprintf (stderr,
1111                          "Illegal character %03o in error table name\n",
1112                          c);
1113         exit (1);
1114 }
1115
1116 void set_table_num(char *string)
1117 {
1118         if (msfile) {
1119             set_table_1num(string);
1120             return;
1121         }
1122         if (strlen(string) > 4) {
1123                 fprintf(stderr, "Table name %s too long, truncated ",
1124                         string);
1125                 string[4] = '\0';
1126                 fprintf(stderr, "to %s\n", string);
1127         }
1128         if (char_to_num (string[0]) > char_to_num ('z')) {
1129                 fprintf (stderr, "%s%s%s%s",
1130                          "First character of error table name must be ",
1131                          "a letter; name ``",
1132                          string, "'' rejected\n");
1133                 exit (1);
1134         }
1135         while (*string != '\0') {
1136                 table_number = (table_number << BITS_PER_CHAR)
1137                         + char_to_num(*string);
1138                 string++;
1139         }
1140         table_number = table_number << ERRCODE_RANGE;
1141 }
1142
1143 void set_table_fun(char *astring)
1144 {
1145     register char *tp;
1146     unsigned int tc;
1147
1148     for(tp=astring; (tc = *tp) != 0; tp++) {
1149         if (!isdigit(tc)) {
1150             fprintf(stderr, "Table function '%s' must be a decimal integer.\n",
1151                     astring);
1152             exit(1);
1153         }
1154     }
1155     if (msfile)
1156         table_number += (atoi(astring)) << 28;
1157 }
1158
1159 /* for compatibility with old comerr's, we truncate package name to 4
1160  * characters, but only store first 3 in the error code.  Note that this
1161  * function, as a side effect, truncates the table name down to 4 chars.
1162  */
1163 void set_table_1num(char *string)
1164 {
1165         afs_int32 temp;
1166         int ctr;
1167
1168         if ((temp = strlen(string)) > 4) {
1169                 fprintf(stderr, "Table name %s too long, truncated ",
1170                         string);
1171                 string[4] = '\0';
1172                 fprintf(stderr, "to %s\n", string);
1173         }
1174         if (temp == 4) {
1175             fprintf(stderr, "Table name %s too long, only 3 characters fit in error code.\n",
1176                     string);
1177         }
1178         if (char_to_1num (string[0]) > char_to_1num ('z')) {
1179                 fprintf (stderr, "%s%s%s%s",
1180                          "First character of error table name must be ",
1181                          "a letter; name ``",
1182                          string, "'' rejected\n");
1183                 exit (1);
1184         }
1185         temp = 0;
1186         for(ctr=0; ctr < 3; ctr++) {            /* copy at most 3 chars to integer */
1187             if (*string == '\0') break;         /* and watch for early end */
1188             temp = (temp * 050)                 /* "radix fifty" is base 050 = 40 */
1189                 + char_to_1num(*string);
1190             string++;
1191         }
1192         table_number += temp << 12;
1193 }
1194
1195 /*
1196  * char_to_num -- maps letters and numbers into very small space
1197  *      0-9        -> 0-9
1198  *      mixed case -> 10-35
1199  *      _          -> 36
1200  *      others are reserved
1201  */
1202
1203 static const char char_1set[] =
1204         "abcdefghijklmnopqrstuvwxyz_0123456789";
1205
1206 int char_to_1num(char c)
1207 {
1208         const char *where;
1209         int diff;
1210
1211         if (isupper(c)) c = tolower(c);
1212
1213         where = strchr (char_1set, c);
1214         if (where) {
1215                 /* start at 1 so we can decode */
1216                 diff = where - char_1set;
1217                 assert (diff < 050);    /* it is radix 50, after all */
1218                 return diff;
1219         }
1220         else if (isprint (c))
1221                 fprintf (stderr,
1222                          "Illegal character `%c' in error table name\n",
1223                          c);
1224         else
1225                 fprintf (stderr,
1226                          "Illegal character %03o in error table name\n",
1227                          c);
1228         exit (1);
1229 }
1230
1231 #ifdef AFS_NT40_ENV
1232 #include "et_lex.lex_nt.c"
1233 #else
1234 #include "et_lex.lex.c"
1235 #endif