generated with bison 1.28 which removes the alloca() mess!

/*  A Bison parser, made from getdate.y with Bison version GNU Bison version 1.21

  */

/*  A Bison parser, made from getdate.y

    by GNU Bison version 1.28  */

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

#define	tAGO	258

#define	tDAY	259

#define	tDAY_UNIT	260

#define	tDAYZONE	261

#define	tDST	262

#define	tHOUR_UNIT	263

#define	tID	264

#define	tMERIDIAN	265

#define	tMINUTE_UNIT	266

#define	tMONTH	267

#define	tMONTH_UNIT	268

#define	tSEC_UNIT	269

#define	tSNUMBER	270

#define	tUNUMBER	271

#define	tYEAR_UNIT	272

#define	tZONE	273

#define	tAGO	257

#define	tDAY	258

#define	tDAY_UNIT	259

#define	tDAYZONE	260

#define	tDST	261

#define	tHOUR_UNIT	262

#define	tID	263

#define	tMERIDIAN	264

#define	tMINUTE_UNIT	265

#define	tMONTH	266

#define	tMONTH_UNIT	267

#define	tSEC_UNIT	268

#define	tSNUMBER	269

#define	tUNUMBER	270

#define	tYEAR_UNIT	271

#define	tZONE	272

#line 1 "getdate.y"

    int			Number;

    enum _MERIDIAN	Meridian;

} YYSTYPE;

#ifndef YYLTYPE

typedef

  struct yyltype

    {

      int timestamp;

      int first_line;

      int first_column;

      int last_line;

      int last_column;

      char *text;

   }

  yyltype;

#define YYLTYPE yyltype

#endif

#include <stdio.h>

#ifndef __cplusplus

#define	YYFLAG		-32768

#define	YYNTBASE	22

#define YYTRANSLATE(x) ((unsigned)(x) <= 273 ? yytranslate[x] : 32)

#define YYTRANSLATE(x) ((unsigned)(x) <= 272 ? yytranslate[x] : 32)

static const char yytranslate[] = {     0,

     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,

     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,

    16,    17,    18

     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,

     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,

    17,    18

};

#if YYDEBUG != 0

   366,   369,   372,   375,   378,   381,   384,   387,   390,   393,

   396,   399,   402,   405,   408,   411,   414,   419,   452,   456

};

#endif

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

static const char * const yytname[] = {   "$","error","$illegal.","tAGO","tDAY",

static const char * const yytname[] = {   "$","error","$undefined.","tAGO","tDAY",

"tDAY_UNIT","tDAYZONE","tDST","tHOUR_UNIT","tID","tMERIDIAN","tMINUTE_UNIT",

"tMONTH","tMONTH_UNIT","tSEC_UNIT","tSNUMBER","tUNUMBER","tYEAR_UNIT","tZONE",

"':'","','","'/'","spec","item","time","zone","day","date","rel","relunit","number",

"o_merid",""

"o_merid", NULL

};

#endif

    56

};

/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */

#line 3 "/usr/gnu/lib/bison.simple"

#line 3 "/usr/local/share/bison.simple"

/* This file comes from bison-1.28.  */

/* Skeleton output parser for bison,

   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman

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

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 1, or (at your option)

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

/* As a special exception, when this file is copied by Bison into a

   Bison output file, you may use that output file without restriction.

   This special exception was added by the Free Software Foundation

   in version 1.24 of Bison.  */

#ifndef alloca

/* This is the parser code that is written into each bison parser

  when the %semantic_parser declaration is not specified in the grammar.

  It was written by Richard Stallman by simplifying the hairy parser

  used when %semantic_parser is specified.  */

#ifndef YYSTACK_USE_ALLOCA

#ifdef alloca

#define YYSTACK_USE_ALLOCA

#else /* alloca not defined */

#ifdef __GNUC__

#define YYSTACK_USE_ALLOCA

#define alloca __builtin_alloca

#else /* not GNU C.  */

#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)

#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))

#define YYSTACK_USE_ALLOCA

#include <alloca.h>

#else /* not sparc */

#if defined (MSDOS) && !defined (__TURBOC__)

/* We think this test detects Watcom and Microsoft C.  */

/* This used to test MSDOS, but that is a bad idea

   since that symbol is in the user namespace.  */

#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)

#if 0 /* No need for malloc.h, which pollutes the namespace;

	 instead, just don't use alloca.  */

#include <malloc.h>

#endif

#else /* not MSDOS, or __TURBOC__ */

#if defined(_AIX)

#include <malloc.h>

/* I don't know what this was needed for, but it pollutes the namespace.

   So I turned it off.   rms, 2 May 1997.  */

/* #include <malloc.h>  */

 #pragma alloca

#else /* not MSDOS, __TURBOC__, or _AIX */

#ifdef __hpux

#ifdef __cplusplus

extern "C" {

void *alloca (unsigned int);

};

#else /* not __cplusplus */

void *alloca (unsigned int);

#endif /* not __cplusplus */

#define YYSTACK_USE_ALLOCA

#else /* not MSDOS, or __TURBOC__, or _AIX */

#if 0

#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,

		 and on HPUX 10.  Eventually we can turn this on.  */

#define YYSTACK_USE_ALLOCA

#define alloca __builtin_alloca

#endif /* __hpux */

#endif

#endif /* not _AIX */

#endif /* not MSDOS, or __TURBOC__ */

#endif /* not sparc.  */

#endif /* not GNU C.  */

#endif /* alloca not defined.  */

#endif /* not sparc */

#endif /* not GNU C */

#endif /* alloca not defined */

#endif /* YYSTACK_USE_ALLOCA not defined */

/* This is the parser code that is written into each bison parser

  when the %semantic_parser declaration is not specified in the grammar.

  It was written by Richard Stallman by simplifying the hairy parser

  used when %semantic_parser is specified.  */

#ifdef YYSTACK_USE_ALLOCA

#define YYSTACK_ALLOC alloca

#else

#define YYSTACK_ALLOC malloc

#endif

/* Note: there must be only one dollar sign in this file.

   It is replaced by the list of actions, each action

#define yyclearin	(yychar = YYEMPTY)

#define YYEMPTY		-2

#define YYEOF		0

#define YYACCEPT	return(0)

#define YYABORT 	return(1)

#define YYACCEPT	goto yyacceptlab

#define YYABORT 	goto yyabortlab

#define YYERROR		goto yyerrlab1

/* Like YYERROR except do call yyerror.

   This remains here temporarily to ease the

#ifdef YYPURE

#ifdef YYLSP_NEEDED

#ifdef YYLEX_PARAM

#define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)

#else

#define YYLEX		yylex(&yylval, &yylloc)

#endif

#else /* not YYLSP_NEEDED */

#ifdef YYLEX_PARAM

#define YYLEX		yylex(&yylval, YYLEX_PARAM)

#else

#define YYLEX		yylex(&yylval)

#endif

#endif /* not YYLSP_NEEDED */

#endif

/* If nonreentrant, generate the variables here */

#ifndef YYMAXDEPTH

#define YYMAXDEPTH 10000

#endif

/* Prevent warning if -Wstrict-prototypes.  */

#ifdef __GNUC__

int yyparse (void);

#endif

/* Define __yy_memcpy.  Note that the size argument

   should be passed with type unsigned int, because that is what the non-GCC

   definitions require.  With GCC, __builtin_memcpy takes an arg

   of type size_t, but it can handle unsigned int.  */

#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */

#define __yy_bcopy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)

#define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)

#else				/* not GNU C or C++ */

#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities

   in available built-in functions on various systems.  */

static void

__yy_bcopy (from, to, count)

     char *from;

__yy_memcpy (to, from, count)

     char *to;

     int count;

     char *from;

     unsigned int count;

{

  register char *f = from;

  register char *t = to;

/* This is the most reliable way to avoid incompatibilities

   in available built-in functions on various systems.  */

static void

__yy_bcopy (char *from, char *to, int count)

__yy_memcpy (char *to, char *from, unsigned int count)

{

  register char *f = from;

  register char *t = to;

  register char *f = from;

  register int i = count;

  while (i-- > 0)

#endif

#endif

#line 184 "/usr/gnu/lib/bison.simple"

#line 217 "/usr/local/share/bison.simple"

/* The user can define YYPARSE_PARAM as the name of an argument to be passed

   into yyparse.  The argument should have type void *.

   It should actually point to an object.

   Grammar actions can access the variable by casting it

   to the proper pointer type.  */

#ifdef YYPARSE_PARAM

#ifdef __cplusplus

#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM

#define YYPARSE_PARAM_DECL

#else /* not __cplusplus */

#define YYPARSE_PARAM_ARG YYPARSE_PARAM

#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;

#endif /* not __cplusplus */

#else /* not YYPARSE_PARAM */

#define YYPARSE_PARAM_ARG

#define YYPARSE_PARAM_DECL

#endif /* not YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */

#ifdef __GNUC__

#ifdef YYPARSE_PARAM

int yyparse (void *);

#else

int yyparse (void);

#endif

#endif

int

yyparse()

yyparse(YYPARSE_PARAM_ARG)

     YYPARSE_PARAM_DECL

{

  register int yystate;

  register int yyn;

  register short *yyssp;

  register YYSTYPE *yyvsp;

  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */

  int yychar1;		/*  lookahead token as an internal (translated) token number */

  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */

  short	yyssa[YYINITDEPTH];	/*  the state stack			*/

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

#endif

  int yystacksize = YYINITDEPTH;

  int yyfree_stacks = 0;

#ifdef YYPURE

  int yychar;

#ifdef yyoverflow

      /* Each stack pointer address is followed by the size of

	 the data in use in that stack, in bytes.  */

#ifdef YYLSP_NEEDED

      /* This used to be a conditional around just the two extra args,

	 but that might be undefined if yyoverflow is a macro.  */

      yyoverflow("parser stack overflow",

		 &yyss1, size * sizeof (*yyssp),

		 &yyvs1, size * sizeof (*yyvsp),

#ifdef YYLSP_NEEDED

		 &yyls1, size * sizeof (*yylsp),

#endif

		 &yystacksize);

#else

      yyoverflow("parser stack overflow",

		 &yyss1, size * sizeof (*yyssp),

		 &yyvs1, size * sizeof (*yyvsp),

		 &yystacksize);

#endif

      yyss = yyss1; yyvs = yyvs1;

#ifdef YYLSP_NEEDED

      if (yystacksize >= YYMAXDEPTH)

	{

	  yyerror("parser stack overflow");

	  if (yyfree_stacks)

	    {

	      free (yyss);

	      free (yyvs);

#ifdef YYLSP_NEEDED

	      free (yyls);

#endif

	    }

	  return 2;

	}

      yystacksize *= 2;

      if (yystacksize > YYMAXDEPTH)

	yystacksize = YYMAXDEPTH;

      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));

      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));

      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));

      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));

#ifndef YYSTACK_USE_ALLOCA

      yyfree_stacks = 1;

#endif

      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));

      __yy_memcpy ((char *)yyss, (char *)yyss1,

		   size * (unsigned int) sizeof (*yyssp));

      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));

      __yy_memcpy ((char *)yyvs, (char *)yyvs1,

		   size * (unsigned int) sizeof (*yyvsp));

#ifdef YYLSP_NEEDED

      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));

      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));

      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));

      __yy_memcpy ((char *)yyls, (char *)yyls1,

		   size * (unsigned int) sizeof (*yylsp));

#endif

#endif /* no yyoverflow */

/* Do a reduction.  yyn is the number of a rule to reduce with.  */

yyreduce:

  yylen = yyr2[yyn];

  if (yylen > 0)

    yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0

    break;}

}

   /* the action file gets copied in in place of this dollarsign */

#line 457 "/usr/gnu/lib/bison.simple"

#line 543 "/usr/local/share/bison.simple"

  yyvsp -= yylen;

  yyssp -= yylen;

  yystate = yyn;

  goto yynewstate;

 yyacceptlab:

  /* YYACCEPT comes here.  */

  if (yyfree_stacks)

    {

      free (yyss);

      free (yyvs);

#ifdef YYLSP_NEEDED

      free (yyls);

#endif

    }

  return 0;

 yyabortlab:

  /* YYABORT comes here.  */

  if (yyfree_stacks)

    {

      free (yyss);

      free (yyvs);

#ifdef YYLSP_NEEDED

      free (yyls);

#endif

    }

  return 1;

}

#line 462 "getdate.y"