[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Staging #OBR-846828]: make error



Taimaz,

> The "fgrep" output is attached

The output was the following:

                        YYACCEPT;
                        YYACCEPT;

The "#define YYACCEPT ..." line is definitely missing.

I suspect that your file "src/lib/utparse.c" has somehow been corrupted or 
modified. I've attached a replacement for the file. Use it and tell me what 
happens.

Regards,
Steve Emmerson

Ticket Details
===================
Ticket ID: OBR-846828
Department: Support UDUNITS
Priority: Normal
Status: Closed
#ifndef lint
static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
#endif

#include <stdlib.h>

#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYPATCH 20050813

#define YYEMPTY (-1)
#define yyclearin    (yychar = YYEMPTY)
#define yyerrok      (yyerrflag = 0)
#define YYRECOVERING (yyerrflag != 0)

extern int yyparse(void);

static int yygrowstack(void);
#define yyparse utparse
#define yylex utlex
#define yyerror uterror
#define yychar utchar
#define yyval utval
#define yylval utlval
#define yydebug utdebug
#define yynerrs utnerrs
#define yyerrflag uterrflag
#define yyss utss
#define yyssp utssp
#define yyvs utvs
#define yyvsp utvsp
#define yylhs utlhs
#define yylen utlen
#define yydefred utdefred
#define yydgoto utdgoto
#define yysindex utsindex
#define yyrindex utrindex
#define yygindex utgindex
#define yytable uttable
#define yycheck utcheck
#define yyname utname
#define yyrule utrule
#define YYPREFIX "ut"
#line 2 "utparse.y"
/*
 * $Id: utparse.c,v 1.4 2008/07/22 18:24:34 steve Exp $
 *
 * yacc(1)-based parser for decoding formatted units(3) specifications.
 */

/*LINTLIBRARY*/

#include <stdio.h>
#include <string.h>
#include "udunits.h"
#include "utscan.h"
#include "utprivate.h"

/*
 * Allocate storage for the package global variables, which are declared in
 * header file "utprivate.h".
 */
int     UtLineno;               /* input-file line index */
int     UnitNotFound;           /* parser didn't find unit */
utUnit  *FinalUnit;             /* fully-parsed specification */

#line 26 "utparse.y"
typedef union {
    double      rval;                   /* floating-point numerical value */
    long        ival;                   /* integer numerical value */
    char        name[UT_NAMELEN];       /* name of a quantity */
    utUnit      unit;                   /* "unit" structure */
} YYSTYPE;
#line 76 "y.tab.c"
#define INT 257
#define ERR 258
#define SHIFT 259
#define SPACE 260
#define MULTIPLY 261
#define DIVIDE 262
#define EXPONENT 263
#define REAL 264
#define NAME 265
#define DATE 266
#define TIME 267
#define ZONE 268
#define YYERRCODE 256
short utlhs[] = {                                        -1,
    0,    0,    0,    9,    9,    9,    5,    5,    5,    5,
    6,    6,    6,    7,    7,    7,    8,    8,    2,    2,
    1,    1,    3,    3,    4,    4,    4,
};
short utlen[] = {                                         2,
    0,    1,    1,    1,    3,    3,    1,    2,    3,    3,
    1,    2,    3,    1,    1,    3,    1,    2,    1,    3,
    1,    1,    1,    3,    1,    2,    3,
};
short utdefred[] = {                                      0,
    3,   21,   22,    0,    0,    0,   14,    0,    0,   11,
   15,    2,   18,    0,    0,    0,    0,    0,   12,    0,
   16,    0,    0,   19,    5,    6,   23,    0,    0,   13,
    0,    0,    0,   27,   20,   24,
};
short utdgoto[] = {                                       6,
    7,   25,   26,   27,    8,    9,   10,   11,   12,
};
short utsindex[] = {                                    -24,
    0,    0,    0, -250,  -28,    0,    0,  -34, -239,    0,
    0,    0,    0,  -31,  -40,  -28,  -28, -239,    0, -246,
    0, -248,  -40,    0,    0,    0,    0, -239, -239,    0,
 -247,  -21,  -18,    0,    0,    0,
};
short utrindex[] = {                                     25,
    0,    0,    0,    1,    0,    0,    0,    2,    8,    0,
    0,    0,    0,    0,    0,    0,    0,   15,    0,    0,
    0,    3,    0,    0,    0,    0,    0,   22,   29,    0,
    4,    0,    0,    0,    0,    0,
};
short utgindex[] = {                                      0,
   -6,    5,    7,    0,    0,   -3,    0,    0,   21,
};
#define YYTABLESIZE 294
short uttable[] = {                                      23,
   17,    4,   25,   26,   18,    5,   13,    7,   24,   21,
   30,    5,   28,   29,    8,    5,   24,   19,   31,   35,
   34,    9,   36,   20,    1,   14,    0,   32,   10,   33,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   17,   17,    4,   25,   26,    0,    0,    7,    7,    0,
    0,    0,    0,    0,    8,    8,    0,    0,    0,    0,
    0,    9,    9,    0,    0,    0,    0,    0,   10,   10,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    2,    0,    0,    0,
    0,    0,    2,    3,   15,   22,   16,   17,    2,    3,
    4,    1,    2,    0,    0,    3,    4,    0,    0,    3,
    4,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,   17,
    0,   17,   17,   17,   17,   17,    7,    0,    7,    7,
    0,    7,    7,    8,    0,    8,    8,    0,    8,    8,
    9,    0,    9,    9,    0,    9,    9,   10,    0,   10,
   10,    0,   10,   10,
};
short utcheck[] = {                                      40,
    0,    0,    0,    0,    8,   40,  257,    0,   15,   41,
  257,   40,   16,   17,    0,   40,   23,  257,  267,   41,
  268,    0,   41,  263,    0,    5,   -1,   23,    0,   23,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   40,   41,   41,   41,   41,   -1,   -1,   40,   41,   -1,
   -1,   -1,   -1,   -1,   40,   41,   -1,   -1,   -1,   -1,
   -1,   40,   41,   -1,   -1,   -1,   -1,   -1,   40,   41,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,   -1,
   -1,   -1,  257,  264,  259,  266,  261,  262,  257,  264,
  265,  256,  257,   -1,   -1,  264,  265,   -1,   -1,  264,
  265,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,
   -1,  261,  262,  263,  264,  265,  259,   -1,  261,  262,
   -1,  264,  265,  259,   -1,  261,  262,   -1,  264,  265,
  259,   -1,  261,  262,   -1,  264,  265,  259,   -1,  261,
  262,   -1,  264,  265,
};
#define YYFINAL 6
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 268
#if YYDEBUG
char *utname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,"'('","')'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"INT","ERR","SHIFT",
"SPACE","MULTIPLY","DIVIDE","EXPONENT","REAL","NAME","DATE","TIME","ZONE",
};
char *utrule[] = {
"$accept : unit_spec",
"unit_spec :",
"unit_spec : origin_exp",
"unit_spec : error",
"origin_exp : unit_exp",
"origin_exp : unit_exp SHIFT value_exp",
"origin_exp : unit_exp SHIFT timestamp",
"unit_exp : power_exp",
"unit_exp : unit_exp power_exp",
"unit_exp : unit_exp MULTIPLY power_exp",
"unit_exp : unit_exp DIVIDE power_exp",
"power_exp : factor_exp",
"power_exp : power_exp INT",
"power_exp : power_exp EXPONENT INT",
"factor_exp : number_exp",
"factor_exp : quant_exp",
"factor_exp : '(' origin_exp ')'",
"quant_exp : NAME",
"quant_exp : NAME INT",
"value_exp : number_exp",
"value_exp : '(' value_exp ')'",
"number_exp : INT",
"number_exp : REAL",
"timestamp : time_exp",
"timestamp : '(' timestamp ')'",
"time_exp : DATE",
"time_exp : DATE TIME",
"time_exp : DATE TIME ZONE",
};
#endif
#if YYDEBUG
#include <stdio.h>
#endif

/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH  YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH  500
#endif
#endif

#define YYINITSTACKSIZE 500

int      yydebug;
int      yynerrs;
int      yyerrflag;
int      yychar;
short   *yyssp;
YYSTYPE *yyvsp;
YYSTYPE  yyval;
YYSTYPE  yylval;

/* variables for the parser stack */
static short   *yyss;
static short   *yysslim;
static YYSTYPE *yyvs;
static int      yystacksize;
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(void)
{
    int newsize, i;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;

    i = yyssp - yyss;
    newss = (yyss != 0)
          ? (short *)realloc(yyss, newsize * sizeof(*newss))
          : (short *)malloc(newsize * sizeof(*newss));
    if (newss == 0)
        return -1;

    yyss  = newss;
    yyssp = newss + i;
    newvs = (yyvs != 0)
          ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
          : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
    if (newvs == 0)
        return -1;

    yyvs = newvs;
    yyvsp = newvs + i;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse(void)
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register const char *yys;

    if ((yys = getenv("YYDEBUG")) != 0)
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = YYEMPTY;

    if (yyss == NULL && yygrowstack()) goto yyoverflow;
    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yysslim && yygrowstack())
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = YYEMPTY;
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;

    yyerror("syntax error");

#ifdef lint
    goto yyerrlab;
#endif

yyerrlab:
    ++yynerrs;

yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yysslim && yygrowstack())
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = YYEMPTY;
        goto yyloop;
    }

yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 1:
#line 59 "utparse.y"
{
                        YYACCEPT;
                  }
break;
case 2:
#line 62 "utparse.y"
{
                        (void)utCopy(&yyvsp[0].unit, FinalUnit);
                        YYACCEPT;
                  }
break;
case 3:
#line 66 "utparse.y"
{
                        yyerrok;
                        yyclearin;
                        YYABORT;
                  }
break;
case 4:
#line 73 "utparse.y"
{
                        (void)utCopy(&yyvsp[0].unit, &yyval.unit);
                  }
break;
case 5:
#line 76 "utparse.y"
{
                        if (utIsTime(&yyvsp[-2].unit)) {
                            /*
                             * The shift amount is divided by the unit scale
                             * factor in the following because the shift amount
                             * must be in the units of the first argument (e.g.
                             * 0.555556 kelvins for the fahrenheit unit) and a
                             * timestamp isn't necessarily so proportioned.
                            (void)utShift(&$1, $3, &$$);
                             */
                            (void)utShift(&yyvsp[-2].unit, 
yyvsp[0].rval/yyvsp[-2].unit.factor, &yyval.unit);
                        } else {
                            (void) utShift(&yyvsp[-2].unit, yyvsp[0].rval, 
&yyval.unit);
                        }
                  }
break;
case 6:
#line 91 "utparse.y"
{
                        if (utIsTime(&yyvsp[-2].unit)) {
                            (void)utShift(&yyvsp[-2].unit, 
yyvsp[0].rval/yyvsp[-2].unit.factor, &yyval.unit);
                        } else {
                            UnitNotFound        = 1;
                            YYERROR;
                        }
                  }
break;
case 7:
#line 101 "utparse.y"
{
                        (void)utCopy(&yyvsp[0].unit, &yyval.unit);
                  }
break;
case 8:
#line 104 "utparse.y"
{
                        (void)utMultiply(&yyvsp[-1].unit, &yyvsp[0].unit, 
&yyval.unit);
                  }
break;
case 9:
#line 107 "utparse.y"
{
                        (void)utMultiply(&yyvsp[-2].unit, &yyvsp[0].unit, 
&yyval.unit);
                  }
break;
case 10:
#line 110 "utparse.y"
{
                        (void)utDivide(&yyvsp[-2].unit, &yyvsp[0].unit, 
&yyval.unit);
                  }
break;
case 11:
#line 115 "utparse.y"
{
                        (void)utCopy(&yyvsp[0].unit, &yyval.unit);
                  }
break;
case 12:
#line 118 "utparse.y"
{
                        (void)utRaise(&yyvsp[-1].unit, yyvsp[0].ival, 
&yyval.unit);
                  }
break;
case 13:
#line 121 "utparse.y"
{
                        (void)utRaise(&yyvsp[-2].unit, yyvsp[0].ival, 
&yyval.unit);
                  }
break;
case 14:
#line 126 "utparse.y"
{
                        utUnit  unit;
                        (void)utScale(utClear(&unit), yyvsp[0].rval, 
&yyval.unit);
                  }
break;
case 15:
#line 130 "utparse.y"
{
                        (void)utCopy(&yyvsp[0].unit, &yyval.unit);
                  }
break;
case 16:
#line 133 "utparse.y"
{
                        (void)utCopy(&yyvsp[-1].unit, &yyval.unit);
                  }
break;
case 17:
#line 138 "utparse.y"
{
                        utUnit     unit;
                        if (utFind(yyvsp[0].name, &unit) != 0) {
                            UnitNotFound        = 1;
                            YYERROR;
                        }
                        (void)utCopy(&unit, &yyval.unit);
                  }
break;
case 18:
#line 146 "utparse.y"
{
                        utUnit     unit;
                        if (utFind(yyvsp[-1].name, &unit) != 0) {
                            UnitNotFound        = 1;
                            YYERROR;
                        }
                        (void)utRaise(&unit, yyvsp[0].ival, &yyval.unit);
                  }
break;
case 19:
#line 156 "utparse.y"
{ yyval.rval = yyvsp[0].rval; }
break;
case 20:
#line 157 "utparse.y"
{ yyval.rval = yyvsp[-1].rval; }
break;
case 21:
#line 160 "utparse.y"
{ yyval.rval = yyvsp[0].ival; }
break;
case 22:
#line 161 "utparse.y"
{ yyval.rval = yyvsp[0].rval; }
break;
case 23:
#line 164 "utparse.y"
{ yyval.rval = yyvsp[0].rval; }
break;
case 24:
#line 165 "utparse.y"
{ yyval.rval = yyvsp[-1].rval; }
break;
case 25:
#line 168 "utparse.y"
{ yyval.rval = yyvsp[0].rval; }
break;
case 26:
#line 169 "utparse.y"
{ yyval.rval = yyvsp[-1].rval + yyvsp[0].rval; }
break;
case 27:
#line 170 "utparse.y"
{ yyval.rval = yyvsp[-2].rval + (yyvsp[-1].rval - yyvsp[0].rval); }
break;
#line 621 "y.tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yysslim && yygrowstack())
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;

yyoverflow:
    yyerror("yacc stack overflow");

yyabort:
    return (1);

yyaccept:
    return (0);
}

NOTE: All email exchanges with Unidata User Support are recorded in the Unidata inquiry tracking system and then made publicly available through the web. If you do not want to have your interactions made available in this way, you must let us know in each email you send to us.