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-gram.gen.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  27KB  |  919 lines
  1.  
  2. /*  A Bison parser, made from ../../src/po-gram.y with Bison version GNU Bison version 1.24
  3.   */
  4.  
  5. #define po_gram_BISON 1  /* Identify Bison output.  */
  6.  
  7. #define    COMMENT    258
  8. #define    DOMAIN    259
  9. #define    JUNK    260
  10. #define    MSGID    261
  11. #define    MSGSTR    262
  12. #define    NAME    263
  13. #define    NUMBER    264
  14. #define    STRING    265
  15.  
  16. #line 20 "../../src/po-gram.y"
  17.  
  18. #ifdef HAVE_CONFIG_H
  19. # include "config.h"
  20. #endif
  21.  
  22. #include <stdio.h>
  23.  
  24. #include "po-lex.h"
  25. #include "po-gram.h"
  26. #include "error.h"
  27. #include "system.h"
  28. #include <libintl.h>
  29. #include "po.h"
  30.  
  31. #define _(str) gettext (str)
  32.  
  33. #line 46 "../../src/po-gram.y"
  34. typedef union
  35. {
  36.   char *string;
  37.   long number;
  38.   lex_pos_ty pos;
  39. } po_gram_STYPE;
  40.  
  41. #ifndef po_gram_LTYPE
  42. typedef
  43.   struct po_gram_ltype
  44.     {
  45.       int timestamp;
  46.       int first_line;
  47.       int first_column;
  48.       int last_line;
  49.       int last_column;
  50.       char *text;
  51.    }
  52.   po_gram_ltype;
  53.  
  54. #define po_gram_LTYPE po_gram_ltype
  55. #endif
  56.  
  57. #include <stdio.h>
  58.  
  59. #ifndef __cplusplus
  60. #ifndef __STDC__
  61. #define const
  62. #endif
  63. #endif
  64.  
  65.  
  66.  
  67. #define    po_gram_FINAL        18
  68. #define    po_gram_FLAG        -32768
  69. #define    po_gram_NTBASE    11
  70.  
  71. #define po_gram_TRANSLATE(x) ((unsigned)(x) <= 265 ? po_gram_translate[x] : 18)
  72.  
  73. static const char po_gram_translate[] = {     0,
  74.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  75.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  76.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  77.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  78.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  79.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  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,     1,     2,     3,     4,     5,
  100.      6,     7,     8,     9,    10
  101. };
  102.  
  103. #if po_gram_DEBUG != 0
  104. static const short po_gram_prhs[] = {     0,
  105.      0,     1,     4,     7,    10,    13,    16,    21,    24,    26,
  106.     28,    30,    33
  107. };
  108.  
  109. static const short po_gram_rhs[] = {    -1,
  110.     11,    17,     0,    11,    12,     0,    11,    13,     0,    11,
  111.      1,     0,     4,    10,     0,    14,    16,    15,    16,     0,
  112.     14,    16,     0,     6,     0,     7,     0,    10,     0,    16,
  113.     10,     0,     3,     0
  114. };
  115.  
  116. #endif
  117.  
  118. #if po_gram_DEBUG != 0
  119. static const short po_gram_rline[] = { 0,
  120.     62,    63,    64,    65,    66,    70,    77,    81,    89,    96,
  121.    103,   107,   122
  122. };
  123.  
  124. static const char * const po_gram_tname[] = {   "$","error","$undefined.","COMMENT",
  125. "DOMAIN","JUNK","MSGID","MSGSTR","NAME","NUMBER","STRING","msgfmt","domain",
  126. "message","msgid","msgstr","string_list","comment",""
  127. };
  128. #endif
  129.  
  130. static const short po_gram_r1[] = {     0,
  131.     11,    11,    11,    11,    11,    12,    13,    13,    14,    15,
  132.     16,    16,    17
  133. };
  134.  
  135. static const short po_gram_r2[] = {     0,
  136.      0,     2,     2,     2,     2,     2,     4,     2,     1,     1,
  137.      1,     2,     1
  138. };
  139.  
  140. static const short po_gram_defact[] = {     1,
  141.      0,     5,    13,     0,     9,     3,     4,     0,     2,     6,
  142.     11,     8,    10,    12,     0,     7,     0,     0
  143. };
  144.  
  145. static const short po_gram_defgoto[] = {     1,
  146.      6,     7,     8,    15,    12,     9
  147. };
  148.  
  149. static const short po_gram_pact[] = {-32768,
  150.      0,-32768,-32768,    -3,-32768,-32768,-32768,    -2,-32768,-32768,
  151. -32768,    -5,-32768,-32768,    -2,    -1,    10,-32768
  152. };
  153.  
  154. static const short po_gram_pgoto[] = {-32768,
  155. -32768,-32768,-32768,-32768,    -4,-32768
  156. };
  157.  
  158.  
  159. #define    po_gram_LAST        11
  160.  
  161.  
  162. static const short po_gram_table[] = {    17,
  163.      2,    13,     3,     4,    14,     5,    10,    11,    14,    18,
  164.     16
  165. };
  166.  
  167. static const short po_gram_check[] = {     0,
  168.      1,     7,     3,     4,    10,     6,    10,    10,    10,     0,
  169.     15
  170. };
  171. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  172. #line 3 "/usr/local/share/bison.simple"
  173.  
  174. /* Skeleton output parser for bison,
  175.    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
  176.  
  177.    This program is free software; you can redistribute it and/or modify
  178.    it under the terms of the GNU General Public License as published by
  179.    the Free Software Foundation; either version 2, or (at your option)
  180.    any later version.
  181.  
  182.    This program is distributed in the hope that it will be useful,
  183.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  184.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  185.    GNU General Public License for more details.
  186.  
  187.    You should have received a copy of the GNU General Public License
  188.    along with this program; if not, write to the Free Software
  189.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  190.  
  191. /* As a special exception, when this file is copied by Bison into a
  192.    Bison output file, you may use that output file without restriction.
  193.    This special exception was added by the Free Software Foundation
  194.    in version 1.24 of Bison.  */
  195.  
  196. #ifndef alloca
  197. #ifdef __GNUC__
  198. #define alloca __builtin_alloca
  199. #else /* not GNU C.  */
  200. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
  201. #include <alloca.h>
  202. #else /* not sparc */
  203. #if defined (MSDOS) && !defined (__TURBOC__)
  204. #include <malloc.h>
  205. #else /* not MSDOS, or __TURBOC__ */
  206. #if defined(_AIX)
  207. #include <malloc.h>
  208.  #pragma alloca
  209. #else /* not MSDOS, __TURBOC__, or _AIX */
  210. #ifdef __hpux
  211. #ifdef __cplusplus
  212. extern "C" {
  213. void *alloca (unsigned int);
  214. };
  215. #else /* not __cplusplus */
  216. void *alloca ();
  217. #endif /* not __cplusplus */
  218. #endif /* __hpux */
  219. #endif /* not _AIX */
  220. #endif /* not MSDOS, or __TURBOC__ */
  221. #endif /* not sparc.  */
  222. #endif /* not GNU C.  */
  223. #endif /* alloca not defined.  */
  224.  
  225. /* This is the parser code that is written into each bison parser
  226.   when the %semantic_parser declaration is not specified in the grammar.
  227.   It was written by Richard Stallman by simplifying the hairy parser
  228.   used when %semantic_parser is specified.  */
  229.  
  230. /* Note: there must be only one dollar sign in this file.
  231.    It is replaced by the list of actions, each action
  232.    as one case of the switch.  */
  233.  
  234. #define po_gram_errok        (po_gram_errstatus = 0)
  235. #define po_gram_clearin    (po_gram_char = po_gram_EMPTY)
  236. #define po_gram_EMPTY        -2
  237. #define po_gram_EOF        0
  238. #define po_gram_ACCEPT    return(0)
  239. #define po_gram_ABORT     return(1)
  240. #define po_gram_ERROR        goto po_gram_errlab1
  241. /* Like po_gram_ERROR except do call po_gram_error.
  242.    This remains here temporarily to ease the
  243.    transition to the new meaning of po_gram_ERROR, for GCC.
  244.    Once GCC version 2 has supplanted version 1, this can go.  */
  245. #define po_gram_FAIL        goto po_gram_errlab
  246. #define po_gram_RECOVERING()  (!!po_gram_errstatus)
  247. #define po_gram_BACKUP(token, value) \
  248. do                                \
  249.   if (po_gram_char == po_gram_EMPTY && po_gram_len == 1)                \
  250.     { po_gram_char = (token), po_gram_lval = (value);            \
  251.       po_gram_char1 = po_gram_TRANSLATE (po_gram_char);                \
  252.       po_gram_POPSTACK;                        \
  253.       goto po_gram_backup;                        \
  254.     }                                \
  255.   else                                \
  256.     { po_gram_error ("syntax error: cannot back up"); po_gram_ERROR; }    \
  257. while (0)
  258.  
  259. #define po_gram_TERROR    1
  260. #define po_gram_ERRCODE    256
  261.  
  262. #ifndef po_gram_PURE
  263. #define po_gram_LEX        po_gram_lex()
  264. #endif
  265.  
  266. #ifdef po_gram_PURE
  267. #ifdef po_gram_LSP_NEEDED
  268. #ifdef po_gram_LEX_PARAM
  269. #define po_gram_LEX        po_gram_lex(&po_gram_lval, &po_gram_lloc, po_gram_LEX_PARAM)
  270. #else
  271. #define po_gram_LEX        po_gram_lex(&po_gram_lval, &po_gram_lloc)
  272. #endif
  273. #else /* not po_gram_LSP_NEEDED */
  274. #ifdef po_gram_LEX_PARAM
  275. #define po_gram_LEX        po_gram_lex(&po_gram_lval, po_gram_LEX_PARAM)
  276. #else
  277. #define po_gram_LEX        po_gram_lex(&po_gram_lval)
  278. #endif
  279. #endif /* not po_gram_LSP_NEEDED */
  280. #endif
  281.  
  282. /* If nonreentrant, generate the variables here */
  283.  
  284. #ifndef po_gram_PURE
  285.  
  286. int    po_gram_char;            /*  the lookahead symbol        */
  287. po_gram_STYPE    po_gram_lval;            /*  the semantic value of the        */
  288.                 /*  lookahead symbol            */
  289.  
  290. #ifdef po_gram_LSP_NEEDED
  291. po_gram_LTYPE po_gram_lloc;            /*  location data for the lookahead    */
  292.                 /*  symbol                */
  293. #endif
  294.  
  295. int po_gram_nerrs;            /*  number of parse errors so far       */
  296. #endif  /* not po_gram_PURE */
  297.  
  298. #if po_gram_DEBUG != 0
  299. int po_gram_debug;            /*  nonzero means print parse trace    */
  300. /* Since this is uninitialized, it does not stop multiple parsers
  301.    from coexisting.  */
  302. #endif
  303.  
  304. /*  po_gram_INITDEPTH indicates the initial size of the parser's stacks    */
  305.  
  306. #ifndef    po_gram_INITDEPTH
  307. #define po_gram_INITDEPTH 200
  308. #endif
  309.  
  310. /*  po_gram_MAXDEPTH is the maximum size the stacks can grow to
  311.     (effective only if the built-in stack extension method is used).  */
  312.  
  313. #if po_gram_MAXDEPTH == 0
  314. #undef po_gram_MAXDEPTH
  315. #endif
  316.  
  317. #ifndef po_gram_MAXDEPTH
  318. #define po_gram_MAXDEPTH 10000
  319. #endif
  320.  
  321. /* Prevent warning if -Wstrict-prototypes.  */
  322. #ifdef __GNUC__
  323. int po_gram_parse (void);
  324. #endif
  325.  
  326. #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
  327. #define __po_gram__memcpy(FROM,TO,COUNT)    __builtin_memcpy(TO,FROM,COUNT)
  328. #else                /* not GNU C or C++ */
  329. #ifndef __cplusplus
  330.  
  331. /* This is the most reliable way to avoid incompatibilities
  332.    in available built-in functions on various systems.  */
  333. static void
  334. __po_gram__memcpy (from, to, count)
  335.      char *from;
  336.      char *to;
  337.      int count;
  338. {
  339.   register char *f = from;
  340.   register char *t = to;
  341.   register int i = count;
  342.  
  343.   while (i-- > 0)
  344.     *t++ = *f++;
  345. }
  346.  
  347. #else /* __cplusplus */
  348.  
  349. /* This is the most reliable way to avoid incompatibilities
  350.    in available built-in functions on various systems.  */
  351. static void
  352. __po_gram__memcpy (char *from, char *to, int count)
  353. {
  354.   register char *f = from;
  355.   register char *t = to;
  356.   register int i = count;
  357.  
  358.   while (i-- > 0)
  359.     *t++ = *f++;
  360. }
  361.  
  362. #endif
  363. #endif
  364.  
  365. #line 192 "/usr/local/share/bison.simple"
  366.  
  367. /* The user can define po_gram_PARSE_PARAM as the name of an argument to be passed
  368.    into po_gram_parse.  The argument should have type void *.
  369.    It should actually point to an object.
  370.    Grammar actions can access the variable by casting it
  371.    to the proper pointer type.  */
  372.  
  373. #ifdef po_gram_PARSE_PARAM
  374. #define po_gram_PARSE_PARAM_DECL void *po_gram_PARSE_PARAM;
  375. #else
  376. #define po_gram_PARSE_PARAM
  377. #define po_gram_PARSE_PARAM_DECL
  378. #endif
  379.  
  380. int
  381. po_gram_parse(po_gram_PARSE_PARAM)
  382.      po_gram_PARSE_PARAM_DECL
  383. {
  384.   register int po_gram_state;
  385.   register int po_gram_n;
  386.   register short *po_gram_ssp;
  387.   register po_gram_STYPE *po_gram_vsp;
  388.   int po_gram_errstatus;    /*  number of tokens to shift before error messages enabled */
  389.   int po_gram_char1 = 0;        /*  lookahead token as an internal (translated) token number */
  390.  
  391.   short    po_gram_ssa[po_gram_INITDEPTH];    /*  the state stack            */
  392.   po_gram_STYPE po_gram_vsa[po_gram_INITDEPTH];    /*  the semantic value stack        */
  393.  
  394.   short *po_gram_ss = po_gram_ssa;        /*  refer to the stacks thru separate pointers */
  395.   po_gram_STYPE *po_gram_vs = po_gram_vsa;    /*  to allow po_gram_overflow to reallocate them elsewhere */
  396.  
  397. #ifdef po_gram_LSP_NEEDED
  398.   po_gram_LTYPE po_gram_lsa[po_gram_INITDEPTH];    /*  the location stack            */
  399.   po_gram_LTYPE *po_gram_ls = po_gram_lsa;
  400.   po_gram_LTYPE *po_gram_lsp;
  401.  
  402. #define po_gram_POPSTACK   (po_gram_vsp--, po_gram_ssp--, po_gram_lsp--)
  403. #else
  404. #define po_gram_POPSTACK   (po_gram_vsp--, po_gram_ssp--)
  405. #endif
  406.  
  407.   int po_gram_stacksize = po_gram_INITDEPTH;
  408.  
  409. #ifdef po_gram_PURE
  410.   int po_gram_char;
  411.   po_gram_STYPE po_gram_lval;
  412.   int po_gram_nerrs;
  413. #ifdef po_gram_LSP_NEEDED
  414.   po_gram_LTYPE po_gram_lloc;
  415. #endif
  416. #endif
  417.  
  418.   po_gram_STYPE po_gram_val;        /*  the variable used to return        */
  419.                 /*  semantic values from the action    */
  420.                 /*  routines                */
  421.  
  422.   int po_gram_len;
  423.  
  424. #if po_gram_DEBUG != 0
  425.   if (po_gram_debug)
  426.     fprintf(stderr, "Starting parse\n");
  427. #endif
  428.  
  429.   po_gram_state = 0;
  430.   po_gram_errstatus = 0;
  431.   po_gram_nerrs = 0;
  432.   po_gram_char = po_gram_EMPTY;        /* Cause a token to be read.  */
  433.  
  434.   /* Initialize stack pointers.
  435.      Waste one element of value and location stack
  436.      so that they stay on the same level as the state stack.
  437.      The wasted elements are never initialized.  */
  438.  
  439.   po_gram_ssp = po_gram_ss - 1;
  440.   po_gram_vsp = po_gram_vs;
  441. #ifdef po_gram_LSP_NEEDED
  442.   po_gram_lsp = po_gram_ls;
  443. #endif
  444.  
  445. /* Push a new state, which is found in  po_gram_state  .  */
  446. /* In all cases, when you get here, the value and location stacks
  447.    have just been pushed. so pushing a state here evens the stacks.  */
  448. po_gram_newstate:
  449.  
  450.   *++po_gram_ssp = po_gram_state;
  451.  
  452.   if (po_gram_ssp >= po_gram_ss + po_gram_stacksize - 1)
  453.     {
  454.       /* Give user a chance to reallocate the stack */
  455.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  456.       po_gram_STYPE *po_gram_vs1 = po_gram_vs;
  457.       short *po_gram_ss1 = po_gram_ss;
  458. #ifdef po_gram_LSP_NEEDED
  459.       po_gram_LTYPE *po_gram_ls1 = po_gram_ls;
  460. #endif
  461.  
  462.       /* Get the current used size of the three stacks, in elements.  */
  463.       int size = po_gram_ssp - po_gram_ss + 1;
  464.  
  465. #ifdef po_gram_overflow
  466.       /* Each stack pointer address is followed by the size of
  467.      the data in use in that stack, in bytes.  */
  468. #ifdef po_gram_LSP_NEEDED
  469.       /* This used to be a conditional around just the two extra args,
  470.      but that might be undefined if po_gram_overflow is a macro.  */
  471.       po_gram_overflow("parser stack overflow",
  472.          &po_gram_ss1, size * sizeof (*po_gram_ssp),
  473.          &po_gram_vs1, size * sizeof (*po_gram_vsp),
  474.          &po_gram_ls1, size * sizeof (*po_gram_lsp),
  475.          &po_gram_stacksize);
  476. #else
  477.       po_gram_overflow("parser stack overflow",
  478.          &po_gram_ss1, size * sizeof (*po_gram_ssp),
  479.          &po_gram_vs1, size * sizeof (*po_gram_vsp),
  480.          &po_gram_stacksize);
  481. #endif
  482.  
  483.       po_gram_ss = po_gram_ss1; po_gram_vs = po_gram_vs1;
  484. #ifdef po_gram_LSP_NEEDED
  485.       po_gram_ls = po_gram_ls1;
  486. #endif
  487. #else /* no po_gram_overflow */
  488.       /* Extend the stack our own way.  */
  489.       if (po_gram_stacksize >= po_gram_MAXDEPTH)
  490.     {
  491.       po_gram_error("parser stack overflow");
  492.       return 2;
  493.     }
  494.       po_gram_stacksize *= 2;
  495.       if (po_gram_stacksize > po_gram_MAXDEPTH)
  496.     po_gram_stacksize = po_gram_MAXDEPTH;
  497.       po_gram_ss = (short *) alloca (po_gram_stacksize * sizeof (*po_gram_ssp));
  498.       __po_gram__memcpy ((char *)po_gram_ss1, (char *)po_gram_ss, size * sizeof (*po_gram_ssp));
  499.       po_gram_vs = (po_gram_STYPE *) alloca (po_gram_stacksize * sizeof (*po_gram_vsp));
  500.       __po_gram__memcpy ((char *)po_gram_vs1, (char *)po_gram_vs, size * sizeof (*po_gram_vsp));
  501. #ifdef po_gram_LSP_NEEDED
  502.       po_gram_ls = (po_gram_LTYPE *) alloca (po_gram_stacksize * sizeof (*po_gram_lsp));
  503.       __po_gram__memcpy ((char *)po_gram_ls1, (char *)po_gram_ls, size * sizeof (*po_gram_lsp));
  504. #endif
  505. #endif /* no po_gram_overflow */
  506.  
  507.       po_gram_ssp = po_gram_ss + size - 1;
  508.       po_gram_vsp = po_gram_vs + size - 1;
  509. #ifdef po_gram_LSP_NEEDED
  510.       po_gram_lsp = po_gram_ls + size - 1;
  511. #endif
  512.  
  513. #if po_gram_DEBUG != 0
  514.       if (po_gram_debug)
  515.     fprintf(stderr, "Stack size increased to %d\n", po_gram_stacksize);
  516. #endif
  517.  
  518.       if (po_gram_ssp >= po_gram_ss + po_gram_stacksize - 1)
  519.     po_gram_ABORT;
  520.     }
  521.  
  522. #if po_gram_DEBUG != 0
  523.   if (po_gram_debug)
  524.     fprintf(stderr, "Entering state %d\n", po_gram_state);
  525. #endif
  526.  
  527.   goto po_gram_backup;
  528.  po_gram_backup:
  529.  
  530. /* Do appropriate processing given the current state.  */
  531. /* Read a lookahead token if we need one and don't already have one.  */
  532. /* po_gram_resume: */
  533.  
  534.   /* First try to decide what to do without reference to lookahead token.  */
  535.  
  536.   po_gram_n = po_gram_pact[po_gram_state];
  537.   if (po_gram_n == po_gram_FLAG)
  538.     goto po_gram_default;
  539.  
  540.   /* Not known => get a lookahead token if don't already have one.  */
  541.  
  542.   /* po_gram_char is either po_gram_EMPTY or po_gram_EOF
  543.      or a valid token in external form.  */
  544.  
  545.   if (po_gram_char == po_gram_EMPTY)
  546.     {
  547. #if po_gram_DEBUG != 0
  548.       if (po_gram_debug)
  549.     fprintf(stderr, "Reading a token: ");
  550. #endif
  551.       po_gram_char = po_gram_LEX;
  552.     }
  553.  
  554.   /* Convert token to internal form (in po_gram_char1) for indexing tables with */
  555.  
  556.   if (po_gram_char <= 0)        /* This means end of input. */
  557.     {
  558.       po_gram_char1 = 0;
  559.       po_gram_char = po_gram_EOF;        /* Don't call po_gram_LEX any more */
  560.  
  561. #if po_gram_DEBUG != 0
  562.       if (po_gram_debug)
  563.     fprintf(stderr, "Now at end of input.\n");
  564. #endif
  565.     }
  566.   else
  567.     {
  568.       po_gram_char1 = po_gram_TRANSLATE(po_gram_char);
  569.  
  570. #if po_gram_DEBUG != 0
  571.       if (po_gram_debug)
  572.     {
  573.       fprintf (stderr, "Next token is %d (%s", po_gram_char, po_gram_tname[po_gram_char1]);
  574.       /* Give the individual parser a way to print the precise meaning
  575.          of a token, for further debugging info.  */
  576. #ifdef po_gram_PRINT
  577.       po_gram_PRINT (stderr, po_gram_char, po_gram_lval);
  578. #endif
  579.       fprintf (stderr, ")\n");
  580.     }
  581. #endif
  582.     }
  583.  
  584.   po_gram_n += po_gram_char1;
  585.   if (po_gram_n < 0 || po_gram_n > po_gram_LAST || po_gram_check[po_gram_n] != po_gram_char1)
  586.     goto po_gram_default;
  587.  
  588.   po_gram_n = po_gram_table[po_gram_n];
  589.  
  590.   /* po_gram_n is what to do for this token type in this state.
  591.      Negative => reduce, -po_gram_n is rule number.
  592.      Positive => shift, po_gram_n is new state.
  593.        New state is final state => don't bother to shift,
  594.        just return success.
  595.      0, or most negative number => error.  */
  596.  
  597.   if (po_gram_n < 0)
  598.     {
  599.       if (po_gram_n == po_gram_FLAG)
  600.     goto po_gram_errlab;
  601.       po_gram_n = -po_gram_n;
  602.       goto po_gram_reduce;
  603.     }
  604.   else if (po_gram_n == 0)
  605.     goto po_gram_errlab;
  606.  
  607.   if (po_gram_n == po_gram_FINAL)
  608.     po_gram_ACCEPT;
  609.  
  610.   /* Shift the lookahead token.  */
  611.  
  612. #if po_gram_DEBUG != 0
  613.   if (po_gram_debug)
  614.     fprintf(stderr, "Shifting token %d (%s), ", po_gram_char, po_gram_tname[po_gram_char1]);
  615. #endif
  616.  
  617.   /* Discard the token being shifted unless it is eof.  */
  618.   if (po_gram_char != po_gram_EOF)
  619.     po_gram_char = po_gram_EMPTY;
  620.  
  621.   *++po_gram_vsp = po_gram_lval;
  622. #ifdef po_gram_LSP_NEEDED
  623.   *++po_gram_lsp = po_gram_lloc;
  624. #endif
  625.  
  626.   /* count tokens shifted since error; after three, turn off error status.  */
  627.   if (po_gram_errstatus) po_gram_errstatus--;
  628.  
  629.   po_gram_state = po_gram_n;
  630.   goto po_gram_newstate;
  631.  
  632. /* Do the default action for the current state.  */
  633. po_gram_default:
  634.  
  635.   po_gram_n = po_gram_defact[po_gram_state];
  636.   if (po_gram_n == 0)
  637.     goto po_gram_errlab;
  638.  
  639. /* Do a reduction.  po_gram_n is the number of a rule to reduce with.  */
  640. po_gram_reduce:
  641.   po_gram_len = po_gram_r2[po_gram_n];
  642.   if (po_gram_len > 0)
  643.     po_gram_val = po_gram_vsp[1-po_gram_len]; /* implement default value of the action */
  644.  
  645. #if po_gram_DEBUG != 0
  646.   if (po_gram_debug)
  647.     {
  648.       int i;
  649.  
  650.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  651.            po_gram_n, po_gram_rline[po_gram_n]);
  652.  
  653.       /* Print the symbols being reduced, and their result.  */
  654.       for (i = po_gram_prhs[po_gram_n]; po_gram_rhs[i] > 0; i++)
  655.     fprintf (stderr, "%s ", po_gram_tname[po_gram_rhs[i]]);
  656.       fprintf (stderr, " -> %s\n", po_gram_tname[po_gram_r1[po_gram_n]]);
  657.     }
  658. #endif
  659.  
  660.  
  661.   switch (po_gram_n) {
  662.  
  663. case 6:
  664. #line 71 "../../src/po-gram.y"
  665. {
  666.            po_callback_domain (po_gram_vsp[0].string);
  667.         ;
  668.     break;}
  669. case 7:
  670. #line 78 "../../src/po-gram.y"
  671. {
  672.           po_callback_message (po_gram_vsp[-2].string, &po_gram_vsp[-3].pos, po_gram_vsp[0].string, &po_gram_vsp[-1].pos);
  673.         ;
  674.     break;}
  675. case 8:
  676. #line 82 "../../src/po-gram.y"
  677. {
  678.           gram_error_at_line (&po_gram_vsp[-1].pos, _("missing `msgstr' section"));
  679.           free (po_gram_vsp[0].string);
  680.         ;
  681.     break;}
  682. case 9:
  683. #line 90 "../../src/po-gram.y"
  684. {
  685.           po_gram_val.pos = gram_pos;
  686.         ;
  687.     break;}
  688. case 10:
  689. #line 97 "../../src/po-gram.y"
  690. {
  691.           po_gram_val.pos = gram_pos;
  692.         ;
  693.     break;}
  694. case 11:
  695. #line 104 "../../src/po-gram.y"
  696. {
  697.           po_gram_val.string = po_gram_vsp[0].string;
  698.         ;
  699.     break;}
  700. case 12:
  701. #line 108 "../../src/po-gram.y"
  702. {
  703.           size_t len1;
  704.           size_t len2;
  705.  
  706.           len1 = strlen (po_gram_vsp[-1].string);
  707.           len2 = strlen (po_gram_vsp[0].string);
  708.           po_gram_val.string = (char *) xmalloc (len1 + len2 + 1);
  709.           stpcpy (stpcpy (po_gram_val.string, po_gram_vsp[-1].string), po_gram_vsp[0].string);
  710.           free (po_gram_vsp[-1].string);
  711.           free (po_gram_vsp[0].string);
  712.         ;
  713.     break;}
  714. case 13:
  715. #line 123 "../../src/po-gram.y"
  716. {
  717.           po_callback_comment (po_gram_vsp[0].string);
  718.         ;
  719.     break;}
  720. }
  721.    /* the action file gets copied in in place of this dollarsign */
  722. #line 487 "/usr/local/share/bison.simple"
  723.  
  724.   po_gram_vsp -= po_gram_len;
  725.   po_gram_ssp -= po_gram_len;
  726. #ifdef po_gram_LSP_NEEDED
  727.   po_gram_lsp -= po_gram_len;
  728. #endif
  729.  
  730. #if po_gram_DEBUG != 0
  731.   if (po_gram_debug)
  732.     {
  733.       short *ssp1 = po_gram_ss - 1;
  734.       fprintf (stderr, "state stack now");
  735.       while (ssp1 != po_gram_ssp)
  736.     fprintf (stderr, " %d", *++ssp1);
  737.       fprintf (stderr, "\n");
  738.     }
  739. #endif
  740.  
  741.   *++po_gram_vsp = po_gram_val;
  742.  
  743. #ifdef po_gram_LSP_NEEDED
  744.   po_gram_lsp++;
  745.   if (po_gram_len == 0)
  746.     {
  747.       po_gram_lsp->first_line = po_gram_lloc.first_line;
  748.       po_gram_lsp->first_column = po_gram_lloc.first_column;
  749.       po_gram_lsp->last_line = (po_gram_lsp-1)->last_line;
  750.       po_gram_lsp->last_column = (po_gram_lsp-1)->last_column;
  751.       po_gram_lsp->text = 0;
  752.     }
  753.   else
  754.     {
  755.       po_gram_lsp->last_line = (po_gram_lsp+po_gram_len-1)->last_line;
  756.       po_gram_lsp->last_column = (po_gram_lsp+po_gram_len-1)->last_column;
  757.     }
  758. #endif
  759.  
  760.   /* Now "shift" the result of the reduction.
  761.      Determine what state that goes to,
  762.      based on the state we popped back to
  763.      and the rule number reduced by.  */
  764.  
  765.   po_gram_n = po_gram_r1[po_gram_n];
  766.  
  767.   po_gram_state = po_gram_pgoto[po_gram_n - po_gram_NTBASE] + *po_gram_ssp;
  768.   if (po_gram_state >= 0 && po_gram_state <= po_gram_LAST && po_gram_check[po_gram_state] == *po_gram_ssp)
  769.     po_gram_state = po_gram_table[po_gram_state];
  770.   else
  771.     po_gram_state = po_gram_defgoto[po_gram_n - po_gram_NTBASE];
  772.  
  773.   goto po_gram_newstate;
  774.  
  775. po_gram_errlab:   /* here on detecting error */
  776.  
  777.   if (! po_gram_errstatus)
  778.     /* If not already recovering from an error, report this error.  */
  779.     {
  780.       ++po_gram_nerrs;
  781.  
  782. #ifdef po_gram_ERROR_VERBOSE
  783.       po_gram_n = po_gram_pact[po_gram_state];
  784.  
  785.       if (po_gram_n > po_gram_FLAG && po_gram_n < po_gram_LAST)
  786.     {
  787.       int size = 0;
  788.       char *msg;
  789.       int x, count;
  790.  
  791.       count = 0;
  792.       /* Start X at -po_gram_n if nec to avoid negative indexes in po_gram_check.  */
  793.       for (x = (po_gram_n < 0 ? -po_gram_n : 0);
  794.            x < (sizeof(po_gram_tname) / sizeof(char *)); x++)
  795.         if (po_gram_check[x + po_gram_n] == x)
  796.           size += strlen(po_gram_tname[x]) + 15, count++;
  797.       msg = (char *) malloc(size + 15);
  798.       if (msg != 0)
  799.         {
  800.           strcpy(msg, "parse error");
  801.  
  802.           if (count < 5)
  803.         {
  804.           count = 0;
  805.           for (x = (po_gram_n < 0 ? -po_gram_n : 0);
  806.                x < (sizeof(po_gram_tname) / sizeof(char *)); x++)
  807.             if (po_gram_check[x + po_gram_n] == x)
  808.               {
  809.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  810.             strcat(msg, po_gram_tname[x]);
  811.             strcat(msg, "'");
  812.             count++;
  813.               }
  814.         }
  815.           po_gram_error(msg);
  816.           free(msg);
  817.         }
  818.       else
  819.         po_gram_error ("parse error; also virtual memory exceeded");
  820.     }
  821.       else
  822. #endif /* po_gram_ERROR_VERBOSE */
  823.     po_gram_error("parse error");
  824.     }
  825.  
  826.   goto po_gram_errlab1;
  827. po_gram_errlab1:   /* here on error raised explicitly by an action */
  828.  
  829.   if (po_gram_errstatus == 3)
  830.     {
  831.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  832.  
  833.       /* return failure if at end of input */
  834.       if (po_gram_char == po_gram_EOF)
  835.     po_gram_ABORT;
  836.  
  837. #if po_gram_DEBUG != 0
  838.       if (po_gram_debug)
  839.     fprintf(stderr, "Discarding token %d (%s).\n", po_gram_char, po_gram_tname[po_gram_char1]);
  840. #endif
  841.  
  842.       po_gram_char = po_gram_EMPTY;
  843.     }
  844.  
  845.   /* Else will try to reuse lookahead token
  846.      after shifting the error token.  */
  847.  
  848.   po_gram_errstatus = 3;        /* Each real token shifted decrements this */
  849.  
  850.   goto po_gram_errhandle;
  851.  
  852. po_gram_errdefault:  /* current state does not do anything special for the error token. */
  853.  
  854. #if 0
  855.   /* This is wrong; only states that explicitly want error tokens
  856.      should shift them.  */
  857.   po_gram_n = po_gram_defact[po_gram_state];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  858.   if (po_gram_n) goto po_gram_default;
  859. #endif
  860.  
  861. po_gram_errpop:   /* pop the current state because it cannot handle the error token */
  862.  
  863.   if (po_gram_ssp == po_gram_ss) po_gram_ABORT;
  864.   po_gram_vsp--;
  865.   po_gram_state = *--po_gram_ssp;
  866. #ifdef po_gram_LSP_NEEDED
  867.   po_gram_lsp--;
  868. #endif
  869.  
  870. #if po_gram_DEBUG != 0
  871.   if (po_gram_debug)
  872.     {
  873.       short *ssp1 = po_gram_ss - 1;
  874.       fprintf (stderr, "Error: state stack now");
  875.       while (ssp1 != po_gram_ssp)
  876.     fprintf (stderr, " %d", *++ssp1);
  877.       fprintf (stderr, "\n");
  878.     }
  879. #endif
  880.  
  881. po_gram_errhandle:
  882.  
  883.   po_gram_n = po_gram_pact[po_gram_state];
  884.   if (po_gram_n == po_gram_FLAG)
  885.     goto po_gram_errdefault;
  886.  
  887.   po_gram_n += po_gram_TERROR;
  888.   if (po_gram_n < 0 || po_gram_n > po_gram_LAST || po_gram_check[po_gram_n] != po_gram_TERROR)
  889.     goto po_gram_errdefault;
  890.  
  891.   po_gram_n = po_gram_table[po_gram_n];
  892.   if (po_gram_n < 0)
  893.     {
  894.       if (po_gram_n == po_gram_FLAG)
  895.     goto po_gram_errpop;
  896.       po_gram_n = -po_gram_n;
  897.       goto po_gram_reduce;
  898.     }
  899.   else if (po_gram_n == 0)
  900.     goto po_gram_errpop;
  901.  
  902.   if (po_gram_n == po_gram_FINAL)
  903.     po_gram_ACCEPT;
  904.  
  905. #if po_gram_DEBUG != 0
  906.   if (po_gram_debug)
  907.     fprintf(stderr, "Shifting error token, ");
  908. #endif
  909.  
  910.   *++po_gram_vsp = po_gram_lval;
  911. #ifdef po_gram_LSP_NEEDED
  912.   *++po_gram_lsp = po_gram_lloc;
  913. #endif
  914.  
  915.   po_gram_state = po_gram_n;
  916.   goto po_gram_newstate;
  917. }
  918. #line 127 "../../src/po-gram.y"
  919.