lp_rlpt.c

lp_solve_5.5.0.13_xli_CPLEX_source.tar优化问题的求解

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
lpt_yy_symbol_print (FILE *lpt_yyoutput, int lpt_yytype, YYSTYPE const * const lpt_yyvaluep, parse_parm *parm, void *scanner)
#else
static void
lpt_yy_symbol_print (lpt_yyoutput, lpt_yytype, lpt_yyvaluep, parm, scanner)
    FILE *lpt_yyoutput;
    int lpt_yytype;
    YYSTYPE const * const lpt_yyvaluep;
    parse_parm *parm;
    void *scanner;
#endif
{
  if (lpt_yytype < YYNTOKENS)
    YYFPRINTF (lpt_yyoutput, "token %s (", lpt_yytname[lpt_yytype]);
  else
    YYFPRINTF (lpt_yyoutput, "nterm %s (", lpt_yytname[lpt_yytype]);

  lpt_yy_symbol_value_print (lpt_yyoutput, lpt_yytype, lpt_yyvaluep, parm, scanner);
  YYFPRINTF (lpt_yyoutput, ")");
}

/*------------------------------------------------------------------.
| lpt_yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included).                                                   |
`------------------------------------------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
lpt_yy_stack_print (lpt_yytype_int16 *bottom, lpt_yytype_int16 *top)
#else
static void
lpt_yy_stack_print (bottom, top)
    lpt_yytype_int16 *bottom;
    lpt_yytype_int16 *top;
#endif
{
  YYFPRINTF (stderr, "Stack now");
  for (; bottom <= top; ++bottom)
    YYFPRINTF (stderr, " %d", *bottom);
  YYFPRINTF (stderr, "\n");
}

# define YY_STACK_PRINT(Bottom, Top)				\
do {								\
  if (lpt_yydebug)							\
    lpt_yy_stack_print ((Bottom), (Top));				\
} while (YYID (0))


/*------------------------------------------------.
| Report that the YYRULE is going to be reduced.  |
`------------------------------------------------*/

#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
lpt_yy_reduce_print (YYSTYPE *lpt_yyvsp, int lpt_yyrule, parse_parm *parm, void *scanner)
#else
static void
lpt_yy_reduce_print (lpt_yyvsp, lpt_yyrule, parm, scanner)
    YYSTYPE *lpt_yyvsp;
    int lpt_yyrule;
    parse_parm *parm;
    void *scanner;
#endif
{
  int lpt_yynrhs = lpt_yyr2[lpt_yyrule];
  int lpt_yyi;
  unsigned long int lpt_yylno = lpt_yyrline[lpt_yyrule];
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
	     lpt_yyrule - 1, lpt_yylno);
  /* The symbols being reduced.  */
  for (lpt_yyi = 0; lpt_yyi < lpt_yynrhs; lpt_yyi++)
    {
      fprintf (stderr, "   $%d = ", lpt_yyi + 1);
      lpt_yy_symbol_print (stderr, lpt_yyrhs[lpt_yyprhs[lpt_yyrule] + lpt_yyi],
		       &(lpt_yyvsp[(lpt_yyi + 1) - (lpt_yynrhs)])
		       		       , parm, scanner);
      fprintf (stderr, "\n");
    }
}

# define YY_REDUCE_PRINT(Rule)		\
do {					\
  if (lpt_yydebug)				\
    lpt_yy_reduce_print (lpt_yyvsp, Rule, parm, scanner); \
} while (YYID (0))

/* Nonzero means print parse trace.  It is left uninitialized so that
   multiple parsers can coexist.  */
int lpt_yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */


/* YYINITDEPTH -- initial size of the parser's stacks.  */
#ifndef	YYINITDEPTH
# define YYINITDEPTH 200
#endif

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif



#if YYERROR_VERBOSE

# ifndef lpt_yystrlen
#  if defined __GLIBC__ && defined _STRING_H
#   define lpt_yystrlen strlen
#  else
/* Return the length of YYSTR.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
lpt_yystrlen (const char *lpt_yystr)
#else
static YYSIZE_T
lpt_yystrlen (lpt_yystr)
    const char *lpt_yystr;
#endif
{
  YYSIZE_T lpt_yylen;
  for (lpt_yylen = 0; lpt_yystr[lpt_yylen]; lpt_yylen++)
    continue;
  return lpt_yylen;
}
#  endif
# endif

# ifndef lpt_yystpcpy
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
#   define lpt_yystpcpy stpcpy
#  else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
   YYDEST.  */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static char *
lpt_yystpcpy (char *lpt_yydest, const char *lpt_yysrc)
#else
static char *
lpt_yystpcpy (lpt_yydest, lpt_yysrc)
    char *lpt_yydest;
    const char *lpt_yysrc;
#endif
{
  char *lpt_yyd = lpt_yydest;
  const char *lpt_yys = lpt_yysrc;

  while ((*lpt_yyd++ = *lpt_yys++) != '\0')
    continue;

  return lpt_yyd - 1;
}
#  endif
# endif

# ifndef lpt_yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
   quotes and backslashes, so that it's suitable for lpt_yyerror.  The
   heuristic is that double-quoting is unnecessary unless the string
   contains an apostrophe, a comma, or backslash (other than
   backslash-backslash).  YYSTR is taken from lpt_yytname.  If YYRES is
   null, do not copy; instead, return the length of what the result
   would have been.  */
static YYSIZE_T
lpt_yytnamerr (char *lpt_yyres, const char *lpt_yystr)
{
  if (*lpt_yystr == '"')
    {
      YYSIZE_T lpt_yyn = 0;
      char const *lpt_yyp = lpt_yystr;

      for (;;)
	switch (*++lpt_yyp)
	  {
	  case '\'':
	  case ',':
	    goto do_not_strip_quotes;

	  case '\\':
	    if (*++lpt_yyp != '\\')
	      goto do_not_strip_quotes;
	    /* Fall through.  */
	  default:
	    if (lpt_yyres)
	      lpt_yyres[lpt_yyn] = *lpt_yyp;
	    lpt_yyn++;
	    break;

	  case '"':
	    if (lpt_yyres)
	      lpt_yyres[lpt_yyn] = '\0';
	    return lpt_yyn;
	  }
    do_not_strip_quotes: ;
    }

  if (! lpt_yyres)
    return lpt_yystrlen (lpt_yystr);

  return lpt_yystpcpy (lpt_yyres, lpt_yystr) - lpt_yyres;
}
# endif

/* Copy into YYRESULT an error message about the unexpected token
   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
   including the terminating null byte.  If YYRESULT is null, do not
   copy anything; just return the number of bytes that would be
   copied.  As a special case, return 0 if an ordinary "syntax error"
   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
   size calculation.  */
static YYSIZE_T
lpt_yysyntax_error (char *lpt_yyresult, int lpt_yystate, int lpt_yychar)
{
  int lpt_yyn = lpt_yypact[lpt_yystate];

  if (! (YYPACT_NINF < lpt_yyn && lpt_yyn <= YYLAST))
    return 0;
  else
    {
      int lpt_yytype = YYTRANSLATE (lpt_yychar);
      YYSIZE_T lpt_yysize0 = lpt_yytnamerr (0, lpt_yytname[lpt_yytype]);
      YYSIZE_T lpt_yysize = lpt_yysize0;
      YYSIZE_T lpt_yysize1;
      int lpt_yysize_overflow = 0;
      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
      char const *lpt_yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
      int lpt_yyx;

# if 0
      /* This is so xgettext sees the translatable formats that are
	 constructed on the fly.  */
      YY_("syntax error, unexpected %s");
      YY_("syntax error, unexpected %s, expecting %s");
      YY_("syntax error, unexpected %s, expecting %s or %s");
      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
# endif
      char *lpt_yyfmt;
      char const *lpt_yyf;
      static char const lpt_yyunexpected[] = "syntax error, unexpected %s";
      static char const lpt_yyexpecting[] = ", expecting %s";
      static char const lpt_yyor[] = " or %s";
      char lpt_yyformat[sizeof lpt_yyunexpected
		    + sizeof lpt_yyexpecting - 1
		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
		       * (sizeof lpt_yyor - 1))];
      char const *lpt_yyprefix = lpt_yyexpecting;

      /* Start YYX at -YYN if negative to avoid negative indexes in
	 YYCHECK.  */
      int lpt_yyxbegin = lpt_yyn < 0 ? -lpt_yyn : 0;

      /* Stay within bounds of both lpt_yycheck and lpt_yytname.  */
      int lpt_yychecklim = YYLAST - lpt_yyn + 1;
      int lpt_yyxend = lpt_yychecklim < YYNTOKENS ? lpt_yychecklim : YYNTOKENS;
      int lpt_yycount = 1;

      lpt_yyarg[0] = lpt_yytname[lpt_yytype];
      lpt_yyfmt = lpt_yystpcpy (lpt_yyformat, lpt_yyunexpected);

      for (lpt_yyx = lpt_yyxbegin; lpt_yyx < lpt_yyxend; ++lpt_yyx)
	if (lpt_yycheck[lpt_yyx + lpt_yyn] == lpt_yyx && lpt_yyx != YYTERROR)
	  {
	    if (lpt_yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
	      {
		lpt_yycount = 1;
		lpt_yysize = lpt_yysize0;
		lpt_yyformat[sizeof lpt_yyunexpected - 1] = '\0';
		break;
	      }
	    lpt_yyarg[lpt_yycount++] = lpt_yytname[lpt_yyx];
	    lpt_yysize1 = lpt_yysize + lpt_yytnamerr (0, lpt_yytname[lpt_yyx]);
	    lpt_yysize_overflow |= (lpt_yysize1 < lpt_yysize);
	    lpt_yysize = lpt_yysize1;
	    lpt_yyfmt = lpt_yystpcpy (lpt_yyfmt, lpt_yyprefix);
	    lpt_yyprefix = lpt_yyor;
	  }

      lpt_yyf = YY_(lpt_yyformat);
      lpt_yysize1 = lpt_yysize + lpt_yystrlen (lpt_yyf);
      lpt_yysize_overflow |= (lpt_yysize1 < lpt_yysize);
      lpt_yysize = lpt_yysize1;

      if (lpt_yysize_overflow)
	return YYSIZE_MAXIMUM;

      if (lpt_yyresult)
	{
	  /* Avoid sprintf, as that infringes on the user's name space.
	     Don't have undefined behavior even if the translation
	     produced a string with the wrong number of "%s"s.  */
	  char *lpt_yyp = lpt_yyresult;
	  int lpt_yyi = 0;
	  while ((*lpt_yyp = *lpt_yyf) != '\0')
	    {
	      if (*lpt_yyp == '%' && lpt_yyf[1] == 's' && lpt_yyi < lpt_yycount)
		{
		  lpt_yyp += lpt_yytnamerr (lpt_yyp, lpt_yyarg[lpt_yyi++]);
		  lpt_yyf += 2;
		}
	      else
		{
		  lpt_yyp++;
		  lpt_yyf++;
		}
	    }
	}
      return lpt_yysize;
    }
}
#endif /* YYERROR_VERBOSE */


/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
static void
lpt_yydestruct (const char *lpt_yymsg, int lpt_yytype, YYSTYPE *lpt_yyvaluep, parse_parm *parm, void *scanner)
#else
static void
lpt_yydestruct (lpt_yymsg, lpt_yytype, lpt_yyvaluep, parm, scanner)
    const char *lpt_yymsg;
    int lpt_yytype;
    YYSTYPE *lpt_yyvaluep;
    parse_parm *parm;
    void *scanner;
#endif
{
  YYUSE (lpt_yyvaluep);
  YYUSE (parm);
  YYUSE (scanner);

  if (!lpt_yymsg)
    lpt_yymsg = "Deleting";
  YY_SYMBOL_PRINT (lpt_yymsg, lpt_yytype, lpt_yyvaluep, lpt_yylocationp);

  switch (lpt_yytype)
    {

      default:
	break;
    }
}


/* Prevent warnings from -Wmissing-prototypes.  */

#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int lpt_yyparse (void *YYPARSE_PARAM);
#else
int lpt_yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
#if defined __STDC__ || defined __cplusplus
int lpt_yyparse (parse_parm *parm, void *scanner);
#else
int lpt_yyparse ();
#endif
#endif /* ! YYPARSE_PARAM */






/*----------.
| lpt_yyparse.  |
`----------*/

#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
lpt_yyparse (void *YYPARSE_PARAM)
#else
int
lpt_yyparse (YYPARSE_PARAM)
    void *YYPARSE_PARAM;
#endif
#else /* ! YYPARSE_PARAM */
#if (defined __STDC__ || defined __C99__FUNC__ \
     || defined __cplusplus || defined _MSC_VER)
int
lpt_yyparse (parse_parm *parm, void *scanner)
#else
int
lpt_yyparse (parm, scanner)
    parse_parm *parm;
    void *scanner;
#endif
#endif
{
  /* The look-ahead symbol.  */
int lpt_yychar;

/* The semantic value of the look-ahead symbol.  */
YYSTYPE lpt_yylval;

/* Number of syntax errors so far.  */
int lpt_yynerrs;

  int lpt_yystate;
  int lpt_yyn;
  int lpt_yyresult;
  /* Number of tokens to shift before error messages enabled.  */
  int lpt_yyerrstatus;
  /* Look-ahead token as an internal (translated) token number.  */
  int lpt_yytoken = 0;
#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char lpt_yymsgbuf[128];
  char *lpt_yymsg = lpt_yymsgbuf;
  YYSIZE_T lpt_yymsg_alloc = sizeof lpt_yymsgbuf;
#endif

  /* Three stacks and their tools:
     `lpt_yyss': related to states,
     `lpt_yyvs': related to semantic values,
     `lpt_yyls': related to locations.

     Refer to the stacks thru separate pointers, to allow lpt_yyoverflow
     to reallocate them elsewhere.  */

  /* The state stack.  */
  lpt_yytype_int16 lpt_yyssa[YYINITDEPTH];
  lpt_yytype_int16 *lpt_yyss = lpt_yyssa;
  lpt_yytype_int16 *lpt_yyssp;

  /* The semantic value stack.  */
  YYSTYPE lpt_yyvsa[YYINITDEPTH];
  YYSTYPE *lpt_yyvs = lpt_yyvsa;
  YYSTYPE *lpt_yyvsp;