[BACK]Return to capaFormulaParser.c CVS log [TXT] [DIR] Up to [LON-CAPA] / capa / capa51 / pProj

Diff for /capa/capa51/pProj/Attic/capaFormulaParser.c between versions 1.1 and 1.2

version 1.1, 1999/09/28 21:26:21 version 1.2, 2000/06/27 18:28:48
Line 1 Line 1
 #ifndef lint  
 static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";  /*  A Bison parser, made from capaFormula.y
 #endif      by GNU Bison version 1.28  */
 #define YYBYACC 1  
 #define YYMAJOR 1  #define YYBISON 1  /* Identify Bison output.  */
 #define YYMINOR 9  
 #define yyclearin (yychar=(-1))  
 #define yyerrok (yyerrflag=0)  
 #define YYRECOVERING (yyerrflag!=0)  
 #define yyparse fml_parse  #define yyparse fml_parse
 #define yylex fml_lex  #define yylex fml_lex
 #define yyerror fml_error  #define yyerror fml_error
 #define yychar fml_char  
 #define yyval fml_val  
 #define yylval fml_lval  #define yylval fml_lval
   #define yychar fml_char
 #define yydebug fml_debug  #define yydebug fml_debug
 #define yynerrs fml_nerrs  #define yynerrs fml_nerrs
 #define yyerrflag fml_errflag  #define F_NUMBER 257
 #define yyss fml_ss  #define V_ID 258
 #define yyssp fml_ssp  #define F_ID 259
 #define yyvs fml_vs  #define EoI 260
 #define yyvsp fml_vsp  #define F_ERROR 261
 #define yylhs fml_lhs  #define F_PLUS 262
 #define yylen fml_len  #define F_MINUS 263
 #define yydefred fml_defred  #define F_MULT 264
 #define yydgoto fml_dgoto  #define F_DIV 265
 #define yysindex fml_sindex  #define F_MOD 266
 #define yyrindex fml_rindex  #define F_POW 267
 #define yygindex fml_gindex  #define F_LPAR 268
 #define yytable fml_table  #define F_RPAR 269
 #define yycheck fml_check  #define F_COMMA 270
 #define yyname fml_name  
 #define yyrule fml_rule  #line 7 "capaFormula.y"
 #define YYPREFIX "fml_"  
 #line 8 "capaFormula.y"  
 #include <stdio.h>  #include <stdio.h>
 #include <ctype.h>  #include <ctype.h>
 #include <string.h>  #include <string.h>
Line 40  static char yysccsid[] = "@(#)yaccpar 1. Line 35  static char yysccsid[] = "@(#)yaccpar 1.
 #include "capaParser.h"   /* _symbol structure def */  #include "capaParser.h"   /* _symbol structure def */
 #include "capaCommon.h"  #include "capaCommon.h"
 #include "capaFunction.h"  #include "capaFunction.h"
   #ifdef  YYSTYPE
   #undef  YYSTYPE
   #endif
   #define YYSTYPE  Symbol_p
 #include "capaToken.h"  #include "capaToken.h"
   
 #ifdef __hpux  #ifdef __hpux
Line 64  static char yysccsid[] = "@(#)yaccpar 1. Line 63  static char yysccsid[] = "@(#)yaccpar 1.
 #define IDIV_op         5  #define IDIV_op         5
 #define NOT_DEFINED_op  9  #define NOT_DEFINED_op  9
   
 #ifdef  YYSTYPE  
 #undef  YYSTYPE  
 #endif  
 #define YYSTYPE  Symbol_p  
   
 /* =============================================================== */  /* =============================================================== */
   
 extern      int         Func_idx;  extern      int         Func_idx;
 extern      Symbol      FuncStack[MAX_FUNC_NEST];  extern      Symbol      FuncStack[MAX_FUNC_NEST];
   void   fml_error(char *msg);
 double      FormulaVal;  double      FormulaVal;
 int         FormulaParseOK=1;  int         FormulaParseOK=1;
   
 #line 81 "fma.tab.c"  #ifndef YYSTYPE
 #define F_NUMBER 257  #define YYSTYPE int
 #define V_ID 258  #endif
 #define F_ID 259  #include <stdio.h>
 #define EoI 260  
 #define F_ERROR 261  #ifndef __cplusplus
 #define F_PLUS 262  #ifndef __STDC__
 #define F_MINUS 263  #define const
 #define F_MULT 264  #endif
 #define F_DIV 265  #endif
 #define F_MOD 266  
 #define F_POW 267  
 #define F_LPAR 268  
 #define F_RPAR 269  #define YYFINAL 38
 #define F_COMMA 270  #define YYFLAG -32768
 #define YYERRCODE 256  #define YYNTBASE 17
 short fml_lhs[] = {                                        -1,  
     0,    1,    1,    1,    1,    1,    2,    2,    2,    2,  #define YYTRANSLATE(x) ((unsigned)(x) <= 270 ? yytranslate[x] : 23)
     3,    3,    5,    5,    4,    4,    4,    4,    4,    4,  
     4,  static const char yytranslate[] = {     0,
 };       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 short fml_len[] = {                                         2,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     1,    3,    3,    1,    1,    1,    3,    3,    3,    1,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     3,    1,    3,    1,    3,    4,    1,    2,    2,    1,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     3,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 };       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 short fml_defred[] = {                                      0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     6,   20,   17,    0,    5,    0,    0,    0,    0,    0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,   12,    0,   19,   18,    0,    0,    0,    0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,    0,   15,    0,    0,   21,    0,    0,    0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,   11,   16,    0,    0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 };       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 short fml_dgoto[] = {                                       9,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    10,   11,   12,   13,   26,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 };       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 short fml_sindex[] = {                                   -227,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,    0, -266,    0, -219, -219, -227,    0, -241,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  -218, -262,    0, -245,    0,    0, -254, -219, -219, -219,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  -219, -219, -219,    0, -241, -244,    0, -218, -218, -262,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  -262, -262,    0,    0, -227, -241,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 };       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 short fml_rindex[] = {                                      0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    7,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    33,    1,    0,    0,    0,    0,    0,    0,    0,    0,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     0,    0,    0,    0, -216,    0,    0,   37,   42,   10,       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    19,   28,    0,    0,    0, -214,       2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 };       7,     8,     9,    10,    11,    12,    13,    14,    15,    16
 short fml_gindex[] = {                                      0,  };
    -8,   39,   30,   -3,    0,  
 };  #if YYDEBUG != 0
 #define YYTABLESIZE 312  static const short yyprhs[] = {     0,
 short fml_table[] = {                                      17,       0,     2,     6,    10,    12,    14,    16,    20,    24,    28,
    10,   14,   15,   16,   23,   25,    1,   18,   19,    7,      30,    34,    36,    40,    42,    46,    51,    53,    56,    59,
     1,    2,    3,    4,   27,    5,    6,    7,    8,   33,      61
    18,   19,    8,   24,   34,   35,   36,    9,    1,    2,  };
     3,    4,    4,    5,    6,    7,    2,    2,    3,    4,  
     8,    3,    6,    7,    0,   20,   21,   22,    8,   30,  static const short yyrhs[] = {    18,
    31,   32,   14,   14,   13,   13,   28,   29,    0,    0,       0,    18,     8,    19,     0,    18,     9,    19,     0,    19,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,       0,     7,     0,     1,     0,    19,    10,    20,     0,    19,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,      11,    20,     0,    19,    12,    20,     0,    20,     0,    20,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,      13,    22,     0,    22,     0,    21,    16,    18,     0,    18,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,       0,     5,    14,    15,     0,     5,    14,    21,    15,     0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,       4,     0,     9,    22,     0,     8,    22,     0,     3,     0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,      14,    18,    15,     0
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  
     0,    0,   10,   10,   10,   10,   10,    0,    0,   10,  
    10,    7,    7,    7,    7,    7,    0,    0,    7,    7,  
     8,    8,    8,    8,    8,    0,    0,    8,    8,    9,  
     9,    9,    9,    9,    4,    4,    9,    9,    2,    2,  
     0,    4,    4,    3,    3,    2,    2,    0,    0,    0,  
     3,    3,  
 };  
 short fml_check[] = {                                       8,  
     0,  268,    6,    7,  267,   14,    0,  262,  263,    0,  
   256,  257,  258,  259,  269,  261,  262,  263,    0,   23,  
   262,  263,  268,  269,  269,  270,   35,    0,  256,  257,  
   258,  259,    0,  261,  262,  263,    0,  257,  258,  259,  
   268,    0,  262,  263,   -1,  264,  265,  266,  268,   20,  
    21,   22,  269,  270,  269,  270,   18,   19,   -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,   -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,  262,  263,  264,  265,  266,   -1,   -1,  269,  
   270,  262,  263,  264,  265,  266,   -1,   -1,  269,  270,  
   262,  263,  264,  265,  266,   -1,   -1,  269,  270,  262,  
   263,  264,  265,  266,  262,  263,  269,  270,  262,  263,  
    -1,  269,  270,  262,  263,  269,  270,   -1,   -1,   -1,  
   269,  270,  
 };  
 #define YYFINAL 9  
 #ifndef YYDEBUG  
 #define YYDEBUG 0  
 #endif  
 #define YYMAXTOKEN 270  
 #if YYDEBUG  
 char *fml_name[] = {  
 "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,0,0,"F_NUMBER","V_ID","F_ID","EoI",  
 "F_ERROR","F_PLUS","F_MINUS","F_MULT","F_DIV","F_MOD","F_POW","F_LPAR","F_RPAR",  
 "F_COMMA",  
 };  
 char *fml_rule[] = {  
 "$accept : f_expr",  
 "f_expr : block",  
 "block : block F_PLUS term",  
 "block : block F_MINUS term",  
 "block : term",  
 "block : F_ERROR",  
 "block : error",  
 "term : term F_MULT basic_constr",  
 "term : term F_DIV basic_constr",  
 "term : term F_MOD basic_constr",  
 "term : basic_constr",  
 "basic_constr : basic_constr F_POW basic_item",  
 "basic_constr : basic_item",  
 "arg_list : arg_list F_COMMA block",  
 "arg_list : block",  
 "basic_item : F_ID F_LPAR F_RPAR",  
 "basic_item : F_ID F_LPAR arg_list F_RPAR",  
 "basic_item : V_ID",  
 "basic_item : F_MINUS basic_item",  
 "basic_item : F_PLUS basic_item",  
 "basic_item : F_NUMBER",  
 "basic_item : F_LPAR block F_RPAR",  
 };  };
   
 #endif  #endif
 #ifndef YYSTYPE  
 typedef int YYSTYPE;  #if YYDEBUG != 0
   static const short yyrline[] = { 0,
       66,    84,    85,    86,    87,    88,    91,    92,    93,    94,
       97,    99,   102,   106,   112,   121,   131,   134,   148,   149,
      152
   };
 #endif  #endif
 #ifdef YYSTACKSIZE  
 #undef YYMAXDEPTH  
 #define YYMAXDEPTH YYSTACKSIZE  #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
   
   static const char * const yytname[] = {   "$","error","$undefined.","F_NUMBER",
   "V_ID","F_ID","EoI","F_ERROR","F_PLUS","F_MINUS","F_MULT","F_DIV","F_MOD","F_POW",
   "F_LPAR","F_RPAR","F_COMMA","f_expr","block","term","basic_constr","arg_list",
   "basic_item", NULL
   };
   #endif
   
   static const short yyr1[] = {     0,
       17,    18,    18,    18,    18,    18,    19,    19,    19,    19,
       20,    20,    21,    21,    22,    22,    22,    22,    22,    22,
       22
   };
   
   static const short yyr2[] = {     0,
        1,     3,     3,     1,     1,     1,     3,     3,     3,     1,
        3,     1,     3,     1,     3,     4,     1,     2,     2,     1,
        3
   };
   
   static const short yydefact[] = {     0,
        6,    20,    17,     0,     5,     0,     0,     0,     1,     4,
       10,    12,     0,    19,    18,     0,     0,     0,     0,     0,
        0,     0,    15,    14,     0,    21,     2,     3,     7,     8,
        9,    11,    16,     0,    13,     0,     0,     0
   };
   
   static const short yydefgoto[] = {    36,
        9,    10,    11,    25,    12
   };
   
   static const short yypact[] = {    20,
   -32768,-32768,-32768,    -7,-32768,    27,    27,    20,    37,    28,
       -2,-32768,     5,-32768,-32768,     7,    27,    27,    27,    27,
       27,    27,-32768,    37,   -12,-32768,    28,    28,    -2,    -2,
       -2,-32768,-32768,    20,    37,    18,    33,-32768
   };
   
   static const short yypgoto[] = {-32768,
       -8,    30,    23,-32768,    -5
   };
   
   
   #define YYLAST 48
   
   
   static const short yytable[] = {    16,
       14,    15,    33,    34,    24,     1,    13,     2,     3,     4,
       22,     5,     6,     7,    17,    18,    32,    37,     8,    23,
        1,    26,     2,     3,     4,    35,     5,     6,     7,     2,
        3,     4,    38,     8,     6,     7,     0,    19,    20,    21,
        8,    29,    30,    31,    17,    18,    27,    28
   };
   
   static const short yycheck[] = {     8,
        6,     7,    15,    16,    13,     1,    14,     3,     4,     5,
       13,     7,     8,     9,     8,     9,    22,     0,    14,    15,
        1,    15,     3,     4,     5,    34,     7,     8,     9,     3,
        4,     5,     0,    14,     8,     9,    -1,    10,    11,    12,
       14,    19,    20,    21,     8,     9,    17,    18
   };
   /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
   #line 3 "/usr/share/misc/bison.simple"
   /* This file comes from bison-1.28.  */
   
   /* Skeleton output parser for bison,
      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 2, or (at your option)
      any later version.
   
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.
   
      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., 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.  */
   
   /* 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) || (defined (__sun) && defined (__i386))
   #define YYSTACK_USE_ALLOCA
   #include <alloca.h>
   #else /* not sparc */
   /* 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)
   /* 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
   #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 /* YYSTACK_USE_ALLOCA not defined */
   
   #ifdef YYSTACK_USE_ALLOCA
   #define YYSTACK_ALLOC alloca
 #else  #else
 #ifdef YYMAXDEPTH  #define YYSTACK_ALLOC malloc
 #define YYSTACKSIZE YYMAXDEPTH  #endif
   
   /* Note: there must be only one dollar sign in this file.
      It is replaced by the list of actions, each action
      as one case of the switch.  */
   
   #define yyerrok (yyerrstatus = 0)
   #define yyclearin (yychar = YYEMPTY)
   #define YYEMPTY -2
   #define YYEOF 0
   #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
      transition to the new meaning of YYERROR, for GCC.
      Once GCC version 2 has supplanted version 1, this can go.  */
   #define YYFAIL goto yyerrlab
   #define YYRECOVERING()  (!!yyerrstatus)
   #define YYBACKUP(token, value) \
   do \
     if (yychar == YYEMPTY && yylen == 1) \
       { yychar = (token), yylval = (value); \
         yychar1 = YYTRANSLATE (yychar); \
         YYPOPSTACK; \
         goto yybackup; \
       } \
     else \
       { yyerror ("syntax error: cannot back up"); YYERROR; } \
   while (0)
   
   #define YYTERROR 1
   #define YYERRCODE 256
   
   #ifndef YYPURE
   #define YYLEX yylex()
   #endif
   
   #ifdef YYPURE
   #ifdef YYLSP_NEEDED
   #ifdef YYLEX_PARAM
   #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
 #else  #else
 #define YYSTACKSIZE 500  #define YYLEX yylex(&yylval, &yylloc)
 #define YYMAXDEPTH 500  
 #endif  #endif
   #else /* not YYLSP_NEEDED */
   #ifdef YYLEX_PARAM
   #define YYLEX yylex(&yylval, YYLEX_PARAM)
   #else
   #define YYLEX yylex(&yylval)
 #endif  #endif
 int yydebug;  #endif /* not YYLSP_NEEDED */
 int yynerrs;  #endif
 int yyerrflag;  
 int yychar;  /* If nonreentrant, generate the variables here */
 short *yyssp;  
 YYSTYPE *yyvsp;  #ifndef YYPURE
 YYSTYPE yyval;  
 YYSTYPE yylval;  int yychar; /*  the lookahead symbol */
 short yyss[YYSTACKSIZE];  YYSTYPE yylval; /*  the semantic value of the */
 YYSTYPE yyvs[YYSTACKSIZE];   /*  lookahead symbol */
 #define yystacksize YYSTACKSIZE  
 #line 155 "capaFormula.y"  #ifdef YYLSP_NEEDED
 void  YYLTYPE yylloc; /*  location data for the lookahead */
 fml_error(char *msg)   /*  symbol */
   #endif
   
   int yynerrs; /*  number of parse errors so far       */
   #endif  /* not YYPURE */
   
   #if YYDEBUG != 0
   int yydebug; /*  nonzero means print parse trace */
   /* Since this is uninitialized, it does not stop multiple parsers
      from coexisting.  */
   #endif
   
   /*  YYINITDEPTH indicates the initial size of the parser's stacks */
   
   #ifndef YYINITDEPTH
   #define YYINITDEPTH 200
   #endif
   
   /*  YYMAXDEPTH is the maximum size the stacks can grow to
       (effective only if the built-in stack extension method is used).  */
   
   #if YYMAXDEPTH == 0
   #undef YYMAXDEPTH
   #endif
   
   #ifndef YYMAXDEPTH
   #define YYMAXDEPTH 10000
   #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_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_memcpy (to, from, count)
        char *to;
        char *from;
        unsigned int count;
 {  {
   FormulaParseOK=0;    register char *f = from;
   printf("Error Parsing: %s\n",msg);    register char *t = to;
       register int i = count;
   
     while (i-- > 0)
       *t++ = *f++;
 }  }
 /* ---------------------------------------------------- */  
 Symbol *  #else /* __cplusplus */
 f_symbol_pow(ap,bp) Symbol *ap; Symbol *bp;  
   /* This is the most reliable way to avoid incompatibilities
      in available built-in functions on various systems.  */
   static void
   __yy_memcpy (char *to, char *from, unsigned int count)
 {  {
   Symbol *cp;    register char *t = to;
   double  a, b;    register char *f = from;
   int     error = 0;    register int i = count;
     
   cp = NULL;    while (i-- > 0)
   switch(ap->s_type) {      *t++ = *f++;
      case I_VAR:      a = (double)(ap->s_int);  
          break;  
      case I_CONSTANT: a = (double)(ap->s_int); capa_mfree((char *)ap);  
          break;  
      case R_VAR:      a = ap->s_real;  
          break;  
      case R_CONSTANT: a = ap->s_real;   capa_mfree((char *)ap);  
          break;  
      case S_VAR:  
      case S_CONSTANT:   
      default:         error = 1;  break;  
   }  
   switch(bp->s_type) {  
      case I_VAR:      b = (double)(bp->s_int);  
          break;  
      case I_CONSTANT: b = (double)(bp->s_int);  capa_mfree((char *)bp);  
          break;  
      case R_VAR:      b = bp->s_real;  
          break;  
      case R_CONSTANT: b = bp->s_real;   capa_mfree((char *)bp);  
          break;  
      case S_VAR:  
      case S_CONSTANT:   
      default:         error = 1; break;  
   }  
   if (!error) {  
     cp = (Symbol *)capa_malloc(sizeof(Symbol),1);  
     cp->s_type = R_CONSTANT;  
     cp->s_real = pow(a,b);  
       
   }  
   return (cp);  
 }  }
   
 /* ============================================================================= */  #endif
 #line 320 "fma.tab.c"  #endif
 #define YYABORT goto yyabort  
 #define YYREJECT goto yyabort  #line 217 "/usr/share/misc/bison.simple"
 #define YYACCEPT goto yyaccept  
 #define YYERROR goto yyerrlab  /* 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  int
 yyparse()  yyparse(YYPARSE_PARAM_ARG)
        YYPARSE_PARAM_DECL
 {  {
     register int yym, yyn, yystate;    register int yystate;
 #if YYDEBUG    register int yyn;
     register char *yys;    register short *yyssp;
     extern char *getenv();    register YYSTYPE *yyvsp;
     int yyerrstatus; /*  number of tokens to shift before error messages enabled */
     if (yys = getenv("YYDEBUG"))    int yychar1 = 0; /*  lookahead token as an internal (translated) token number */
     {  
         yyn = *yys;    short yyssa[YYINITDEPTH]; /*  the state stack */
         if (yyn >= '0' && yyn <= '9')    YYSTYPE yyvsa[YYINITDEPTH]; /*  the semantic value stack */
             yydebug = yyn - '0';  
     }    short *yyss = yyssa; /*  refer to the stacks thru separate pointers */
 #endif    YYSTYPE *yyvs = yyvsa; /*  to allow yyoverflow to reallocate them elsewhere */
   
     yynerrs = 0;  #ifdef YYLSP_NEEDED
     yyerrflag = 0;    YYLTYPE yylsa[YYINITDEPTH]; /*  the location stack */
     yychar = (-1);    YYLTYPE *yyls = yylsa;
     YYLTYPE *yylsp;
     yyssp = yyss;  
     yyvsp = yyvs;  #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
     *yyssp = yystate = 0;  #else
   #define YYPOPSTACK   (yyvsp--, yyssp--)
 yyloop:  #endif
     if (yyn = yydefred[yystate]) goto yyreduce;  
     if (yychar < 0)    int yystacksize = YYINITDEPTH;
     {    int yyfree_stacks = 0;
         if ((yychar = yylex()) < 0) yychar = 0;  
 #if YYDEBUG  #ifdef YYPURE
         if (yydebug)    int yychar;
         {    YYSTYPE yylval;
             yys = 0;    int yynerrs;
             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];  #ifdef YYLSP_NEEDED
             if (!yys) yys = "illegal-symbol";    YYLTYPE yylloc;
             printf("%sdebug: state %d, reading %d (%s)\n",  #endif
                     YYPREFIX, yystate, yychar, yys);  #endif
         }  
 #endif    YYSTYPE yyval; /*  the variable used to return */
     }   /*  semantic values from the action */
     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&   /*  routines */
             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)  
     {    int yylen;
 #if YYDEBUG  
         if (yydebug)  #if YYDEBUG != 0
             printf("%sdebug: state %d, shifting to state %d\n",    if (yydebug)
                     YYPREFIX, yystate, yytable[yyn]);      fprintf(stderr, "Starting parse\n");
 #endif  
         if (yyssp >= yyss + yystacksize - 1)  
         {  
             goto yyoverflow;  
         }  
         *++yyssp = yystate = yytable[yyn];  
         *++yyvsp = yylval;  
         yychar = (-1);  
         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;  
 #ifdef lint  
     goto yynewerror;  
 #endif  
 yynewerror:  
     yyerror("syntax error");  
 #ifdef lint  
     goto yyerrlab;  
 #endif  #endif
 yyerrlab:  
     ++yynerrs;    yystate = 0;
 yyinrecovery:    yyerrstatus = 0;
     if (yyerrflag < 3)    yynerrs = 0;
     {    yychar = YYEMPTY; /* Cause a token to be read.  */
         yyerrflag = 3;  
         for (;;)    /* Initialize stack pointers.
         {       Waste one element of value and location stack
             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&       so that they stay on the same level as the state stack.
                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)       The wasted elements are never initialized.  */
             {  
 #if YYDEBUG    yyssp = yyss - 1;
                 if (yydebug)    yyvsp = yyvs;
                     printf("%sdebug: state %d, error recovery shifting\  #ifdef YYLSP_NEEDED
  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);    yylsp = yyls;
 #endif  
                 if (yyssp >= yyss + yystacksize - 1)  
                 {  
                     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  #endif
         yychar = (-1);  
         goto yyloop;  /* Push a new state, which is found in  yystate  .  */
   /* In all cases, when you get here, the value and location stacks
      have just been pushed. so pushing a state here evens the stacks.  */
   yynewstate:
   
     *++yyssp = yystate;
   
     if (yyssp >= yyss + yystacksize - 1)
       {
         /* Give user a chance to reallocate the stack */
         /* Use copies of these so that the &'s don't force the real ones into memory. */
         YYSTYPE *yyvs1 = yyvs;
         short *yyss1 = yyss;
   #ifdef YYLSP_NEEDED
         YYLTYPE *yyls1 = yyls;
   #endif
   
         /* Get the current used size of the three stacks, in elements.  */
         int size = yyssp - yyss + 1;
   
   #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),
    &yyls1, size * sizeof (*yylsp),
    &yystacksize);
   #else
         yyoverflow("parser stack overflow",
    &yyss1, size * sizeof (*yyssp),
    &yyvs1, size * sizeof (*yyvsp),
    &yystacksize);
   #endif
   
         yyss = yyss1; yyvs = yyvs1;
   #ifdef YYLSP_NEEDED
         yyls = yyls1;
   #endif
   #else /* no yyoverflow */
         /* Extend the stack our own way.  */
         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;
   #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 *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
         __yy_memcpy ((char *)yyls, (char *)yyls1,
      size * (unsigned int) sizeof (*yylsp));
   #endif
   #endif /* no yyoverflow */
   
         yyssp = yyss + size - 1;
         yyvsp = yyvs + size - 1;
   #ifdef YYLSP_NEEDED
         yylsp = yyls + size - 1;
   #endif
   
   #if YYDEBUG != 0
         if (yydebug)
    fprintf(stderr, "Stack size increased to %d\n", yystacksize);
   #endif
   
         if (yyssp >= yyss + yystacksize - 1)
    YYABORT;
     }      }
   
   #if YYDEBUG != 0
     if (yydebug)
       fprintf(stderr, "Entering state %d\n", yystate);
   #endif
   
     goto yybackup;
    yybackup:
   
   /* Do appropriate processing given the current state.  */
   /* Read a lookahead token if we need one and don't already have one.  */
   /* yyresume: */
   
     /* First try to decide what to do without reference to lookahead token.  */
   
     yyn = yypact[yystate];
     if (yyn == YYFLAG)
       goto yydefault;
   
     /* Not known => get a lookahead token if don't already have one.  */
   
     /* yychar is either YYEMPTY or YYEOF
        or a valid token in external form.  */
   
     if (yychar == YYEMPTY)
       {
   #if YYDEBUG != 0
         if (yydebug)
    fprintf(stderr, "Reading a token: ");
   #endif
         yychar = YYLEX;
       }
   
     /* Convert token to internal form (in yychar1) for indexing tables with */
   
     if (yychar <= 0) /* This means end of input. */
       {
         yychar1 = 0;
         yychar = YYEOF; /* Don't call YYLEX any more */
   
   #if YYDEBUG != 0
         if (yydebug)
    fprintf(stderr, "Now at end of input.\n");
   #endif
       }
     else
       {
         yychar1 = YYTRANSLATE(yychar);
   
   #if YYDEBUG != 0
         if (yydebug)
    {
     fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
     /* Give the individual parser a way to print the precise meaning
        of a token, for further debugging info.  */
   #ifdef YYPRINT
     YYPRINT (stderr, yychar, yylval);
   #endif
     fprintf (stderr, ")\n");
    }
   #endif
       }
   
     yyn += yychar1;
     if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
       goto yydefault;
   
     yyn = yytable[yyn];
   
     /* yyn is what to do for this token type in this state.
        Negative => reduce, -yyn is rule number.
        Positive => shift, yyn is new state.
          New state is final state => don't bother to shift,
          just return success.
        0, or most negative number => error.  */
   
     if (yyn < 0)
       {
         if (yyn == YYFLAG)
    goto yyerrlab;
         yyn = -yyn;
         goto yyreduce;
       }
     else if (yyn == 0)
       goto yyerrlab;
   
     if (yyn == YYFINAL)
       YYACCEPT;
   
     /* Shift the lookahead token.  */
   
   #if YYDEBUG != 0
     if (yydebug)
       fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
   #endif
   
     /* Discard the token being shifted unless it is eof.  */
     if (yychar != YYEOF)
       yychar = YYEMPTY;
   
     *++yyvsp = yylval;
   #ifdef YYLSP_NEEDED
     *++yylsp = yylloc;
   #endif
   
     /* count tokens shifted since error; after three, turn off error status.  */
     if (yyerrstatus) yyerrstatus--;
   
     yystate = yyn;
     goto yynewstate;
   
   /* Do the default action for the current state.  */
   yydefault:
   
     yyn = yydefact[yystate];
     if (yyn == 0)
       goto yyerrlab;
   
   /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 yyreduce:  yyreduce:
 #if YYDEBUG    yylen = yyr2[yyn];
     if (yydebug)    if (yylen > 0)
         printf("%sdebug: state %d, reducing by rule %d (%s)\n",      yyval = yyvsp[1-yylen]; /* implement default value of the action */
                 YYPREFIX, yystate, yyn, yyrule[yyn]);  
 #endif  #if YYDEBUG != 0
     yym = yylen[yyn];    if (yydebug)
     yyval = yyvsp[1-yym];  
     switch (yyn)  
     {      {
         int i;
   
         fprintf (stderr, "Reducing via rule %d (line %d), ",
          yyn, yyrline[yyn]);
   
         /* Print the symbols being reduced, and their result.  */
         for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
    fprintf (stderr, "%s ", yytname[yyrhs[i]]);
         fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
       }
   #endif
   
   
     switch (yyn) {
   
 case 1:  case 1:
 #line 66 "capaFormula.y"  #line 66 "capaFormula.y"
 { switch(yyvsp[0]->s_type) {  { switch(yyvsp[0]->s_type) {
Line 474  case 1: Line 771  case 1:
                                                     }                                                      }
                                                     capa_mfree((char *)yyvsp[0]);                                                      capa_mfree((char *)yyvsp[0]);
                                                     FMLDBUG_PR1("[f_expr <= block ]\n");                                                      FMLDBUG_PR1("[f_expr <= block ]\n");
                                                   }                                                    ;
 break;      break;}
 case 2:  case 2:
 #line 84 "capaFormula.y"  #line 84 "capaFormula.y"
 { yyval = symbols_op(yyvsp[-2], yyvsp[0], ADD_op);  }  { yyval = symbols_op(yyvsp[-2], yyvsp[0], ADD_op);  ;
 break;      break;}
 case 3:  case 3:
 #line 85 "capaFormula.y"  #line 85 "capaFormula.y"
 { yyval = symbols_op(yyvsp[-2], yyvsp[0], SUB_op);  }  { yyval = symbols_op(yyvsp[-2], yyvsp[0], SUB_op);  ;
 break;      break;}
 case 4:  case 4:
 #line 86 "capaFormula.y"  #line 86 "capaFormula.y"
 { yyval = yyvsp[0]; }  { yyval = yyvsp[0]; ;
 break;      break;}
 case 5:  case 5:
 #line 87 "capaFormula.y"  #line 87 "capaFormula.y"
 { FormulaParseOK = 0; FMLDBUG_PR1("[F_ERROR]\n"); return 0;}  { FormulaParseOK = 0; FMLDBUG_PR1("[F_ERROR]\n"); return 0;;
 break;      break;}
 case 6:  case 6:
 #line 88 "capaFormula.y"  #line 88 "capaFormula.y"
 { FormulaParseOK = 0; FMLDBUG_PR1("[ERROR]\n"); return 0;  }  { FormulaParseOK = 0; FMLDBUG_PR1("[ERROR]\n"); return 0;  ;
 break;      break;}
 case 7:  case 7:
 #line 91 "capaFormula.y"  #line 91 "capaFormula.y"
 { yyval = symbols_op(yyvsp[-2], yyvsp[0], MUL_op);  }  { yyval = symbols_op(yyvsp[-2], yyvsp[0], MUL_op);  ;
 break;      break;}
 case 8:  case 8:
 #line 92 "capaFormula.y"  #line 92 "capaFormula.y"
 { yyval = symbols_op(yyvsp[-2], yyvsp[0], DIV_op);  }  { yyval = symbols_op(yyvsp[-2], yyvsp[0], DIV_op);  ;
 break;      break;}
 case 9:  case 9:
 #line 93 "capaFormula.y"  #line 93 "capaFormula.y"
 { yyval = symbols_op(yyvsp[-2], yyvsp[0], IDIV_op); }  { yyval = symbols_op(yyvsp[-2], yyvsp[0], IDIV_op); ;
 break;      break;}
 case 10:  case 10:
 #line 94 "capaFormula.y"  #line 94 "capaFormula.y"
 { yyval = yyvsp[0]; }  { yyval = yyvsp[0]; ;
 break;      break;}
 case 11:  case 11:
 #line 97 "capaFormula.y"  #line 97 "capaFormula.y"
 { yyval = f_symbol_pow(yyvsp[-2],yyvsp[0]);  { yyval = f_symbol_pow(yyvsp[-2],yyvsp[0]);
                                                     FMLDBUG_PR3("[%.16g ^ %.16g] ",yyvsp[-2]->s_real,yyvsp[0]->s_real);       }                                                      FMLDBUG_PR3("[%.16g ^ %.16g] ",yyvsp[-2]->s_real,yyvsp[0]->s_real);       ;
 break;      break;}
 case 12:  case 12:
 #line 99 "capaFormula.y"  #line 99 "capaFormula.y"
 { yyval = yyvsp[0]; }  { yyval = yyvsp[0]; ;
 break;      break;}
 case 13:  case 13:
 #line 102 "capaFormula.y"  #line 102 "capaFormula.y"
 { yyval = yyvsp[-2];  { yyval = yyvsp[-2];
                                                     yyval->s_argc++;                                                      yyval->s_argc++;
                                                     yyval->s_argp = addto_arglist(yyvsp[-2]->s_argp, yyvsp[0]);                                                      yyval->s_argp = addto_arglist(yyvsp[-2]->s_argp, yyvsp[0]);
                                                   }                                                    ;
 break;      break;}
 case 14:  case 14:
 #line 106 "capaFormula.y"  #line 106 "capaFormula.y"
 { yyval = yyvsp[0];  { yyval = yyvsp[0];
                                                     yyval->s_argc = 1;                                                      yyval->s_argc = 1;
                                                     yyval->s_argp = new_arglist(yyvsp[0]);                                                      yyval->s_argp = new_arglist(yyvsp[0]);
                                                   }                                                    ;
 break;      break;}
 case 15:  case 15:
 #line 112 "capaFormula.y"  #line 112 "capaFormula.y"
 {  int tmp;  {  int tmp;
Line 545  case 15: Line 842  case 15:
                                                        yyval = do_function(tmp, 0, NULL );                                                         yyval = do_function(tmp, 0, NULL );
                                                        capa_mfree(FuncStack[Func_idx].s_name);                                                         capa_mfree(FuncStack[Func_idx].s_name);
                                                      }                                                       }
                                                   }                                                    ;
 break;      break;}
 case 16:  case 16:
 #line 121 "capaFormula.y"  #line 121 "capaFormula.y"
 {  int  tmp;  {  int  tmp;
Line 558  case 16: Line 855  case 16:
                 capa_mfree(FuncStack[Func_idx].s_name);                  capa_mfree(FuncStack[Func_idx].s_name);
                 free_arglist(yyvsp[-1]->s_argp);                  free_arglist(yyvsp[-1]->s_argp);
                                                       }                                                        }
                                                   }                                                    ;
 break;      break;}
 case 17:  case 17:
 #line 131 "capaFormula.y"  #line 131 "capaFormula.y"
 { FMLDBUG_PR3("[V %s = %.16g] ",yyvsp[0]->s_name, yyvsp[0]->s_real);  { FMLDBUG_PR3("[V %s = %.16g] ",yyvsp[0]->s_name, yyvsp[0]->s_real);
                                                     yyval = yyvsp[0];                                                      yyval = yyvsp[0];
                                                   }                                                    ;
 break;      break;}
 case 18:  case 18:
 #line 134 "capaFormula.y"  #line 134 "capaFormula.y"
 { yyval = yyvsp[0];  { yyval = yyvsp[0];
Line 581  case 18: Line 878  case 18:
                                                       case S_CONSTANT: break;                                                        case S_CONSTANT: break;
                                                       default:         break;                                                        default:         break;
                                                     }                                                      }
                                                   }                                                    ;
 break;      break;}
 case 19:  case 19:
 #line 148 "capaFormula.y"  #line 148 "capaFormula.y"
 { yyval = yyvsp[0]; }  { yyval = yyvsp[0]; ;
 break;      break;}
 case 20:  case 20:
 #line 149 "capaFormula.y"  #line 149 "capaFormula.y"
 { FMLDBUG_PR2("[F %.16g] ",yyvsp[0]->s_real);  { FMLDBUG_PR2("[F %.16g] ",yyvsp[0]->s_real);
                                                     yyval = yyvsp[0];                                                      yyval = yyvsp[0];
                                                   }                                                    ;
 break;      break;}
 case 21:  case 21:
 #line 152 "capaFormula.y"  #line 152 "capaFormula.y"
 { yyval = yyvsp[-1]; }  { yyval = yyvsp[-1]; ;
 break;      break;}
 #line 601 "fma.tab.c"  }
     }     /* the action file gets copied in in place of this dollarsign */
     yyssp -= yym;  #line 543 "/usr/share/misc/bison.simple"
     yystate = *yyssp;  
     yyvsp -= yym;    yyvsp -= yylen;
     yym = yylhs[yyn];    yyssp -= yylen;
     if (yystate == 0 && yym == 0)  #ifdef YYLSP_NEEDED
     {    yylsp -= yylen;
 #if YYDEBUG  #endif
         if (yydebug)  
             printf("%sdebug: after reduction, shifting from state 0 to\  #if YYDEBUG != 0
  state %d\n", YYPREFIX, YYFINAL);    if (yydebug)
 #endif      {
         yystate = YYFINAL;        short *ssp1 = yyss - 1;
         *++yyssp = YYFINAL;        fprintf (stderr, "state stack now");
         *++yyvsp = yyval;        while (ssp1 != yyssp)
         if (yychar < 0)   fprintf (stderr, " %d", *++ssp1);
         {        fprintf (stderr, "\n");
             if ((yychar = yylex()) < 0) yychar = 0;      }
 #if YYDEBUG  #endif
             if (yydebug)  
             {    *++yyvsp = yyval;
                 yys = 0;  
                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];  #ifdef YYLSP_NEEDED
                 if (!yys) yys = "illegal-symbol";    yylsp++;
                 printf("%sdebug: state %d, reading %d (%s)\n",    if (yylen == 0)
                         YYPREFIX, YYFINAL, yychar, yys);      {
             }        yylsp->first_line = yylloc.first_line;
 #endif        yylsp->first_column = yylloc.first_column;
         }        yylsp->last_line = (yylsp-1)->last_line;
         if (yychar == 0) goto yyaccept;        yylsp->last_column = (yylsp-1)->last_column;
         goto yyloop;        yylsp->text = 0;
     }      }
     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&    else
             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)      {
         yystate = yytable[yyn];        yylsp->last_line = (yylsp+yylen-1)->last_line;
     else        yylsp->last_column = (yylsp+yylen-1)->last_column;
         yystate = yydgoto[yym];      }
 #if YYDEBUG  #endif
     if (yydebug)  
         printf("%sdebug: after reduction, shifting from state %d \    /* Now "shift" the result of the reduction.
 to state %d\n", YYPREFIX, *yyssp, yystate);       Determine what state that goes to,
 #endif       based on the state we popped back to
     if (yyssp >= yyss + yystacksize - 1)       and the rule number reduced by.  */
     {  
         goto yyoverflow;    yyn = yyr1[yyn];
     }  
     *++yyssp = yystate;    yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
     *++yyvsp = yyval;    if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     goto yyloop;      yystate = yytable[yystate];
 yyoverflow:    else
     yyerror("yacc stack overflow");      yystate = yydefgoto[yyn - YYNTBASE];
 yyabort:  
     return (1);    goto yynewstate;
 yyaccept:  
     return (0);  yyerrlab:   /* here on detecting error */
   
     if (! yyerrstatus)
       /* If not already recovering from an error, report this error.  */
       {
         ++yynerrs;
   
   #ifdef YYERROR_VERBOSE
         yyn = yypact[yystate];
   
         if (yyn > YYFLAG && yyn < YYLAST)
    {
     int size = 0;
     char *msg;
     int x, count;
   
     count = 0;
     /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
     for (x = (yyn < 0 ? -yyn : 0);
          x < (sizeof(yytname) / sizeof(char *)); x++)
       if (yycheck[x + yyn] == x)
         size += strlen(yytname[x]) + 15, count++;
     msg = (char *) malloc(size + 15);
     if (msg != 0)
       {
         strcpy(msg, "parse error");
   
         if (count < 5)
    {
     count = 0;
     for (x = (yyn < 0 ? -yyn : 0);
          x < (sizeof(yytname) / sizeof(char *)); x++)
       if (yycheck[x + yyn] == x)
         {
    strcat(msg, count == 0 ? ", expecting `" : " or `");
    strcat(msg, yytname[x]);
    strcat(msg, "'");
    count++;
         }
    }
         yyerror(msg);
         free(msg);
       }
     else
       yyerror ("parse error; also virtual memory exceeded");
    }
         else
   #endif /* YYERROR_VERBOSE */
    yyerror("parse error");
       }
   
     goto yyerrlab1;
   yyerrlab1:   /* here on error raised explicitly by an action */
   
     if (yyerrstatus == 3)
       {
         /* if just tried and failed to reuse lookahead token after an error, discard it.  */
   
         /* return failure if at end of input */
         if (yychar == YYEOF)
    YYABORT;
   
   #if YYDEBUG != 0
         if (yydebug)
    fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
   #endif
   
         yychar = YYEMPTY;
       }
   
     /* Else will try to reuse lookahead token
        after shifting the error token.  */
   
     yyerrstatus = 3; /* Each real token shifted decrements this */
   
     goto yyerrhandle;
   
   yyerrdefault:  /* current state does not do anything special for the error token. */
   
   #if 0
     /* This is wrong; only states that explicitly want error tokens
        should shift them.  */
     yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
     if (yyn) goto yydefault;
   #endif
   
   yyerrpop:   /* pop the current state because it cannot handle the error token */
   
     if (yyssp == yyss) YYABORT;
     yyvsp--;
     yystate = *--yyssp;
   #ifdef YYLSP_NEEDED
     yylsp--;
   #endif
   
   #if YYDEBUG != 0
     if (yydebug)
       {
         short *ssp1 = yyss - 1;
         fprintf (stderr, "Error: state stack now");
         while (ssp1 != yyssp)
    fprintf (stderr, " %d", *++ssp1);
         fprintf (stderr, "\n");
       }
   #endif
   
   yyerrhandle:
   
     yyn = yypact[yystate];
     if (yyn == YYFLAG)
       goto yyerrdefault;
   
     yyn += YYTERROR;
     if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
       goto yyerrdefault;
   
     yyn = yytable[yyn];
     if (yyn < 0)
       {
         if (yyn == YYFLAG)
    goto yyerrpop;
         yyn = -yyn;
         goto yyreduce;
       }
     else if (yyn == 0)
       goto yyerrpop;
   
     if (yyn == YYFINAL)
       YYACCEPT;
   
   #if YYDEBUG != 0
     if (yydebug)
       fprintf(stderr, "Shifting error token, ");
   #endif
   
     *++yyvsp = yylval;
   #ifdef YYLSP_NEEDED
     *++yylsp = yylloc;
   #endif
   
     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 154 "capaFormula.y"
   
   void
   fml_error(char *msg)
   {
     FormulaParseOK=0;
     printf("Error Parsing: %s\n",msg);
     
 }  }
   /* ---------------------------------------------------- */
   Symbol *
   f_symbol_pow(ap,bp) Symbol *ap; Symbol *bp;
   {
     Symbol *cp;
     double  a, b;
     int     error = 0;
     
     cp = NULL;
     switch(ap->s_type) {
        case I_VAR:      a = (double)(ap->s_int);
            break;
        case I_CONSTANT: a = (double)(ap->s_int); capa_mfree((char *)ap);
            break;
        case R_VAR:      a = ap->s_real;
            break;
        case R_CONSTANT: a = ap->s_real;   capa_mfree((char *)ap);
            break;
        case S_VAR:
        case S_CONSTANT: 
        default:         error = 1;  break;
     }
     switch(bp->s_type) {
        case I_VAR:      b = (double)(bp->s_int);
            break;
        case I_CONSTANT: b = (double)(bp->s_int);  capa_mfree((char *)bp);
            break;
        case R_VAR:      b = bp->s_real;
            break;
        case R_CONSTANT: b = bp->s_real;   capa_mfree((char *)bp);
            break;
        case S_VAR:
        case S_CONSTANT: 
        default:         error = 1; break;
     }
     if (!error) {
       cp = (Symbol *)capa_malloc(sizeof(Symbol),1);
       cp->s_type = R_CONSTANT;
       cp->s_real = pow(a,b);
       
     }
     return (cp);
   }
   
   /* ============================================================================= */
Removed from v.1.1  
changed lines
  Added in v.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>