# Home    # nevrax.com   
Nevrax
Nevrax.org
#News
#Mailing-list
#Documentation
#CVS
#Bugs
#License
Docs
 
Documentation  
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages   Search  

cf_gramatical.cpp

Go to the documentation of this file.
00001 
00002 /*  A Bison parser, made from cf_gramatical.yxx
00003     by GNU Bison version 1.28  */
00004 
00005 #define YYBISON 1  /* Identify Bison output.  */
00006 
00007 #define yyparse cfparse
00008 #define yylex cflex
00009 #define yyerror cferror
00010 #define yylval cflval
00011 #define yychar cfchar
00012 #define yydebug cfdebug
00013 #define yynerrs cfnerrs
00014 #define ADD_ASSIGN      257
00015 #define ASSIGN  258
00016 #define VARIABLE        259
00017 #define STRING  260
00018 #define SEMICOLON       261
00019 #define PLUS    262
00020 #define MINUS   263
00021 #define MULT    264
00022 #define DIVIDE  265
00023 #define RPAREN  266
00024 #define LPAREN  267
00025 #define RBRACE  268
00026 #define LBRACE  269
00027 #define COMMA   270
00028 #define INT     271
00029 #define REAL    272
00030 
00031 #line 1 "cf_gramatical.yxx"
00032 
00033 
00034 /* Includes */
00035 
00036 #ifdef NL_OS_WINDOWS
00037 #pragma warning (disable : 4786)
00038 #endif // NL_OS_WINDOWS
00039 
00040 #include <stdio.h>
00041 #include <vector>
00042 #include <string>
00043 
00044 #include "nel/misc/config_file.h"
00045 #include "nel/misc/common.h"
00046 #include "nel/misc/debug.h"
00047 
00048 using namespace std;
00049 using namespace NLMISC;
00050 
00051 /* Constantes */
00052 
00053 #define YYPARSE_PARAM pvararray
00054 
00055 // WARNING!!!! DEBUG_PRINTF are commented using // so IT MUST HAVE NO INSTRUCTION AFTER A DEBUG_PRINTF OR THEY LL BE COMMENTED
00056 
00057 //#define DEBUG_PRINTF  InfoLog->displayRaw
00058 #ifdef __GNUC__
00059 #define DEBUG_PRINTF(format, args...)
00060 #else // __GNUC__
00061 #define DEBUG_PRINTF    // InfoLog->displayRaw
00062 #endif // __GNUC__
00063 
00064 
00065 //#define DEBUG_PRINT(a)        InfoLog->displayRaw(a)
00066 #define DEBUG_PRINT(a)
00067 
00068 /* Types */
00069 
00070 enum cf_operation { OP_PLUS, OP_MINUS, OP_MULT, OP_DIVIDE, OP_NEG };
00071 
00072 struct cf_value
00073 {
00074         NLMISC::CConfigFile::CVar::TVarType     Type;
00075         int                                             Int;
00076         double                                  Real;
00077         char                                    String[1024];
00078 };
00079 
00080 /* Externals */
00081 
00082 extern bool cf_Ignore;
00083 
00084 extern FILE *yyin;
00085 
00086 /* Variables */
00087 
00088 NLMISC::CConfigFile::CVar               cf_CurrentVar;
00089 
00090 int             cf_CurrentLine;
00091 
00092 bool    cf_OverwriteExistingVariable;   // setup in the config_file.cpp reparse()
00093 
00094 
00095 
00096 /* Prototypes */
00097 
00098 int yylex (void);
00099 
00100 cf_value cf_op (cf_value a, cf_value b, cf_operation op);
00101 
00102 void cf_print (cf_value Val);
00103 
00104 void cf_setVar (NLMISC::CConfigFile::CVar &Var, cf_value Val);
00105 
00106 int yyerror (const char *);
00107 
00108 
00109 #line 81 "cf_gramatical.yxx"
00110 typedef union   {
00111                         cf_value Val;
00112                 } YYSTYPE;
00113 #include <stdio.h>
00114 
00115 #ifndef __cplusplus
00116 #ifndef __STDC__
00117 #define const
00118 #endif
00119 #endif
00120 
00121 
00122 
00123 #define YYFINAL         44
00124 #define YYFLAG          -32768
00125 #define YYNTBASE        19
00126 
00127 #define YYTRANSLATE(x) ((unsigned)(x) <= 272 ? yytranslate[x] : 30)
00128 
00129 static const char yytranslate[] = {     0,
00130      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00131      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00132      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00133      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00134      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00135      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00136      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00137      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00138      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00139      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00140      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00141      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00142      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00143      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00144      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00145      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00146      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00147      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00148      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00149      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00150      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00151      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00152      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00153      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00154      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00155      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
00156      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
00157     17,    18
00158 };
00159 
00160 #if YYDEBUG != 0
00161 static const short yyprhs[] = {     0,
00162      0,     1,     4,     5,     8,    10,    15,    20,    22,    26,
00163     28,    29,    34,    35,    37,    41,    45,    47,    51,    55,
00164     58,    61,    65,    67,    69,    71,    73
00165 };
00166 
00167 static const short yyrhs[] = {    -1,
00168     20,    21,     0,     0,    21,    22,     0,    22,     0,     5,
00169      4,    23,     7,     0,     5,     3,    23,     7,     0,    26,
00170      0,    15,    24,    14,     0,    26,     0,     0,    26,    25,
00171     16,    24,     0,     0,    27,     0,    26,     8,    27,     0,
00172     26,     9,    27,     0,    28,     0,    27,    10,    28,     0,
00173     27,    11,    28,     0,     8,    28,     0,     9,    28,     0,
00174     13,    23,    12,     0,    17,     0,    18,     0,     6,     0,
00175     29,     0,     5,     0
00176 };
00177 
00178 #endif
00179 
00180 #if YYDEBUG != 0
00181 static const short yyrline[] = { 0,
00182    100,   100,   100,   103,   104,   107,   161,   209,   210,   213,
00183    214,   214,   215,   218,   219,   220,   223,   224,   225,   228,
00184    229,   230,   231,   232,   233,   234,   237
00185 };
00186 #endif
00187 
00188 
00189 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
00190 
00191 static const char * const yytname[] = {   "$","error","$undefined.","ADD_ASSIGN",
00192 "ASSIGN","VARIABLE","STRING","SEMICOLON","PLUS","MINUS","MULT","DIVIDE","RPAREN",
00193 "LPAREN","RBRACE","LBRACE","COMMA","INT","REAL","ROOT","@1","instlist","inst",
00194 "expression","exprbrace","@2","expr2","expr3","expr4","variable", NULL
00195 };
00196 #endif
00197 
00198 static const short yyr1[] = {     0,
00199     20,    19,    19,    21,    21,    22,    22,    23,    23,    24,
00200     25,    24,    24,    26,    26,    26,    27,    27,    27,    28,
00201     28,    28,    28,    28,    28,    28,    29
00202 };
00203 
00204 static const short yyr2[] = {     0,
00205      0,     2,     0,     2,     1,     4,     4,     1,     3,     1,
00206      0,     4,     0,     1,     3,     3,     1,     3,     3,     2,
00207      2,     3,     1,     1,     1,     1,     1
00208 };
00209 
00210 static const short yydefact[] = {     1,
00211      0,     0,     2,     5,     0,     0,     4,    27,    25,     0,
00212      0,     0,    13,    23,    24,     0,     8,    14,    17,    26,
00213      0,    20,    21,     0,     0,    10,     7,     0,     0,     0,
00214      0,     6,    22,     9,     0,    15,    16,    18,    19,    13,
00215     12,     0,     0,     0
00216 };
00217 
00218 static const short yydefgoto[] = {    42,
00219      1,     3,     4,    16,    25,    35,    17,    18,    19,    20
00220 };
00221 
00222 static const short yypact[] = {     5,
00223      7,    15,     7,-32768,    -2,    -2,-32768,-32768,-32768,    20,
00224     20,    -2,    20,-32768,-32768,    25,    22,    13,-32768,-32768,
00225     29,-32768,-32768,     8,    26,     1,-32768,    20,    20,    20,
00226     20,-32768,-32768,-32768,    23,    13,    13,-32768,-32768,    20,
00227 -32768,    41,    42,-32768
00228 };
00229 
00230 static const short yypgoto[] = {-32768,
00231 -32768,-32768,    40,     2,     4,-32768,   -13,     6,    -9,-32768
00232 };
00233 
00234 
00235 #define YYLAST          44
00236 
00237 
00238 static const short yytable[] = {    26,
00239     22,    23,     8,     9,    -3,    10,    11,    21,    28,    29,
00240     12,     2,    13,    24,    14,    15,   -11,     5,     6,    33,
00241     38,    39,    30,    31,     8,     9,    26,    10,    11,    28,
00242     29,    27,    12,    36,    37,    32,    14,    15,    40,    34,
00243     43,    44,     7,    41
00244 };
00245 
00246 static const short yycheck[] = {    13,
00247     10,    11,     5,     6,     0,     8,     9,     6,     8,     9,
00248     13,     5,    15,    12,    17,    18,    16,     3,     4,    12,
00249     30,    31,    10,    11,     5,     6,    40,     8,     9,     8,
00250      9,     7,    13,    28,    29,     7,    17,    18,    16,    14,
00251      0,     0,     3,    40
00252 };
00253 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
00254 #line 3 "cfbison.simple"
00255 /* This file comes from bison-1.28.  */
00256 
00257 /* Skeleton output parser for bison,
00258    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
00259 
00260    This program is free software; you can redistribute it and/or modify
00261    it under the terms of the GNU General Public License as published by
00262    the Free Software Foundation; either version 2, or (at your option)
00263    any later version.
00264 
00265    This program is distributed in the hope that it will be useful,
00266    but WITHOUT ANY WARRANTY; without even the implied warranty of
00267    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00268    GNU General Public License for more details.
00269 
00270    You should have received a copy of the GNU General Public License
00271    along with this program; if not, write to the Free Software
00272    Foundation, Inc., 59 Temple Place - Suite 330,
00273    Boston, MA 02111-1307, USA.  */
00274 
00275 /* As a special exception, when this file is copied by Bison into a
00276    Bison output file, you may use that output file without restriction.
00277    This special exception was added by the Free Software Foundation
00278    in version 1.24 of Bison.  */
00279 
00280 /* This is the parser code that is written into each bison parser
00281   when the %semantic_parser declaration is not specified in the grammar.
00282   It was written by Richard Stallman by simplifying the hairy parser
00283   used when %semantic_parser is specified.  */
00284 
00285 #ifndef YYSTACK_USE_ALLOCA
00286 #ifdef alloca
00287 #define YYSTACK_USE_ALLOCA
00288 #else /* alloca not defined */
00289 #ifdef __GNUC__
00290 #define YYSTACK_USE_ALLOCA
00291 #define alloca __builtin_alloca
00292 #else /* not GNU C.  */
00293 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
00294 #define YYSTACK_USE_ALLOCA
00295 #include <alloca.h>
00296 #else /* not sparc */
00297 /* We think this test detects Watcom and Microsoft C.  */
00298 /* This used to test MSDOS, but that is a bad idea
00299    since that symbol is in the user namespace.  */
00300 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
00301 #if 0 /* No need for malloc.h, which pollutes the namespace;
00302          instead, just don't use alloca.  */
00303 #include <malloc.h>
00304 #endif
00305 #else /* not MSDOS, or __TURBOC__ */
00306 #if defined(_AIX)
00307 /* I don't know what this was needed for, but it pollutes the namespace.
00308    So I turned it off.   rms, 2 May 1997.  */
00309 /* #include <malloc.h>  */
00310  #pragma alloca
00311 #define YYSTACK_USE_ALLOCA
00312 #else /* not MSDOS, or __TURBOC__, or _AIX */
00313 #if 0
00314 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
00315                  and on HPUX 10.  Eventually we can turn this on.  */
00316 #define YYSTACK_USE_ALLOCA
00317 #define alloca __builtin_alloca
00318 #endif /* __hpux */
00319 #endif
00320 #endif /* not _AIX */
00321 #endif /* not MSDOS, or __TURBOC__ */
00322 #endif /* not sparc */
00323 #endif /* not GNU C */
00324 #endif /* alloca not defined */
00325 #endif /* YYSTACK_USE_ALLOCA not defined */
00326 
00327 #ifdef YYSTACK_USE_ALLOCA
00328 #define YYSTACK_ALLOC alloca
00329 #else
00330 #define YYSTACK_ALLOC malloc
00331 #endif
00332 
00333 /* Note: there must be only one dollar sign in this file.
00334    It is replaced by the list of actions, each action
00335    as one case of the switch.  */
00336 
00337 #define yyerrok         (yyerrstatus = 0)
00338 #define yyclearin       (yychar = YYEMPTY)
00339 #define YYEMPTY         -2
00340 #define YYEOF           0
00341 #define YYACCEPT        goto yyacceptlab
00342 #define YYABORT         goto yyabortlab
00343 #define YYERROR         goto yyerrlab1
00344 /* Like YYERROR except do call yyerror.
00345    This remains here temporarily to ease the
00346    transition to the new meaning of YYERROR, for GCC.
00347    Once GCC version 2 has supplanted version 1, this can go.  */
00348 #define YYFAIL          goto yyerrlab
00349 #define YYRECOVERING()  (!!yyerrstatus)
00350 #define YYBACKUP(token, value) \
00351 do                                                              \
00352   if (yychar == YYEMPTY && yylen == 1)                          \
00353     { yychar = (token), yylval = (value);                       \
00354       yychar1 = YYTRANSLATE (yychar);                           \
00355       YYPOPSTACK;                                               \
00356       goto yybackup;                                            \
00357     }                                                           \
00358   else                                                          \
00359     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
00360 while (0)
00361 
00362 #define YYTERROR        1
00363 #define YYERRCODE       256
00364 
00365 #ifndef YYPURE
00366 #define YYLEX           yylex()
00367 #endif
00368 
00369 #ifdef YYPURE
00370 #ifdef YYLSP_NEEDED
00371 #ifdef YYLEX_PARAM
00372 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
00373 #else
00374 #define YYLEX           yylex(&yylval, &yylloc)
00375 #endif
00376 #else /* not YYLSP_NEEDED */
00377 #ifdef YYLEX_PARAM
00378 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
00379 #else
00380 #define YYLEX           yylex(&yylval)
00381 #endif
00382 #endif /* not YYLSP_NEEDED */
00383 #endif
00384 
00385 /* If nonreentrant, generate the variables here */
00386 
00387 #ifndef YYPURE
00388 
00389 int     yychar;                 /*  the lookahead symbol                */
00390 YYSTYPE yylval;                 /*  the semantic value of the           */
00391                                 /*  lookahead symbol                    */
00392 
00393 #ifdef YYLSP_NEEDED
00394 YYLTYPE yylloc;                 /*  location data for the lookahead     */
00395                                 /*  symbol                              */
00396 #endif
00397 
00398 int yynerrs;                    /*  number of parse errors so far       */
00399 #endif  /* not YYPURE */
00400 
00401 #if YYDEBUG != 0
00402 int yydebug;                    /*  nonzero means print parse trace     */
00403 /* Since this is uninitialized, it does not stop multiple parsers
00404    from coexisting.  */
00405 #endif
00406 
00407 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
00408 
00409 #ifndef YYINITDEPTH
00410 #define YYINITDEPTH 200
00411 #endif
00412 
00413 /*  YYMAXDEPTH is the maximum size the stacks can grow to
00414     (effective only if the built-in stack extension method is used).  */
00415 
00416 #if YYMAXDEPTH == 0
00417 #undef YYMAXDEPTH
00418 #endif
00419 
00420 #ifndef YYMAXDEPTH
00421 #define YYMAXDEPTH 10000
00422 #endif
00423 
00424 /* Define __yy_memcpy.  Note that the size argument
00425    should be passed with type unsigned int, because that is what the non-GCC
00426    definitions require.  With GCC, __builtin_memcpy takes an arg
00427    of type size_t, but it can handle unsigned int.  */
00428 
00429 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
00430 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
00431 #else                           /* not GNU C or C++ */
00432 #ifndef __cplusplus
00433 
00434 /* This is the most reliable way to avoid incompatibilities
00435    in available built-in functions on various systems.  */
00436 static void
00437 __yy_memcpy (to, from, count)
00438      char *to;
00439      char *from;
00440      unsigned int count;
00441 {
00442   register char *f = from;
00443   register char *t = to;
00444   register int i = count;
00445 
00446   while (i-- > 0)
00447     *t++ = *f++;
00448 }
00449 
00450 #else /* __cplusplus */
00451 
00452 /* This is the most reliable way to avoid incompatibilities
00453    in available built-in functions on various systems.  */
00454 static void
00455 __yy_memcpy (char *to, char *from, unsigned int count)
00456 {
00457   register char *t = to;
00458   register char *f = from;
00459   register int i = count;
00460 
00461   while (i-- > 0)
00462     *t++ = *f++;
00463 }
00464 
00465 #endif
00466 #endif
00467 
00468 #line 217 "cfbison.simple"
00469 
00470 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
00471    into yyparse.  The argument should have type void *.
00472    It should actually point to an object.
00473    Grammar actions can access the variable by casting it
00474    to the proper pointer type.  */
00475 
00476 #ifdef YYPARSE_PARAM
00477 #ifdef __cplusplus
00478 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
00479 #define YYPARSE_PARAM_DECL
00480 #else /* not __cplusplus */
00481 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
00482 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
00483 #endif /* not __cplusplus */
00484 #else /* not YYPARSE_PARAM */
00485 #define YYPARSE_PARAM_ARG
00486 #define YYPARSE_PARAM_DECL
00487 #endif /* not YYPARSE_PARAM */
00488 
00489 /* Prevent warning if -Wstrict-prototypes.  */
00490 #ifdef __GNUC__
00491 #ifdef YYPARSE_PARAM
00492 int yyparse (void *);
00493 #else
00494 int yyparse (void);
00495 #endif
00496 #endif
00497 
00498 int
00499 yyparse(YYPARSE_PARAM_ARG)
00500      YYPARSE_PARAM_DECL
00501 {
00502   register int yystate;
00503   register int yyn;
00504   register short *yyssp;
00505   register YYSTYPE *yyvsp;
00506   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
00507   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
00508 
00509   short yyssa[YYINITDEPTH];     /*  the state stack                     */
00510   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
00511 
00512   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
00513   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
00514 
00515 #ifdef YYLSP_NEEDED
00516   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
00517   YYLTYPE *yyls = yylsa;
00518   YYLTYPE *yylsp;
00519 
00520 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
00521 #else
00522 #define YYPOPSTACK   (yyvsp--, yyssp--)
00523 #endif
00524 
00525   int yystacksize = YYINITDEPTH;
00526   int yyfree_stacks = 0;
00527 
00528 #ifdef YYPURE
00529   int yychar;
00530   YYSTYPE yylval;
00531   int yynerrs;
00532 #ifdef YYLSP_NEEDED
00533   YYLTYPE yylloc;
00534 #endif
00535 #endif
00536 
00537   YYSTYPE yyval;                /*  the variable used to return         */
00538                                 /*  semantic values from the action     */
00539                                 /*  routines                            */
00540  // ace: big fake for VC7 because it checks if yyval is init or not
00541   yyval.Val.Int = 0;
00542   int yylen;
00543 
00544 #if YYDEBUG != 0
00545   if (yydebug)
00546     fprintf(stderr, "Starting parse\n");
00547 #endif
00548 
00549   yystate = 0;
00550   yyerrstatus = 0;
00551   yynerrs = 0;
00552   yychar = YYEMPTY;             /* Cause a token to be read.  */
00553 
00554   /* Initialize stack pointers.
00555      Waste one element of value and location stack
00556      so that they stay on the same level as the state stack.
00557      The wasted elements are never initialized.  */
00558 
00559   yyssp = yyss - 1;
00560   yyvsp = yyvs;
00561 #ifdef YYLSP_NEEDED
00562   yylsp = yyls;
00563 #endif
00564 
00565 /* Push a new state, which is found in  yystate  .  */
00566 /* In all cases, when you get here, the value and location stacks
00567    have just been pushed. so pushing a state here evens the stacks.  */
00568 yynewstate:
00569 
00570   *++yyssp = yystate;
00571 
00572   if (yyssp >= yyss + yystacksize - 1)
00573     {
00574       /* Give user a chance to reallocate the stack */
00575       /* Use copies of these so that the &'s don't force the real ones into memory. */
00576       YYSTYPE *yyvs1 = yyvs;
00577       short *yyss1 = yyss;
00578 #ifdef YYLSP_NEEDED
00579       YYLTYPE *yyls1 = yyls;
00580 #endif
00581 
00582       /* Get the current used size of the three stacks, in elements.  */
00583       int size = yyssp - yyss + 1;
00584 
00585 #ifdef yyoverflow
00586       /* Each stack pointer address is followed by the size of
00587          the data in use in that stack, in bytes.  */
00588 #ifdef YYLSP_NEEDED
00589       /* This used to be a conditional around just the two extra args,
00590          but that might be undefined if yyoverflow is a macro.  */
00591       yyoverflow("parser stack overflow",
00592                  &yyss1, size * sizeof (*yyssp),
00593                  &yyvs1, size * sizeof (*yyvsp),
00594                  &yyls1, size * sizeof (*yylsp),
00595                  &yystacksize);
00596 #else
00597       yyoverflow("parser stack overflow",
00598                  &yyss1, size * sizeof (*yyssp),
00599                  &yyvs1, size * sizeof (*yyvsp),
00600                  &yystacksize);
00601 #endif
00602 
00603       yyss = yyss1; yyvs = yyvs1;
00604 #ifdef YYLSP_NEEDED
00605       yyls = yyls1;
00606 #endif
00607 #else /* no yyoverflow */
00608       /* Extend the stack our own way.  */
00609       if (yystacksize >= YYMAXDEPTH)
00610         {
00611           yyerror("parser stack overflow");
00612           if (yyfree_stacks)
00613             {
00614               free (yyss);
00615               free (yyvs);
00616 #ifdef YYLSP_NEEDED
00617               free (yyls);
00618 #endif
00619             }
00620           return 2;
00621         }
00622       yystacksize *= 2;
00623       if (yystacksize > YYMAXDEPTH)
00624         yystacksize = YYMAXDEPTH;
00625 #ifndef YYSTACK_USE_ALLOCA
00626       yyfree_stacks = 1;
00627 #endif
00628       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
00629       __yy_memcpy ((char *)yyss, (char *)yyss1,
00630                    size * (unsigned int) sizeof (*yyssp));
00631       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
00632       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
00633                    size * (unsigned int) sizeof (*yyvsp));
00634 #ifdef YYLSP_NEEDED
00635       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
00636       __yy_memcpy ((char *)yyls, (char *)yyls1,
00637                    size * (unsigned int) sizeof (*yylsp));
00638 #endif
00639 #endif /* no yyoverflow */
00640 
00641       yyssp = yyss + size - 1;
00642       yyvsp = yyvs + size - 1;
00643 #ifdef YYLSP_NEEDED
00644       yylsp = yyls + size - 1;
00645 #endif
00646 
00647 #if YYDEBUG != 0
00648       if (yydebug)
00649         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
00650 #endif
00651 
00652       if (yyssp >= yyss + yystacksize - 1)
00653         YYABORT;
00654     }
00655 
00656 #if YYDEBUG != 0
00657   if (yydebug)
00658     fprintf(stderr, "Entering state %d\n", yystate);
00659 #endif
00660 
00661   goto yybackup;
00662  yybackup:
00663 
00664 /* Do appropriate processing given the current state.  */
00665 /* Read a lookahead token if we need one and don't already have one.  */
00666 /* yyresume: */
00667 
00668   /* First try to decide what to do without reference to lookahead token.  */
00669 
00670   yyn = yypact[yystate];
00671   if (yyn == YYFLAG)
00672     goto yydefault;
00673 
00674   /* Not known => get a lookahead token if don't already have one.  */
00675 
00676   /* yychar is either YYEMPTY or YYEOF
00677      or a valid token in external form.  */
00678 
00679   if (yychar == YYEMPTY)
00680     {
00681 #if YYDEBUG != 0
00682       if (yydebug)
00683         fprintf(stderr, "Reading a token: ");
00684 #endif
00685       yychar = YYLEX;
00686     }
00687 
00688   /* Convert token to internal form (in yychar1) for indexing tables with */
00689 
00690   if (yychar <= 0)              /* This means end of input. */
00691     {
00692       yychar1 = 0;
00693       yychar = YYEOF;           /* Don't call YYLEX any more */
00694 
00695 #if YYDEBUG != 0
00696       if (yydebug)
00697         fprintf(stderr, "Now at end of input.\n");
00698 #endif
00699     }
00700   else
00701     {
00702       yychar1 = YYTRANSLATE(yychar);
00703 
00704 #if YYDEBUG != 0
00705       if (yydebug)
00706         {
00707           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
00708           /* Give the individual parser a way to print the precise meaning
00709              of a token, for further debugging info.  */
00710 #ifdef YYPRINT
00711           YYPRINT (stderr, yychar, yylval);
00712 #endif
00713           fprintf (stderr, ")\n");
00714         }
00715 #endif
00716     }
00717 
00718   yyn += yychar1;
00719   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
00720     goto yydefault;
00721 
00722   yyn = yytable[yyn];
00723 
00724   /* yyn is what to do for this token type in this state.
00725      Negative => reduce, -yyn is rule number.
00726      Positive => shift, yyn is new state.
00727        New state is final state => don't bother to shift,
00728        just return success.
00729      0, or most negative number => error.  */
00730 
00731   if (yyn < 0)
00732     {
00733       if (yyn == YYFLAG)
00734         goto yyerrlab;
00735       yyn = -yyn;
00736       goto yyreduce;
00737     }
00738   else if (yyn == 0)
00739     goto yyerrlab;
00740 
00741   if (yyn == YYFINAL)
00742     YYACCEPT;
00743 
00744   /* Shift the lookahead token.  */
00745 
00746 #if YYDEBUG != 0
00747   if (yydebug)
00748     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
00749 #endif
00750 
00751   /* Discard the token being shifted unless it is eof.  */
00752   if (yychar != YYEOF)
00753     yychar = YYEMPTY;
00754 
00755   *++yyvsp = yylval;
00756 #ifdef YYLSP_NEEDED
00757   *++yylsp = yylloc;
00758 #endif
00759 
00760   /* count tokens shifted since error; after three, turn off error status.  */
00761   if (yyerrstatus) yyerrstatus--;
00762 
00763   yystate = yyn;
00764   goto yynewstate;
00765 
00766 /* Do the default action for the current state.  */
00767 yydefault:
00768 
00769   yyn = yydefact[yystate];
00770   if (yyn == 0)
00771     goto yyerrlab;
00772 
00773 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
00774 yyreduce:
00775   yylen = yyr2[yyn];
00776   if (yylen > 0)
00777     yyval = yyvsp[1-yylen]; /* implement default value of the action */
00778 
00779 #if YYDEBUG != 0
00780   if (yydebug)
00781     {
00782       int i;
00783 
00784       fprintf (stderr, "Reducing via rule %d (line %d), ",
00785                yyn, yyrline[yyn]);
00786 
00787       /* Print the symbols being reduced, and their result.  */
00788       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
00789         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
00790       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
00791     }
00792 #endif
00793 
00794 
00795   switch (yyn) {
00796 
00797 case 1:
00798 #line 100 "cf_gramatical.yxx"
00799 { cf_CurrentLine = 1; cf_Ignore = false; ;
00800     break;}
00801 case 3:
00802 #line 100 "cf_gramatical.yxx"
00803 { ;
00804     break;}
00805 case 4:
00806 #line 103 "cf_gramatical.yxx"
00807 { ;
00808     break;}
00809 case 5:
00810 #line 104 "cf_gramatical.yxx"
00811 { ;
00812     break;}
00813 case 6:
00814 #line 108 "cf_gramatical.yxx"
00815 {
00816                                 DEBUG_PRINT("                                   (VARIABLE=");
00817                                 cf_print (yyvsp[-3].Val);
00818                                 DEBUG_PRINT("), (VALUE=");
00819                                 cf_print (yyvsp[-1].Val);
00820                                 DEBUG_PRINT(")\n");
00821                                 int i;
00822                                 // on recherche l'existence de la variable
00823                                 for(i = 0; i < (int)((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).size()); i++)
00824                                 {
00825                                         if ((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Name == yyvsp[-3].Val.String)
00826                                         {
00827                                                 if (cf_OverwriteExistingVariable)
00828                                                 {
00829                                                         DEBUG_PRINTF("Variable '%s' existe deja, ecrasement\n", yyvsp[-3].Val.String);
00830                                                 }
00831                                                 break;
00832                                         }
00833                                 }
00834                                 NLMISC::CConfigFile::CVar Var;
00835                                 Var.Comp = false;
00836                                 Var.Callback = NULL;
00837                                 if (cf_CurrentVar.Comp) Var = cf_CurrentVar;
00838                                 else cf_setVar (Var, yyvsp[-1].Val);
00839                                 Var.Name = yyvsp[-3].Val.String;
00840                                 if (i == (int)((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).size ()))
00841                                 {
00842                                         // nouvelle variable
00843                                         DEBUG_PRINTF ("yacc: new assign var '%s'\n", yyvsp[-3].Val.String);
00844                                         (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).push_back (Var);
00845                                 }
00846                                 else if (cf_OverwriteExistingVariable)
00847                                 {
00848                                         // reaffectation d'une variable
00849                                         Var.Callback = (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Callback;
00850                                         DEBUG_PRINTF ("yacc: reassign var '%s'\n", yyvsp[-3].Val.String);
00851                                         if (Var != (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i] && Var.Callback != NULL)
00852                                                 (Var.Callback)(Var);
00853                                         (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i] = Var;
00854                                 }
00855                                 else
00856                                 {
00857                                         DEBUG_PRINTF ("yacc: don't reassign var '%s' because cf_OverwriteExistingVariable is false\n", yyvsp[-3].Val.String);
00858                                 }
00859 
00860                                 cf_CurrentVar.IntValues.clear ();
00861                                 cf_CurrentVar.RealValues.clear ();
00862                                 cf_CurrentVar.StrValues.clear ();
00863                                 cf_CurrentVar.Comp = false;
00864                                 cf_CurrentVar.Type = NLMISC::CConfigFile::CVar::T_UNKNOWN;
00865                         ;
00866     break;}
00867 case 7:
00868 #line 162 "cf_gramatical.yxx"
00869 {
00870                                 DEBUG_PRINT("                                   (VARIABLE+=");
00871                                 cf_print (yyvsp[-3].Val);
00872                                 DEBUG_PRINT("), (VALUE=");
00873                                 cf_print (yyvsp[-1].Val);
00874                                 DEBUG_PRINT(")\n");
00875                                 int i;
00876                                 // on recherche l'existence de la variable
00877                                 for(i = 0; i < (int)((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).size()); i++)
00878                                 {
00879                                         if ((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Name == yyvsp[-3].Val.String)
00880                                         {
00881                                                 DEBUG_PRINTF("Variable '%s' existe deja, ajout\n", yyvsp[-3].Val.String);
00882                                                 break;
00883                                         }
00884                                 }
00885                                 NLMISC::CConfigFile::CVar Var;
00886                                 Var.Comp = false;
00887                                 Var.Callback = NULL;
00888                                 if (cf_CurrentVar.Comp) Var = cf_CurrentVar;
00889                                 else cf_setVar (Var, yyvsp[-1].Val);
00890                                 Var.Name = yyvsp[-3].Val.String;
00891                                 if (i == (int)((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).size ()))
00892                                 {
00893                                         // nouvelle variable
00894                                         DEBUG_PRINTF ("yacc: new add assign var '%s'\n", yyvsp[-3].Val.String);
00895                                         (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).push_back (Var);
00896                                 }
00897                                 else
00898                                 {
00899                                         // reaffectation d'une variable
00900                                         Var.Callback = (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Callback;
00901                                         DEBUG_PRINTF ("yacc: add assign var '%s'\n", yyvsp[-3].Val.String);
00902                                         Var.add ((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i]);
00903                                         if (Var != (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i] && Var.Callback != NULL)
00904                                                 (Var.Callback)(Var);
00905                                         (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i] = Var;
00906                                 }
00907 
00908                                 cf_CurrentVar.IntValues.clear ();
00909                                 cf_CurrentVar.RealValues.clear ();
00910                                 cf_CurrentVar.StrValues.clear ();
00911                                 cf_CurrentVar.Comp = false;
00912                                 cf_CurrentVar.Type = NLMISC::CConfigFile::CVar::T_UNKNOWN;
00913                         ;
00914     break;}
00915 case 8:
00916 #line 209 "cf_gramatical.yxx"
00917 { yyval.Val = yyvsp[0].Val; cf_CurrentVar.Comp = false; DEBUG_PRINT("false\n"); ;
00918     break;}
00919 case 9:
00920 #line 210 "cf_gramatical.yxx"
00921 { yyval.Val = yyvsp[-1].Val; cf_CurrentVar.Comp = true; DEBUG_PRINT("true\n"); ;
00922     break;}
00923 case 10:
00924 #line 213 "cf_gramatical.yxx"
00925 { yyval.Val =  yyvsp[0].Val; /*cf_CurrentVar.Type = $1.Type;*/ cf_setVar (cf_CurrentVar, yyvsp[0].Val); ;
00926     break;}
00927 case 11:
00928 #line 214 "cf_gramatical.yxx"
00929 { yyval.Val = yyvsp[0].Val; /*cf_CurrentVar.Type = $1.Type;*/ cf_setVar (cf_CurrentVar, yyvsp[0].Val); ;
00930     break;}
00931 case 13:
00932 #line 215 "cf_gramatical.yxx"
00933 { ;
00934     break;}
00935 case 14:
00936 #line 218 "cf_gramatical.yxx"
00937 { yyval.Val = yyvsp[0].Val; ;
00938     break;}
00939 case 15:
00940 #line 219 "cf_gramatical.yxx"
00941 { yyval.Val = cf_op(yyvsp[-2].Val, yyvsp[0].Val, OP_PLUS); ;
00942     break;}
00943 case 16:
00944 #line 220 "cf_gramatical.yxx"
00945 { yyval.Val = cf_op(yyvsp[-2].Val, yyvsp[0].Val, OP_MINUS); ;
00946     break;}
00947 case 17:
00948 #line 223 "cf_gramatical.yxx"
00949 { yyval.Val = yyvsp[0].Val; ;
00950     break;}
00951 case 18:
00952 #line 224 "cf_gramatical.yxx"
00953 { yyval.Val = cf_op(yyvsp[-2].Val, yyvsp[0].Val, OP_MULT); ;
00954     break;}
00955 case 19:
00956 #line 225 "cf_gramatical.yxx"
00957 { yyval.Val = cf_op (yyvsp[-2].Val, yyvsp[0].Val, OP_DIVIDE); ;
00958     break;}
00959 case 20:
00960 #line 228 "cf_gramatical.yxx"
00961 { yyval.Val = yyvsp[0].Val; ;
00962     break;}
00963 case 21:
00964 #line 229 "cf_gramatical.yxx"
00965 { cf_value v; v.Type=NLMISC::CConfigFile::CVar::T_INT; /* just to avoid a warning, I affect 'v' with a dummy value */ yyval.Val = cf_op(yyvsp[0].Val,v,OP_NEG); ;
00966     break;}
00967 case 22:
00968 #line 230 "cf_gramatical.yxx"
00969 { yyval.Val = yyvsp[-1].Val; ;
00970     break;}
00971 case 23:
00972 #line 231 "cf_gramatical.yxx"
00973 { yyval.Val = yylval.Val; ;
00974     break;}
00975 case 24:
00976 #line 232 "cf_gramatical.yxx"
00977 { yyval.Val = yylval.Val; ;
00978     break;}
00979 case 25:
00980 #line 233 "cf_gramatical.yxx"
00981 { yyval.Val = yylval.Val; ;
00982     break;}
00983 case 26:
00984 #line 234 "cf_gramatical.yxx"
00985 { yyval.Val = yyvsp[0].Val; ;
00986     break;}
00987 case 27:
00988 #line 238 "cf_gramatical.yxx"
00989 {
00990                                 DEBUG_PRINT("yacc: cont\n");
00991                                 bool ok=false;
00992                                 int i;
00993                                 for(i = 0; i < (int)((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM))).size()); i++)
00994                                 {
00995                                         if ((*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Name == yyvsp[0].Val.String)
00996                                         {
00997                                                 ok = true;
00998                                                 break;
00999                                         }
01000                                 }
01001                                 if (ok)
01002                                 {
01003                                         cf_value Var;
01004                                         Var.Type = (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].Type;
01005                                         DEBUG_PRINTF("vart %d\n", Var.Type);
01006                                         switch (Var.Type)
01007                                         {
01008                                         case NLMISC::CConfigFile::CVar::T_INT: Var.Int = (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].IntValues[0]; break;
01009                                         case NLMISC::CConfigFile::CVar::T_REAL: Var.Real = (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].RealValues[0]; break;
01010                                         case NLMISC::CConfigFile::CVar::T_STRING: strcpy (Var.String, (*((vector<NLMISC::CConfigFile::CVar>*)(YYPARSE_PARAM)))[i].StrValues[0].c_str()); break;
01011                                         default: DEBUG_PRINT("*** CAN T DO THAT!!!\n"); break;
01012                                         }
01013                                         yyval.Val = Var;
01014                                 }
01015                                 else
01016                                 {
01017                                         DEBUG_PRINT("var existe pas\n");
01018                                 }
01019                         ;
01020     break;}
01021 }
01022    /* the action file gets copied in in place of this dollarsign */
01023 #line 543 "cfbison.simple"
01024 
01025   yyvsp -= yylen;
01026   yyssp -= yylen;
01027 #ifdef YYLSP_NEEDED
01028   yylsp -= yylen;
01029 #endif
01030 
01031 #if YYDEBUG != 0
01032   if (yydebug)
01033     {
01034       short *ssp1 = yyss - 1;
01035       fprintf (stderr, "state stack now");
01036       while (ssp1 != yyssp)
01037         fprintf (stderr, " %d", *++ssp1);
01038       fprintf (stderr, "\n");
01039     }
01040 #endif
01041 
01042   *++yyvsp = yyval;
01043 
01044 #ifdef YYLSP_NEEDED
01045   yylsp++;
01046   if (yylen == 0)
01047     {
01048       yylsp->first_line = yylloc.first_line;
01049       yylsp->first_column = yylloc.first_column;
01050       yylsp->last_line = (yylsp-1)->last_line;
01051       yylsp->last_column = (yylsp-1)->last_column;
01052       yylsp->text = 0;
01053     }
01054   else
01055     {
01056       yylsp->last_line = (yylsp+yylen-1)->last_line;
01057       yylsp->last_column = (yylsp+yylen-1)->last_column;
01058     }
01059 #endif
01060 
01061   /* Now "shift" the result of the reduction.
01062      Determine what state that goes to,
01063      based on the state we popped back to
01064      and the rule number reduced by.  */
01065 
01066   yyn = yyr1[yyn];
01067 
01068   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
01069   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01070     yystate = yytable[yystate];
01071   else
01072     yystate = yydefgoto[yyn - YYNTBASE];
01073 
01074   goto yynewstate;
01075 
01076 yyerrlab:   /* here on detecting error */
01077 
01078   if (! yyerrstatus)
01079     /* If not already recovering from an error, report this error.  */
01080     {
01081       ++yynerrs;
01082 
01083 #ifdef YYERROR_VERBOSE
01084       yyn = yypact[yystate];
01085 
01086       if (yyn > YYFLAG && yyn < YYLAST)
01087         {
01088           int size = 0;
01089           char *msg;
01090           int x, count;
01091 
01092           count = 0;
01093           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
01094           for (x = (yyn < 0 ? -yyn : 0);
01095                x < (sizeof(yytname) / sizeof(char *)); x++)
01096             if (yycheck[x + yyn] == x)
01097               size += strlen(yytname[x]) + 15, count++;
01098           msg = (char *) malloc(size + 15);
01099           if (msg != 0)
01100             {
01101               strcpy(msg, "parse error");
01102 
01103               if (count < 5)
01104                 {
01105                   count = 0;
01106                   for (x = (yyn < 0 ? -yyn : 0);
01107                        x < (sizeof(yytname) / sizeof(char *)); x++)
01108                     if (yycheck[x + yyn] == x)
01109                       {
01110                         strcat(msg, count == 0 ? ", expecting `" : " or `");
01111                         strcat(msg, yytname[x]);
01112                         strcat(msg, "'");
01113                         count++;
01114                       }
01115                 }
01116               yyerror(msg);
01117               free(msg);
01118             }
01119           else
01120             yyerror ("parse error; also virtual memory exceeded");
01121         }
01122       else
01123 #endif /* YYERROR_VERBOSE */
01124         yyerror("parse error");
01125     }
01126 
01127   goto yyerrlab1;
01128 yyerrlab1:   /* here on error raised explicitly by an action */
01129 
01130   if (yyerrstatus == 3)
01131     {
01132       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
01133 
01134       /* return failure if at end of input */
01135       if (yychar == YYEOF)
01136         YYABORT;
01137 
01138 #if YYDEBUG != 0
01139       if (yydebug)
01140         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
01141 #endif
01142 
01143       yychar = YYEMPTY;
01144     }
01145 
01146   /* Else will try to reuse lookahead token
01147      after shifting the error token.  */
01148 
01149   yyerrstatus = 3;              /* Each real token shifted decrements this */
01150 
01151   goto yyerrhandle;
01152 
01153 yyerrdefault:  /* current state does not do anything special for the error token. */
01154 
01155 #if 0
01156   /* This is wrong; only states that explicitly want error tokens
01157      should shift them.  */
01158   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
01159   if (yyn) goto yydefault;
01160 #endif
01161 
01162 yyerrpop:   /* pop the current state because it cannot handle the error token */
01163 
01164   if (yyssp == yyss) YYABORT;
01165   yyvsp--;
01166   yystate = *--yyssp;
01167 #ifdef YYLSP_NEEDED
01168   yylsp--;
01169 #endif
01170 
01171 #if YYDEBUG != 0
01172   if (yydebug)
01173     {
01174       short *ssp1 = yyss - 1;
01175       fprintf (stderr, "Error: state stack now");
01176       while (ssp1 != yyssp)
01177         fprintf (stderr, " %d", *++ssp1);
01178       fprintf (stderr, "\n");
01179     }
01180 #endif
01181 
01182 yyerrhandle:
01183 
01184   yyn = yypact[yystate];
01185   if (yyn == YYFLAG)
01186     goto yyerrdefault;
01187 
01188   yyn += YYTERROR;
01189   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
01190     goto yyerrdefault;
01191 
01192   yyn = yytable[yyn];
01193   if (yyn < 0)
01194     {
01195       if (yyn == YYFLAG)
01196         goto yyerrpop;
01197       yyn = -yyn;
01198       goto yyreduce;
01199     }
01200   else if (yyn == 0)
01201     goto yyerrpop;
01202 
01203   if (yyn == YYFINAL)
01204     YYACCEPT;
01205 
01206 #if YYDEBUG != 0
01207   if (yydebug)
01208     fprintf(stderr, "Shifting error token, ");
01209 #endif
01210 
01211   *++yyvsp = yylval;
01212 #ifdef YYLSP_NEEDED
01213   *++yylsp = yylloc;
01214 #endif
01215 
01216   yystate = yyn;
01217   goto yynewstate;
01218 
01219  yyacceptlab:
01220   /* YYACCEPT comes here.  */
01221   if (yyfree_stacks)
01222     {
01223       free (yyss);
01224       free (yyvs);
01225 #ifdef YYLSP_NEEDED
01226       free (yyls);
01227 #endif
01228     }
01229   return 0;
01230 
01231  yyabortlab:
01232   /* YYABORT comes here.  */
01233   if (yyfree_stacks)
01234     {
01235       free (yyss);
01236       free (yyvs);
01237 #ifdef YYLSP_NEEDED
01238       free (yyls);
01239 #endif
01240     }
01241   return 1;
01242 }
01243 #line 270 "cf_gramatical.yxx"
01244 
01245 
01246 /* compute the good operation with a, b and op */
01247 cf_value cf_op (cf_value a, cf_value b, cf_operation op)
01248 {
01249         DEBUG_PRINTF("[OP:%d; ", op);
01250         cf_print(a);
01251         DEBUG_PRINT("; ");
01252         cf_print(b);
01253         DEBUG_PRINT("; ");
01254 
01255         switch (op)
01256         {
01257         case OP_MULT:                                                                                                                           //  *********************
01258                 switch (a.Type)
01259                 {
01260                 case NLMISC::CConfigFile::CVar::T_INT:
01261                         switch (b.Type)
01262                         {
01263                         case NLMISC::CConfigFile::CVar::T_INT:          a.Int *= b.Int; break;
01264                         case NLMISC::CConfigFile::CVar::T_REAL: a.Int *= (int)b.Real; break;
01265                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: int*str\n"); break;
01266                         default: break;
01267                         }
01268                         break;
01269                 case NLMISC::CConfigFile::CVar::T_REAL:
01270                         switch (b.Type)
01271                         {
01272                         case NLMISC::CConfigFile::CVar::T_INT:          a.Real *= (double)b.Int; break;
01273                         case NLMISC::CConfigFile::CVar::T_REAL: a.Real *= b.Real; break;
01274                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: real*str\n"); break;
01275                         default: break;
01276                         }
01277                         break;
01278                 case NLMISC::CConfigFile::CVar::T_STRING:
01279                         switch (b.Type)
01280                         {
01281                         case NLMISC::CConfigFile::CVar::T_INT:          DEBUG_PRINT("ERROR: str*int\n");  break;
01282                         case NLMISC::CConfigFile::CVar::T_REAL: DEBUG_PRINT("ERROR: str*real\n");  break;
01283                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: str*str\n");  break;
01284                         default: break;
01285                         }
01286                         break;
01287                 default: break;
01288                 }
01289                 break;
01290         case OP_DIVIDE:                                                                                                                         //  //////////////////////
01291                 switch (a.Type)
01292                 {
01293                 case NLMISC::CConfigFile::CVar::T_INT:
01294                         switch (b.Type)
01295                         {
01296                         case NLMISC::CConfigFile::CVar::T_INT:          a.Int /= b.Int; break;
01297                         case NLMISC::CConfigFile::CVar::T_REAL: a.Int /= (int)b.Real; break;
01298                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: int/str\n"); break;
01299                         default: break;
01300                         }
01301                         break;
01302                 case NLMISC::CConfigFile::CVar::T_REAL:
01303                         switch (b.Type)
01304                         {
01305                         case NLMISC::CConfigFile::CVar::T_INT:          a.Real /= (double)b.Int; break;
01306                         case NLMISC::CConfigFile::CVar::T_REAL: a.Real /= b.Real; break;
01307                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: real/str\n"); break;
01308                         default: break;
01309                         }
01310                         break;
01311                 case NLMISC::CConfigFile::CVar::T_STRING:
01312                         switch (b.Type)
01313                         {
01314                         case NLMISC::CConfigFile::CVar::T_INT:          DEBUG_PRINT("ERROR: str/int\n"); break;
01315                         case NLMISC::CConfigFile::CVar::T_REAL: DEBUG_PRINT("ERROR: str/real\n"); break;
01316                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: str/str\n"); break;
01317                          default: break;
01318                         }
01319                         break;
01320                 default: break;
01321                 }
01322                 break;
01323         case OP_PLUS:                                                                                                                           //  ++++++++++++++++++++++++
01324                 switch (a.Type)
01325                 {
01326                 case NLMISC::CConfigFile::CVar::T_INT:
01327                         switch (b.Type)
01328                         {
01329                         case NLMISC::CConfigFile::CVar::T_INT:  a.Int += b.Int; break;
01330                         case NLMISC::CConfigFile::CVar::T_REAL: a.Int += (int)b.Real; break;
01331                         case NLMISC::CConfigFile::CVar::T_STRING:       a.Int += atoi(b.String); break;
01332                         default: break;
01333                         }
01334                         break;
01335                 case NLMISC::CConfigFile::CVar::T_REAL:
01336                         switch (b.Type)
01337                         {
01338                         case NLMISC::CConfigFile::CVar::T_INT:  a.Real += (double)b.Int; break;
01339                         case NLMISC::CConfigFile::CVar::T_REAL: a.Real += b.Real; break;
01340                         case NLMISC::CConfigFile::CVar::T_STRING:       a.Real += atof (b.String); break;
01341                         default: break;
01342                         }
01343                         break;
01344                 case NLMISC::CConfigFile::CVar::T_STRING:
01345                         switch (b.Type)
01346                         {
01347                         case NLMISC::CConfigFile::CVar::T_INT:  { char str2[60]; NLMISC::smprintf(str2, 60, "%d", b.Int); strcat(a.String, str2); break; }
01348                         case NLMISC::CConfigFile::CVar::T_REAL: { char str2[60]; NLMISC::smprintf(str2, 60, "%f", b.Real); strcat(a.String, str2); break; }
01349                         case NLMISC::CConfigFile::CVar::T_STRING:       strcat (a.String, b.String); break;
01350                         default: break;
01351                         }
01352                         break;
01353                 default: break;
01354                 }
01355                 break;
01356         case OP_MINUS:                                                                                                                          //  -------------------------
01357                 switch (a.Type)
01358                 {
01359                 case NLMISC::CConfigFile::CVar::T_INT:
01360                         switch (b.Type)
01361                         {
01362                         case NLMISC::CConfigFile::CVar::T_INT:  a.Int -= b.Int; break;
01363                         case NLMISC::CConfigFile::CVar::T_REAL: a.Int -= (int)b.Real; break;
01364                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: int-str\n"); break;
01365                         default: break;
01366                         }
01367                         break;
01368                 case NLMISC::CConfigFile::CVar::T_REAL:
01369                         switch (b.Type)
01370                         {
01371                         case NLMISC::CConfigFile::CVar::T_INT:  a.Real -= (double)b.Int; break;
01372                         case NLMISC::CConfigFile::CVar::T_REAL: a.Real -= b.Real; break;
01373                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: real-str\n"); break;
01374                         default: break;
01375                         }
01376                         break;
01377                 case NLMISC::CConfigFile::CVar::T_STRING:
01378                         switch (b.Type)
01379                         {
01380                         case NLMISC::CConfigFile::CVar::T_INT:  DEBUG_PRINT("ERROR: str-int\n"); break;
01381                         case NLMISC::CConfigFile::CVar::T_REAL: DEBUG_PRINT("ERROR: str-real\n"); break;
01382                         case NLMISC::CConfigFile::CVar::T_STRING:       DEBUG_PRINT("ERROR: str-str\n"); break;
01383                         default: break;
01384                         }
01385                         break;
01386                 default: break;
01387                 }
01388                 break;
01389         case OP_NEG:                                                                                                                            // neg
01390                 switch (a.Type)
01391                 {
01392                 case NLMISC::CConfigFile::CVar::T_INT:          a.Int = -a.Int; break;
01393                 case NLMISC::CConfigFile::CVar::T_REAL:         a.Real = -a.Real; break;
01394                 case NLMISC::CConfigFile::CVar::T_STRING:               DEBUG_PRINT("ERROR: -str\n"); break;
01395                 default: break;
01396                 }
01397                 break;
01398         }
01399         cf_print(a);
01400         DEBUG_PRINT("]\n");
01401         return a;
01402 }
01403 
01404 /* print a value, it's only for debug purpose */
01405 void cf_print (cf_value Val)
01406 {
01407         switch (Val.Type)
01408         {
01409         case NLMISC::CConfigFile::CVar::T_INT:
01410                 DEBUG_PRINTF("'%d'", Val.Int);
01411                 break;
01412         case NLMISC::CConfigFile::CVar::T_REAL:
01413                 DEBUG_PRINTF("`%f`", Val.Real);
01414                 break;
01415         case NLMISC::CConfigFile::CVar::T_STRING:
01416                 DEBUG_PRINTF("\"%s\"", Val.String);
01417                 break;
01418         default: break;
01419         }
01420 }
01421 
01422 /* put a value into a var */
01423 void cf_setVar (NLMISC::CConfigFile::CVar &Var, cf_value Val)
01424 {
01425         DEBUG_PRINTF("push type %d in var name '%s' type %d with value : ", Val.Type, Var.Name.c_str(), Var.Type);
01426         cf_print(Val);
01427         DEBUG_PRINTF("\n");
01428         if (Var.Type == NLMISC::CConfigFile::CVar::T_UNKNOWN || Var.Type == Val.Type)
01429         {
01430                 if (Var.Type == NLMISC::CConfigFile::CVar::T_UNKNOWN)
01431                 {
01432                         DEBUG_PRINTF("val type is unknown, set to the var type\n");
01433                 }
01434                 else
01435                 {
01436                         DEBUG_PRINTF("val type is same var type, just add\n");
01437                 }
01438 
01439                 Var.Type = Val.Type;
01440                 switch (Val.Type)
01441                 {
01442                 case NLMISC::CConfigFile::CVar::T_INT: Var.IntValues.push_back (Val.Int); break;
01443                 case NLMISC::CConfigFile::CVar::T_REAL: Var.RealValues.push_back (Val.Real); break;
01444                 case NLMISC::CConfigFile::CVar::T_STRING: Var.StrValues.push_back(Val.String); break;
01445                 default: break;
01446                 }
01447         }
01448         else
01449         {
01450                 // need to convert the type
01451                 switch (Var.Type)
01452                 {
01453                 case NLMISC::CConfigFile::CVar::T_INT:
01454                         switch (Val.Type)
01455                         {
01456                         case NLMISC::CConfigFile::CVar::T_REAL:         Var.IntValues.push_back ((int)Val.Real); break;
01457                         case NLMISC::CConfigFile::CVar::T_STRING:       Var.IntValues.push_back (atoi(Val.String)); break;
01458                         default: break;
01459                         }
01460                         break;
01461                 case NLMISC::CConfigFile::CVar::T_REAL:
01462                         switch (Val.Type)
01463                         {
01464                         case NLMISC::CConfigFile::CVar::T_INT:          Var.RealValues.push_back ((double)Val.Int); break;
01465                         case NLMISC::CConfigFile::CVar::T_STRING:       Var.RealValues.push_back (atof(Val.String)); break;
01466                         default: break;
01467                         }
01468                         break;
01469                 case NLMISC::CConfigFile::CVar::T_STRING:
01470                         switch (Val.Type)
01471                         {
01472                         case NLMISC::CConfigFile::CVar::T_INT:  Var.StrValues.push_back(toString(Val.Int)); break;
01473                         case NLMISC::CConfigFile::CVar::T_REAL: Var.StrValues.push_back(toString(Val.Real)); break;
01474                         default: break;
01475                         }
01476                         break;
01477                 default: break;
01478                 }
01479         }
01480 }
01481 
01482 int yyerror (const char *s)
01483 {
01484         DEBUG_PRINTF("%s\n",s);
01485         return 1;
01486 }
01487 
01488