home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gettext-0.10.24-src.tgz / tar.out / fsf / gettext / src / po-hash.gen.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  28KB  |  1,023 lines
  1.  
  2. /*  A Bison parser, made from ../../src/po-hash.y
  3.  by  GNU Bison version 1.25
  4.   */
  5.  
  6. #define po_hash_BISON 1  /* Identify Bison output.  */
  7.  
  8. #define    STRING    258
  9. #define    NUMBER    259
  10. #define    COLON    260
  11. #define    COMMA    261
  12. #define    FILE_KEYWORD    262
  13. #define    LINE_KEYWORD    263
  14. #define    NUMBER_KEYWORD    264
  15.  
  16. #line 20 "../../src/po-hash.y"
  17.  
  18.  
  19. #ifdef HAVE_CONFIG_H
  20. # include "config.h"
  21. #endif
  22.  
  23. #include <stdio.h>
  24.  
  25. #include <system.h>
  26. #include "po-hash.h"
  27. #include "po.h"
  28.  
  29.  
  30. #line 42 "../../src/po-hash.y"
  31. typedef union
  32. {
  33.   char *string;
  34.   int number;
  35. } po_hash_STYPE;
  36. #line 51 "../../src/po-hash.y"
  37.  
  38.  
  39. static const char *cur;
  40.  
  41.  
  42. void po_hash_error PARAMS ((char *));
  43. int po_hash_lex PARAMS ((void));
  44.  
  45.  
  46. int
  47. po_hash (s)
  48.      const char *s;
  49. {
  50.   extern int po_hash_parse PARAMS ((void));
  51.  
  52.   cur = s;
  53.   return po_hash_parse ();
  54. }
  55.  
  56.  
  57. void
  58. po_hash_error (s)
  59.      char *s;
  60. {
  61.   /* Do nothing, the grammar is used as a recogniser.  */
  62. }
  63. #include <stdio.h>
  64.  
  65. #ifndef __cplusplus
  66. #ifndef __STDC__
  67. #define const
  68. #endif
  69. #endif
  70.  
  71.  
  72.  
  73. #define    po_hash_FINAL        18
  74. #define    po_hash_FLAG        -32768
  75. #define    po_hash_NTBASE    10
  76.  
  77. #define po_hash_TRANSLATE(x) ((unsigned)(x) <= 264 ? po_hash_translate[x] : 12)
  78.  
  79. static const char po_hash_translate[] = {     0,
  80.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  81.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  82.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  83.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  84.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  85.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  86.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  87.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  88.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  89.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  90.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  91.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  92.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  93.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  94.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  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,     2,     2,     2,     2,     2,     2,     2,
  100.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  101.      2,     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,     1,     2,     3,     4,     5,
  106.      6,     7,     8,     9
  107. };
  108.  
  109. #if po_hash_DEBUG != 0
  110. static const short po_hash_prhs[] = {     0,
  111.      0,     1,     4,     8,    16,    25
  112. };
  113.  
  114. static const short po_hash_rhs[] = {    -1,
  115.     10,    11,     0,     3,     5,     4,     0,     7,     5,     3,
  116.      6,     8,     5,     4,     0,     7,     5,     3,     6,     8,
  117.      9,     5,     4,     0,     7,     5,     4,     0
  118. };
  119.  
  120. #endif
  121.  
  122. #if po_hash_DEBUG != 0
  123. static const short po_hash_rline[] = { 0,
  124.     82,    83,    87,    93,    99,   105
  125. };
  126. #endif
  127.  
  128.  
  129. #if po_hash_DEBUG != 0 || defined (po_hash_ERROR_VERBOSE)
  130.  
  131. static const char * const po_hash_tname[] = {   "$","error","$undefined.","STRING",
  132. "NUMBER","COLON","COMMA","FILE_KEYWORD","LINE_KEYWORD","NUMBER_KEYWORD","filepos_line",
  133. "filepos", NULL
  134. };
  135. #endif
  136.  
  137. static const short po_hash_r1[] = {     0,
  138.     10,    10,    11,    11,    11,    11
  139. };
  140.  
  141. static const short po_hash_r2[] = {     0,
  142.      0,     2,     3,     7,     8,     3
  143. };
  144.  
  145. static const short po_hash_defact[] = {     1,
  146.      0,     0,     0,     2,     0,     0,     3,     0,     6,     0,
  147.      0,     0,     0,     4,     0,     5,     0,     0
  148. };
  149.  
  150. static const short po_hash_defgoto[] = {     1,
  151.      4
  152. };
  153.  
  154. static const short po_hash_pact[] = {-32768,
  155.      0,    -3,    -1,-32768,     2,     5,-32768,     4,-32768,     3,
  156.     -4,     8,     9,-32768,    11,-32768,    13,-32768
  157. };
  158.  
  159. static const short po_hash_pgoto[] = {-32768,
  160. -32768
  161. };
  162.  
  163.  
  164. #define    po_hash_LAST        15
  165.  
  166.  
  167. static const short po_hash_table[] = {    17,
  168.     12,     5,     2,     6,    13,     7,     3,     8,     9,    10,
  169.     11,    14,    18,    15,    16
  170. };
  171.  
  172. static const short po_hash_check[] = {     0,
  173.      5,     5,     3,     5,     9,     4,     7,     3,     4,     6,
  174.      8,     4,     0,     5,     4
  175. };
  176. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  177. #line 3 "/usr/local/share/bison.simple"
  178.  
  179. /* Skeleton output parser for bison,
  180.    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
  181.  
  182.    This program is free software; you can redistribute it and/or modify
  183.    it under the terms of the GNU General Public License as published by
  184.    the Free Software Foundation; either version 2, or (at your option)
  185.    any later version.
  186.  
  187.    This program is distributed in the hope that it will be useful,
  188.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  189.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  190.    GNU General Public License for more details.
  191.  
  192.    You should have received a copy of the GNU General Public License
  193.    along with this program; if not, write to the Free Software
  194.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  195.  
  196. /* As a special exception, when this file is copied by Bison into a
  197.    Bison output file, you may use that output file without restriction.
  198.    This special exception was added by the Free Software Foundation
  199.    in version 1.24 of Bison.  */
  200.  
  201. #ifndef alloca
  202. #ifdef __GNUC__
  203. #define alloca __builtin_alloca
  204. #else /* not GNU C.  */
  205. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  206. #include <alloca.h>
  207. #else /* not sparc */
  208. #if defined (MSDOS) && !defined (__TURBOC__)
  209. #include <malloc.h>
  210. #else /* not MSDOS, or __TURBOC__ */
  211. #if defined(_AIX)
  212. #include <malloc.h>
  213.  #pragma alloca
  214. #else /* not MSDOS, __TURBOC__, or _AIX */
  215. #ifdef __hpux
  216. #ifdef __cplusplus
  217. extern "C" {
  218. void *alloca (unsigned int);
  219. };
  220. #else /* not __cplusplus */
  221. void *alloca ();
  222. #endif /* not __cplusplus */
  223. #endif /* __hpux */
  224. #endif /* not _AIX */
  225. #endif /* not MSDOS, or __TURBOC__ */
  226. #endif /* not sparc.  */
  227. #endif /* not GNU C.  */
  228. #endif /* alloca not defined.  */
  229.  
  230. /* This is the parser code that is written into each bison parser
  231.   when the %semantic_parser declaration is not specified in the grammar.
  232.   It was written by Richard Stallman by simplifying the hairy parser
  233.   used when %semantic_parser is specified.  */
  234.  
  235. /* Note: there must be only one dollar sign in this file.
  236.    It is replaced by the list of actions, each action
  237.    as one case of the switch.  */
  238.  
  239. #define po_hash_errok        (po_hash_errstatus = 0)
  240. #define po_hash_clearin    (po_hash_char = po_hash_EMPTY)
  241. #define po_hash_EMPTY        -2
  242. #define po_hash_EOF        0
  243. #define po_hash_ACCEPT    return(0)
  244. #define po_hash_ABORT     return(1)
  245. #define po_hash_ERROR        goto po_hash_errlab1
  246. /* Like po_hash_ERROR except do call po_hash_error.
  247.    This remains here temporarily to ease the
  248.    transition to the new meaning of po_hash_ERROR, for GCC.
  249.    Once GCC version 2 has supplanted version 1, this can go.  */
  250. #define po_hash_FAIL        goto po_hash_errlab
  251. #define po_hash_RECOVERING()  (!!po_hash_errstatus)
  252. #define po_hash_BACKUP(token, value) \
  253. do                                \
  254.   if (po_hash_char == po_hash_EMPTY && po_hash_len == 1)                \
  255.     { po_hash_char = (token), po_hash_lval = (value);            \
  256.       po_hash_char1 = po_hash_TRANSLATE (po_hash_char);                \
  257.       po_hash_POPSTACK;                        \
  258.       goto po_hash_backup;                        \
  259.     }                                \
  260.   else                                \
  261.     { po_hash_error ("syntax error: cannot back up"); po_hash_ERROR; }    \
  262. while (0)
  263.  
  264. #define po_hash_TERROR    1
  265. #define po_hash_ERRCODE    256
  266.  
  267. #ifndef po_hash_PURE
  268. #define po_hash_LEX        po_hash_lex()
  269. #endif
  270.  
  271. #ifdef po_hash_PURE
  272. #ifdef po_hash_LSP_NEEDED
  273. #ifdef po_hash_LEX_PARAM
  274. #define po_hash_LEX        po_hash_lex(&po_hash_lval, &po_hash_lloc, po_hash_LEX_PARAM)
  275. #else
  276. #define po_hash_LEX        po_hash_lex(&po_hash_lval, &po_hash_lloc)
  277. #endif
  278. #else /* not po_hash_LSP_NEEDED */
  279. #ifdef po_hash_LEX_PARAM
  280. #define po_hash_LEX        po_hash_lex(&po_hash_lval, po_hash_LEX_PARAM)
  281. #else
  282. #define po_hash_LEX        po_hash_lex(&po_hash_lval)
  283. #endif
  284. #endif /* not po_hash_LSP_NEEDED */
  285. #endif
  286.  
  287. /* If nonreentrant, generate the variables here */
  288.  
  289. #ifndef po_hash_PURE
  290.  
  291. int    po_hash_char;            /*  the lookahead symbol        */
  292. po_hash_STYPE    po_hash_lval;            /*  the semantic value of the        */
  293.                 /*  lookahead symbol            */
  294.  
  295. #ifdef po_hash_LSP_NEEDED
  296. po_hash_LTYPE po_hash_lloc;            /*  location data for the lookahead    */
  297.                 /*  symbol                */
  298. #endif
  299.  
  300. int po_hash_nerrs;            /*  number of parse errors so far       */
  301. #endif  /* not po_hash_PURE */
  302.  
  303. #if po_hash_DEBUG != 0
  304. int po_hash_debug;            /*  nonzero means print parse trace    */
  305. /* Since this is uninitialized, it does not stop multiple parsers
  306.    from coexisting.  */
  307. #endif
  308.  
  309. /*  po_hash_INITDEPTH indicates the initial size of the parser's stacks    */
  310.  
  311. #ifndef    po_hash_INITDEPTH
  312. #define po_hash_INITDEPTH 200
  313. #endif
  314.  
  315. /*  po_hash_MAXDEPTH is the maximum size the stacks can grow to
  316.     (effective only if the built-in stack extension method is used).  */
  317.  
  318. #if po_hash_MAXDEPTH == 0
  319. #undef po_hash_MAXDEPTH
  320. #endif
  321.  
  322. #ifndef po_hash_MAXDEPTH
  323. #define po_hash_MAXDEPTH 10000
  324. #endif
  325.  
  326. /* Prevent warning if -Wstrict-prototypes.  */
  327. #ifdef __GNUC__
  328. int po_hash_parse (void);
  329. #endif
  330.  
  331. #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
  332. #define __po_hash__memcpy(TO,FROM,COUNT)    __builtin_memcpy(TO,FROM,COUNT)
  333. #else                /* not GNU C or C++ */
  334. #ifndef __cplusplus
  335.  
  336. /* This is the most reliable way to avoid incompatibilities
  337.    in available built-in functions on various systems.  */
  338. static void
  339. __po_hash__memcpy (to, from, count)
  340.      char *to;
  341.      char *from;
  342.      int count;
  343. {
  344.   register char *f = from;
  345.   register char *t = to;
  346.   register int i = count;
  347.  
  348.   while (i-- > 0)
  349.     *t++ = *f++;
  350. }
  351.  
  352. #else /* __cplusplus */
  353.  
  354. /* This is the most reliable way to avoid incompatibilities
  355.    in available built-in functions on various systems.  */
  356. static void
  357. __po_hash__memcpy (char *to, char *from, int count)
  358. {
  359.   register char *f = from;
  360.   register char *t = to;
  361.   register int i = count;
  362.  
  363.   while (i-- > 0)
  364.     *t++ = *f++;
  365. }
  366.  
  367. #endif
  368. #endif
  369.  
  370. #line 196 "/usr/local/share/bison.simple"
  371.  
  372. /* The user can define po_hash_PARSE_PARAM as the name of an argument to be passed
  373.    into po_hash_parse.  The argument should have type void *.
  374.    It should actually point to an object.
  375.    Grammar actions can access the variable by casting it
  376.    to the proper pointer type.  */
  377.  
  378. #ifdef po_hash_PARSE_PARAM
  379. #ifdef __cplusplus
  380. #define po_hash_PARSE_PARAM_ARG void *po_hash_PARSE_PARAM
  381. #define po_hash_PARSE_PARAM_DECL
  382. #else /* not __cplusplus */
  383. #define po_hash_PARSE_PARAM_ARG po_hash_PARSE_PARAM
  384. #define po_hash_PARSE_PARAM_DECL void *po_hash_PARSE_PARAM;
  385. #endif /* not __cplusplus */
  386. #else /* not po_hash_PARSE_PARAM */
  387. #define po_hash_PARSE_PARAM_ARG
  388. #define po_hash_PARSE_PARAM_DECL
  389. #endif /* not po_hash_PARSE_PARAM */
  390.  
  391. int
  392. po_hash_parse(po_hash_PARSE_PARAM_ARG)
  393.      po_hash_PARSE_PARAM_DECL
  394. {
  395.   register int po_hash_state;
  396.   register int po_hash_n;
  397.   register short *po_hash_ssp;
  398.   register po_hash_STYPE *po_hash_vsp;
  399.   int po_hash_errstatus;    /*  number of tokens to shift before error messages enabled */
  400.   int po_hash_char1 = 0;        /*  lookahead token as an internal (translated) token number */
  401.  
  402.   short    po_hash_ssa[po_hash_INITDEPTH];    /*  the state stack            */
  403.   po_hash_STYPE po_hash_vsa[po_hash_INITDEPTH];    /*  the semantic value stack        */
  404.  
  405.   short *po_hash_ss = po_hash_ssa;        /*  refer to the stacks thru separate pointers */
  406.   po_hash_STYPE *po_hash_vs = po_hash_vsa;    /*  to allow po_hash_overflow to reallocate them elsewhere */
  407.  
  408. #ifdef po_hash_LSP_NEEDED
  409.   po_hash_LTYPE po_hash_lsa[po_hash_INITDEPTH];    /*  the location stack            */
  410.   po_hash_LTYPE *po_hash_ls = po_hash_lsa;
  411.   po_hash_LTYPE *po_hash_lsp;
  412.  
  413. #define po_hash_POPSTACK   (po_hash_vsp--, po_hash_ssp--, po_hash_lsp--)
  414. #else
  415. #define po_hash_POPSTACK   (po_hash_vsp--, po_hash_ssp--)
  416. #endif
  417.  
  418.   int po_hash_stacksize = po_hash_INITDEPTH;
  419.  
  420. #ifdef po_hash_PURE
  421.   int po_hash_char;
  422.   po_hash_STYPE po_hash_lval;
  423.   int po_hash_nerrs;
  424. #ifdef po_hash_LSP_NEEDED
  425.   po_hash_LTYPE po_hash_lloc;
  426. #endif
  427. #endif
  428.  
  429.   po_hash_STYPE po_hash_val;        /*  the variable used to return        */
  430.                 /*  semantic values from the action    */
  431.                 /*  routines                */
  432.  
  433.   int po_hash_len;
  434.  
  435. #if po_hash_DEBUG != 0
  436.   if (po_hash_debug)
  437.     fprintf(stderr, "Starting parse\n");
  438. #endif
  439.  
  440.   po_hash_state = 0;
  441.   po_hash_errstatus = 0;
  442.   po_hash_nerrs = 0;
  443.   po_hash_char = po_hash_EMPTY;        /* Cause a token to be read.  */
  444.  
  445.   /* Initialize stack pointers.
  446.      Waste one element of value and location stack
  447.      so that they stay on the same level as the state stack.
  448.      The wasted elements are never initialized.  */
  449.  
  450.   po_hash_ssp = po_hash_ss - 1;
  451.   po_hash_vsp = po_hash_vs;
  452. #ifdef po_hash_LSP_NEEDED
  453.   po_hash_lsp = po_hash_ls;
  454. #endif
  455.  
  456. /* Push a new state, which is found in  po_hash_state  .  */
  457. /* In all cases, when you get here, the value and location stacks
  458.    have just been pushed. so pushing a state here evens the stacks.  */
  459. po_hash_newstate:
  460.  
  461.   *++po_hash_ssp = po_hash_state;
  462.  
  463.   if (po_hash_ssp >= po_hash_ss + po_hash_stacksize - 1)
  464.     {
  465.       /* Give user a chance to reallocate the stack */
  466.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  467.       po_hash_STYPE *po_hash_vs1 = po_hash_vs;
  468.       short *po_hash_ss1 = po_hash_ss;
  469. #ifdef po_hash_LSP_NEEDED
  470.       po_hash_LTYPE *po_hash_ls1 = po_hash_ls;
  471. #endif
  472.  
  473.       /* Get the current used size of the three stacks, in elements.  */
  474.       int size = po_hash_ssp - po_hash_ss + 1;
  475.  
  476. #ifdef po_hash_overflow
  477.       /* Each stack pointer address is followed by the size of
  478.      the data in use in that stack, in bytes.  */
  479. #ifdef po_hash_LSP_NEEDED
  480.       /* This used to be a conditional around just the two extra args,
  481.      but that might be undefined if po_hash_overflow is a macro.  */
  482.       po_hash_overflow("parser stack overflow",
  483.          &po_hash_ss1, size * sizeof (*po_hash_ssp),
  484.          &po_hash_vs1, size * sizeof (*po_hash_vsp),
  485.          &po_hash_ls1, size * sizeof (*po_hash_lsp),
  486.          &po_hash_stacksize);
  487. #else
  488.       po_hash_overflow("parser stack overflow",
  489.          &po_hash_ss1, size * sizeof (*po_hash_ssp),
  490.          &po_hash_vs1, size * sizeof (*po_hash_vsp),
  491.          &po_hash_stacksize);
  492. #endif
  493.  
  494.       po_hash_ss = po_hash_ss1; po_hash_vs = po_hash_vs1;
  495. #ifdef po_hash_LSP_NEEDED
  496.       po_hash_ls = po_hash_ls1;
  497. #endif
  498. #else /* no po_hash_overflow */
  499.       /* Extend the stack our own way.  */
  500.       if (po_hash_stacksize >= po_hash_MAXDEPTH)
  501.     {
  502.       po_hash_error("parser stack overflow");
  503.       return 2;
  504.     }
  505.       po_hash_stacksize *= 2;
  506.       if (po_hash_stacksize > po_hash_MAXDEPTH)
  507.     po_hash_stacksize = po_hash_MAXDEPTH;
  508.       po_hash_ss = (short *) alloca (po_hash_stacksize * sizeof (*po_hash_ssp));
  509.       __po_hash__memcpy ((char *)po_hash_ss, (char *)po_hash_ss1, size * sizeof (*po_hash_ssp));
  510.       po_hash_vs = (po_hash_STYPE *) alloca (po_hash_stacksize * sizeof (*po_hash_vsp));
  511.       __po_hash__memcpy ((char *)po_hash_vs, (char *)po_hash_vs1, size * sizeof (*po_hash_vsp));
  512. #ifdef po_hash_LSP_NEEDED
  513.       po_hash_ls = (po_hash_LTYPE *) alloca (po_hash_stacksize * sizeof (*po_hash_lsp));
  514.       __po_hash__memcpy ((char *)po_hash_ls, (char *)po_hash_ls1, size * sizeof (*po_hash_lsp));
  515. #endif
  516. #endif /* no po_hash_overflow */
  517.  
  518.       po_hash_ssp = po_hash_ss + size - 1;
  519.       po_hash_vsp = po_hash_vs + size - 1;
  520. #ifdef po_hash_LSP_NEEDED
  521.       po_hash_lsp = po_hash_ls + size - 1;
  522. #endif
  523.  
  524. #if po_hash_DEBUG != 0
  525.       if (po_hash_debug)
  526.     fprintf(stderr, "Stack size increased to %d\n", po_hash_stacksize);
  527. #endif
  528.  
  529.       if (po_hash_ssp >= po_hash_ss + po_hash_stacksize - 1)
  530.     po_hash_ABORT;
  531.     }
  532.  
  533. #if po_hash_DEBUG != 0
  534.   if (po_hash_debug)
  535.     fprintf(stderr, "Entering state %d\n", po_hash_state);
  536. #endif
  537.  
  538.   goto po_hash_backup;
  539.  po_hash_backup:
  540.  
  541. /* Do appropriate processing given the current state.  */
  542. /* Read a lookahead token if we need one and don't already have one.  */
  543. /* po_hash_resume: */
  544.  
  545.   /* First try to decide what to do without reference to lookahead token.  */
  546.  
  547.   po_hash_n = po_hash_pact[po_hash_state];
  548.   if (po_hash_n == po_hash_FLAG)
  549.     goto po_hash_default;
  550.  
  551.   /* Not known => get a lookahead token if don't already have one.  */
  552.  
  553.   /* po_hash_char is either po_hash_EMPTY or po_hash_EOF
  554.      or a valid token in external form.  */
  555.  
  556.   if (po_hash_char == po_hash_EMPTY)
  557.     {
  558. #if po_hash_DEBUG != 0
  559.       if (po_hash_debug)
  560.     fprintf(stderr, "Reading a token: ");
  561. #endif
  562.       po_hash_char = po_hash_LEX;
  563.     }
  564.  
  565.   /* Convert token to internal form (in po_hash_char1) for indexing tables with */
  566.  
  567.   if (po_hash_char <= 0)        /* This means end of input. */
  568.     {
  569.       po_hash_char1 = 0;
  570.       po_hash_char = po_hash_EOF;        /* Don't call po_hash_LEX any more */
  571.  
  572. #if po_hash_DEBUG != 0
  573.       if (po_hash_debug)
  574.     fprintf(stderr, "Now at end of input.\n");
  575. #endif
  576.     }
  577.   else
  578.     {
  579.       po_hash_char1 = po_hash_TRANSLATE(po_hash_char);
  580.  
  581. #if po_hash_DEBUG != 0
  582.       if (po_hash_debug)
  583.     {
  584.       fprintf (stderr, "Next token is %d (%s", po_hash_char, po_hash_tname[po_hash_char1]);
  585.       /* Give the individual parser a way to print the precise meaning
  586.          of a token, for further debugging info.  */
  587. #ifdef po_hash_PRINT
  588.       po_hash_PRINT (stderr, po_hash_char, po_hash_lval);
  589. #endif
  590.       fprintf (stderr, ")\n");
  591.     }
  592. #endif
  593.     }
  594.  
  595.   po_hash_n += po_hash_char1;
  596.   if (po_hash_n < 0 || po_hash_n > po_hash_LAST || po_hash_check[po_hash_n] != po_hash_char1)
  597.     goto po_hash_default;
  598.  
  599.   po_hash_n = po_hash_table[po_hash_n];
  600.  
  601.   /* po_hash_n is what to do for this token type in this state.
  602.      Negative => reduce, -po_hash_n is rule number.
  603.      Positive => shift, po_hash_n is new state.
  604.        New state is final state => don't bother to shift,
  605.        just return success.
  606.      0, or most negative number => error.  */
  607.  
  608.   if (po_hash_n < 0)
  609.     {
  610.       if (po_hash_n == po_hash_FLAG)
  611.     goto po_hash_errlab;
  612.       po_hash_n = -po_hash_n;
  613.       goto po_hash_reduce;
  614.     }
  615.   else if (po_hash_n == 0)
  616.     goto po_hash_errlab;
  617.  
  618.   if (po_hash_n == po_hash_FINAL)
  619.     po_hash_ACCEPT;
  620.  
  621.   /* Shift the lookahead token.  */
  622.  
  623. #if po_hash_DEBUG != 0
  624.   if (po_hash_debug)
  625.     fprintf(stderr, "Shifting token %d (%s), ", po_hash_char, po_hash_tname[po_hash_char1]);
  626. #endif
  627.  
  628.   /* Discard the token being shifted unless it is eof.  */
  629.   if (po_hash_char != po_hash_EOF)
  630.     po_hash_char = po_hash_EMPTY;
  631.  
  632.   *++po_hash_vsp = po_hash_lval;
  633. #ifdef po_hash_LSP_NEEDED
  634.   *++po_hash_lsp = po_hash_lloc;
  635. #endif
  636.  
  637.   /* count tokens shifted since error; after three, turn off error status.  */
  638.   if (po_hash_errstatus) po_hash_errstatus--;
  639.  
  640.   po_hash_state = po_hash_n;
  641.   goto po_hash_newstate;
  642.  
  643. /* Do the default action for the current state.  */
  644. po_hash_default:
  645.  
  646.   po_hash_n = po_hash_defact[po_hash_state];
  647.   if (po_hash_n == 0)
  648.     goto po_hash_errlab;
  649.  
  650. /* Do a reduction.  po_hash_n is the number of a rule to reduce with.  */
  651. po_hash_reduce:
  652.   po_hash_len = po_hash_r2[po_hash_n];
  653.   if (po_hash_len > 0)
  654.     po_hash_val = po_hash_vsp[1-po_hash_len]; /* implement default value of the action */
  655.  
  656. #if po_hash_DEBUG != 0
  657.   if (po_hash_debug)
  658.     {
  659.       int i;
  660.  
  661.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  662.            po_hash_n, po_hash_rline[po_hash_n]);
  663.  
  664.       /* Print the symbols being reduced, and their result.  */
  665.       for (i = po_hash_prhs[po_hash_n]; po_hash_rhs[i] > 0; i++)
  666.     fprintf (stderr, "%s ", po_hash_tname[po_hash_rhs[i]]);
  667.       fprintf (stderr, " -> %s\n", po_hash_tname[po_hash_r1[po_hash_n]]);
  668.     }
  669. #endif
  670.  
  671.  
  672.   switch (po_hash_n) {
  673.  
  674. case 3:
  675. #line 88 "../../src/po-hash.y"
  676. {
  677.           /* GNU style */
  678.           po_callback_comment_filepos (po_hash_vsp[-2].string, po_hash_vsp[0].number);
  679.           free (po_hash_vsp[-2].string);
  680.         ;
  681.     break;}
  682. case 4:
  683. #line 94 "../../src/po-hash.y"
  684. {
  685.           /* SunOS style */
  686.           po_callback_comment_filepos (po_hash_vsp[-4].string, po_hash_vsp[0].number);
  687.           free (po_hash_vsp[-4].string);
  688.         ;
  689.     break;}
  690. case 5:
  691. #line 100 "../../src/po-hash.y"
  692. {
  693.           /* Solaris style */
  694.           po_callback_comment_filepos (po_hash_vsp[-5].string, po_hash_vsp[0].number);
  695.           free (po_hash_vsp[-5].string);
  696.         ;
  697.     break;}
  698. case 6:
  699. #line 106 "../../src/po-hash.y"
  700. {
  701.           /* GNU style, but STRING is `file'.  Esiteric, but it
  702.              happened.  */
  703.           po_callback_comment_filepos ("file", po_hash_vsp[0].number);
  704.         ;
  705.     break;}
  706. }
  707.    /* the action file gets copied in in place of this dollarsign */
  708. #line 498 "/usr/local/share/bison.simple"
  709.  
  710.   po_hash_vsp -= po_hash_len;
  711.   po_hash_ssp -= po_hash_len;
  712. #ifdef po_hash_LSP_NEEDED
  713.   po_hash_lsp -= po_hash_len;
  714. #endif
  715.  
  716. #if po_hash_DEBUG != 0
  717.   if (po_hash_debug)
  718.     {
  719.       short *ssp1 = po_hash_ss - 1;
  720.       fprintf (stderr, "state stack now");
  721.       while (ssp1 != po_hash_ssp)
  722.     fprintf (stderr, " %d", *++ssp1);
  723.       fprintf (stderr, "\n");
  724.     }
  725. #endif
  726.  
  727.   *++po_hash_vsp = po_hash_val;
  728.  
  729. #ifdef po_hash_LSP_NEEDED
  730.   po_hash_lsp++;
  731.   if (po_hash_len == 0)
  732.     {
  733.       po_hash_lsp->first_line = po_hash_lloc.first_line;
  734.       po_hash_lsp->first_column = po_hash_lloc.first_column;
  735.       po_hash_lsp->last_line = (po_hash_lsp-1)->last_line;
  736.       po_hash_lsp->last_column = (po_hash_lsp-1)->last_column;
  737.       po_hash_lsp->text = 0;
  738.     }
  739.   else
  740.     {
  741.       po_hash_lsp->last_line = (po_hash_lsp+po_hash_len-1)->last_line;
  742.       po_hash_lsp->last_column = (po_hash_lsp+po_hash_len-1)->last_column;
  743.     }
  744. #endif
  745.  
  746.   /* Now "shift" the result of the reduction.
  747.      Determine what state that goes to,
  748.      based on the state we popped back to
  749.      and the rule number reduced by.  */
  750.  
  751.   po_hash_n = po_hash_r1[po_hash_n];
  752.  
  753.   po_hash_state = po_hash_pgoto[po_hash_n - po_hash_NTBASE] + *po_hash_ssp;
  754.   if (po_hash_state >= 0 && po_hash_state <= po_hash_LAST && po_hash_check[po_hash_state] == *po_hash_ssp)
  755.     po_hash_state = po_hash_table[po_hash_state];
  756.   else
  757.     po_hash_state = po_hash_defgoto[po_hash_n - po_hash_NTBASE];
  758.  
  759.   goto po_hash_newstate;
  760.  
  761. po_hash_errlab:   /* here on detecting error */
  762.  
  763.   if (! po_hash_errstatus)
  764.     /* If not already recovering from an error, report this error.  */
  765.     {
  766.       ++po_hash_nerrs;
  767.  
  768. #ifdef po_hash_ERROR_VERBOSE
  769.       po_hash_n = po_hash_pact[po_hash_state];
  770.  
  771.       if (po_hash_n > po_hash_FLAG && po_hash_n < po_hash_LAST)
  772.     {
  773.       int size = 0;
  774.       char *msg;
  775.       int x, count;
  776.  
  777.       count = 0;
  778.       /* Start X at -po_hash_n if nec to avoid negative indexes in po_hash_check.  */
  779.       for (x = (po_hash_n < 0 ? -po_hash_n : 0);
  780.            x < (sizeof(po_hash_tname) / sizeof(char *)); x++)
  781.         if (po_hash_check[x + po_hash_n] == x)
  782.           size += strlen(po_hash_tname[x]) + 15, count++;
  783.       msg = (char *) malloc(size + 15);
  784.       if (msg != 0)
  785.         {
  786.           strcpy(msg, "parse error");
  787.  
  788.           if (count < 5)
  789.         {
  790.           count = 0;
  791.           for (x = (po_hash_n < 0 ? -po_hash_n : 0);
  792.                x < (sizeof(po_hash_tname) / sizeof(char *)); x++)
  793.             if (po_hash_check[x + po_hash_n] == x)
  794.               {
  795.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  796.             strcat(msg, po_hash_tname[x]);
  797.             strcat(msg, "'");
  798.             count++;
  799.               }
  800.         }
  801.           po_hash_error(msg);
  802.           free(msg);
  803.         }
  804.       else
  805.         po_hash_error ("parse error; also virtual memory exceeded");
  806.     }
  807.       else
  808. #endif /* po_hash_ERROR_VERBOSE */
  809.     po_hash_error("parse error");
  810.     }
  811.  
  812.   goto po_hash_errlab1;
  813. po_hash_errlab1:   /* here on error raised explicitly by an action */
  814.  
  815.   if (po_hash_errstatus == 3)
  816.     {
  817.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  818.  
  819.       /* return failure if at end of input */
  820.       if (po_hash_char == po_hash_EOF)
  821.     po_hash_ABORT;
  822.  
  823. #if po_hash_DEBUG != 0
  824.       if (po_hash_debug)
  825.     fprintf(stderr, "Discarding token %d (%s).\n", po_hash_char, po_hash_tname[po_hash_char1]);
  826. #endif
  827.  
  828.       po_hash_char = po_hash_EMPTY;
  829.     }
  830.  
  831.   /* Else will try to reuse lookahead token
  832.      after shifting the error token.  */
  833.  
  834.   po_hash_errstatus = 3;        /* Each real token shifted decrements this */
  835.  
  836.   goto po_hash_errhandle;
  837.  
  838. po_hash_errdefault:  /* current state does not do anything special for the error token. */
  839.  
  840. #if 0
  841.   /* This is wrong; only states that explicitly want error tokens
  842.      should shift them.  */
  843.   po_hash_n = po_hash_defact[po_hash_state];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  844.   if (po_hash_n) goto po_hash_default;
  845. #endif
  846.  
  847. po_hash_errpop:   /* pop the current state because it cannot handle the error token */
  848.  
  849.   if (po_hash_ssp == po_hash_ss) po_hash_ABORT;
  850.   po_hash_vsp--;
  851.   po_hash_state = *--po_hash_ssp;
  852. #ifdef po_hash_LSP_NEEDED
  853.   po_hash_lsp--;
  854. #endif
  855.  
  856. #if po_hash_DEBUG != 0
  857.   if (po_hash_debug)
  858.     {
  859.       short *ssp1 = po_hash_ss - 1;
  860.       fprintf (stderr, "Error: state stack now");
  861.       while (ssp1 != po_hash_ssp)
  862.     fprintf (stderr, " %d", *++ssp1);
  863.       fprintf (stderr, "\n");
  864.     }
  865. #endif
  866.  
  867. po_hash_errhandle:
  868.  
  869.   po_hash_n = po_hash_pact[po_hash_state];
  870.   if (po_hash_n == po_hash_FLAG)
  871.     goto po_hash_errdefault;
  872.  
  873.   po_hash_n += po_hash_TERROR;
  874.   if (po_hash_n < 0 || po_hash_n > po_hash_LAST || po_hash_check[po_hash_n] != po_hash_TERROR)
  875.     goto po_hash_errdefault;
  876.  
  877.   po_hash_n = po_hash_table[po_hash_n];
  878.   if (po_hash_n < 0)
  879.     {
  880.       if (po_hash_n == po_hash_FLAG)
  881.     goto po_hash_errpop;
  882.       po_hash_n = -po_hash_n;
  883.       goto po_hash_reduce;
  884.     }
  885.   else if (po_hash_n == 0)
  886.     goto po_hash_errpop;
  887.  
  888.   if (po_hash_n == po_hash_FINAL)
  889.     po_hash_ACCEPT;
  890.  
  891. #if po_hash_DEBUG != 0
  892.   if (po_hash_debug)
  893.     fprintf(stderr, "Shifting error token, ");
  894. #endif
  895.  
  896.   *++po_hash_vsp = po_hash_lval;
  897. #ifdef po_hash_LSP_NEEDED
  898.   *++po_hash_lsp = po_hash_lloc;
  899. #endif
  900.  
  901.   po_hash_state = po_hash_n;
  902.   goto po_hash_newstate;
  903. }
  904. #line 113 "../../src/po-hash.y"
  905.  
  906.  
  907.  
  908. int
  909. po_hash_lex ()
  910. {
  911.   static char *buf;
  912.   static size_t bufmax;
  913.   size_t bufpos;
  914.   int n;
  915.   int c;
  916.  
  917.   for (;;)
  918.     {
  919.       c = *cur++;
  920.       switch (c)
  921.     {
  922.     case 0:
  923.       --cur;
  924.       return 0;
  925.  
  926.     case ' ':
  927.     case '\t':
  928.     case '\n':
  929.       break;
  930.  
  931.     case ':':
  932.       return COLON;
  933.  
  934.     case ',':
  935.       return COMMA;
  936.  
  937.     case '0':
  938.     case '1':
  939.     case '2':
  940.     case '3':
  941.     case '4':
  942.     case '5':
  943.     case '6':
  944.     case '7':
  945.     case '8':
  946.     case '9':
  947.       /* Accumulate a number.  */
  948.       n = 0;
  949.       for (;;)
  950.         {
  951.           n = n * 10 + c - '0';
  952.           c = *cur++;
  953.           switch (c)
  954.         {
  955.         default:
  956.           break;
  957.  
  958.         case '0':
  959.         case '1':
  960.         case '2':
  961.         case '3':
  962.         case '4':
  963.         case '5':
  964.         case '6':
  965.         case '7':
  966.         case '8':
  967.         case '9':
  968.           continue;
  969.         }
  970.           break;
  971.         }
  972.       --cur;
  973.       po_hash_lval.number = n;
  974.       return NUMBER;
  975.  
  976.     default:
  977.       /* Accumulate a string.  */
  978.       bufpos = 0;
  979.       for (;;)
  980.         {
  981.           if (bufpos >= bufmax)
  982.         {
  983.           bufmax += 100;
  984.           buf = xrealloc (buf, bufmax);
  985.         }
  986.           buf[bufpos++] = c;
  987.  
  988.           c = *cur++;
  989.           switch (c)
  990.             {
  991.             default:
  992.               continue;
  993.  
  994.             case 0:
  995.             case ':':
  996.             case ',':
  997.             case ' ':
  998.             case '\t':
  999.               --cur;
  1000.               break;
  1001.             }
  1002.           break;
  1003.         }
  1004.  
  1005.       if (bufpos >= bufmax)
  1006.         {
  1007.           bufmax += 100;
  1008.           buf = xrealloc (buf, bufmax);
  1009.         }
  1010.       buf[bufpos] = 0;
  1011.  
  1012.       if (strcmp (buf, "file") == 0 || strcmp (buf, "File") == 0)
  1013.         return FILE_KEYWORD;
  1014.       if (strcmp (buf, "line") == 0)
  1015.         return LINE_KEYWORD;
  1016.       if (strcmp (buf, "number") == 0)
  1017.         return NUMBER_KEYWORD;
  1018.       po_hash_lval.string = xstrdup (buf);
  1019.       return STRING;
  1020.     }
  1021.     }
  1022. }
  1023.