diff options
Diffstat (limited to 'pango/mini-xft/minixftgram.c')
| -rw-r--r-- | pango/mini-xft/minixftgram.c | 1498 |
1 files changed, 1498 insertions, 0 deletions
diff --git a/pango/mini-xft/minixftgram.c b/pango/mini-xft/minixftgram.c new file mode 100644 index 00000000..d4798f54 --- /dev/null +++ b/pango/mini-xft/minixftgram.c @@ -0,0 +1,1498 @@ + +/* A Bison parser, made from minixftgram.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define INTEGER 257 +#define DOUBLE 258 +#define STRING 259 +#define NAME 260 +#define ANY 261 +#define ALL 262 +#define DIR 263 +#define CACHE 264 +#define INCLUDE 265 +#define INCLUDEIF 266 +#define MATCH 267 +#define EDIT 268 +#define TOK_TRUE 269 +#define TOK_FALSE 270 +#define TOK_NIL 271 +#define EQUAL 272 +#define SEMI 273 +#define OS 274 +#define CS 275 +#define QUEST 276 +#define COLON 277 +#define OROR 278 +#define ANDAND 279 +#define EQEQ 280 +#define NOTEQ 281 +#define LESS 282 +#define LESSEQ 283 +#define MORE 284 +#define MOREEQ 285 +#define PLUS 286 +#define MINUS 287 +#define TIMES 288 +#define DIVIDE 289 +#define NOT 290 + +#line 25 "minixftgram.y" + + +#include <stdlib.h> +#include <stdio.h> +#include "minixftint.h" + +static MiniXftMatrix matrix; + + +#line 35 "minixftgram.y" +typedef union { + int ival; + double dval; + char *sval; + MiniXftExpr *eval; + MiniXftPattern *pval; + MiniXftValue vval; + MiniXftEdit *Eval; + MiniXftOp oval; + MiniXftQual qval; + MiniXftTest *tval; +} YYSTYPE; +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 95 +#define YYFLAG -32768 +#define YYNTBASE 37 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 290 ? MiniXftConfigtranslate[x] : 51) + +static const char MiniXftConfigtranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 +}; + +#if YYDEBUG != 0 +static const short MiniXftConfigprhs[] = { 0, + 0, 3, 4, 7, 10, 13, 16, 21, 24, 25, + 30, 32, 34, 35, 37, 39, 41, 43, 45, 47, + 49, 51, 53, 55, 57, 59, 61, 63, 65, 72, + 74, 76, 79, 80, 85, 87, 90, 93, 95, 97, + 99, 101, 103, 105, 107, 109, 113, 117, 121, 125, + 129, 133, 137, 141, 145, 149, 153, 157, 160 +}; + +static const short MiniXftConfigrhs[] = { 37, + 38, 0, 0, 9, 5, 0, 10, 5, 0, 11, + 5, 0, 12, 5, 0, 13, 39, 14, 47, 0, + 40, 39, 0, 0, 41, 42, 43, 44, 0, 7, + 0, 8, 0, 0, 6, 0, 18, 0, 26, 0, + 27, 0, 28, 0, 29, 0, 30, 0, 31, 0, + 3, 0, 4, 0, 5, 0, 15, 0, 16, 0, + 17, 0, 45, 0, 20, 46, 46, 46, 46, 21, + 0, 3, 0, 4, 0, 48, 47, 0, 0, 42, + 49, 50, 19, 0, 18, 0, 32, 18, 0, 18, + 32, 0, 3, 0, 4, 0, 5, 0, 15, 0, + 16, 0, 17, 0, 45, 0, 6, 0, 50, 24, + 50, 0, 50, 25, 50, 0, 50, 26, 50, 0, + 50, 27, 50, 0, 50, 28, 50, 0, 50, 29, + 50, 0, 50, 30, 50, 0, 50, 31, 50, 0, + 50, 32, 50, 0, 50, 33, 50, 0, 50, 34, + 50, 0, 50, 35, 50, 0, 36, 50, 0, 50, + 22, 50, 23, 50, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short MiniXftConfigrline[] = { 0, + 77, 78, 80, 82, 84, 86, 88, 91, 93, 96, + 99, 101, 103, 106, 111, 113, 115, 117, 119, 121, + 123, 126, 131, 136, 141, 146, 151, 155, 161, 168, + 170, 172, 174, 177, 180, 182, 184, 187, 189, 191, + 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, + 213, 215, 217, 219, 221, 223, 225, 227, 229 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const MiniXftConfigtname[] = { "$","error","$undefined.","INTEGER", +"DOUBLE","STRING","NAME","ANY","ALL","DIR","CACHE","INCLUDE","INCLUDEIF","MATCH", +"EDIT","TOK_TRUE","TOK_FALSE","TOK_NIL","EQUAL","SEMI","OS","CS","QUEST","COLON", +"OROR","ANDAND","EQEQ","NOTEQ","LESS","LESSEQ","MORE","MOREEQ","PLUS","MINUS", +"TIMES","DIVIDE","NOT","configs","config","tests","test","qual","field","compare", +"value","matrix","number","edits","edit","eqop","expr", NULL +}; +#endif + +static const short MiniXftConfigr1[] = { 0, + 37, 37, 38, 38, 38, 38, 38, 39, 39, 40, + 41, 41, 41, 42, 43, 43, 43, 43, 43, 43, + 43, 44, 44, 44, 44, 44, 44, 44, 45, 46, + 46, 47, 47, 48, 49, 49, 49, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 50, 50, 50, 50, 50, 50, 50, 50, 50 +}; + +static const short MiniXftConfigr2[] = { 0, + 2, 0, 2, 2, 2, 2, 4, 2, 0, 4, + 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 6, 1, + 1, 2, 0, 4, 1, 2, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 2, 5 +}; + +static const short MiniXftConfigdefact[] = { 2, + 0, 0, 0, 0, 0, 9, 1, 3, 4, 5, + 6, 11, 12, 0, 9, 0, 33, 8, 14, 0, + 0, 7, 33, 15, 16, 17, 18, 19, 20, 21, + 0, 35, 0, 0, 32, 22, 23, 24, 25, 26, + 27, 0, 10, 28, 37, 36, 38, 39, 40, 45, + 41, 42, 43, 0, 44, 0, 30, 31, 0, 58, + 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 46, 47, 48, 49, + 50, 51, 52, 53, 54, 55, 56, 57, 0, 0, + 0, 59, 29, 0, 0 +}; + +static const short MiniXftConfigdefgoto[] = { 1, + 7, 14, 15, 16, 21, 31, 43, 55, 59, 22, + 23, 34, 56 +}; + +static const short MiniXftConfigpact[] = {-32768, + 39, 32, 52, 94, 95, -1,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 15, -1, 79, 79,-32768,-32768, 80, + 8,-32768, 79,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 27, 69, 84, 18,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 24,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768, 18,-32768, 34,-32768,-32768, 24,-32768, +-32768, 18, 18, 18, 18, 18, 18, 18, 18, 18, + 18, 18, 18, 18, 24, 48, 87, 97, 105, 105, + -31, -31, -31, -31, 11, 11,-32768,-32768, 24, 18, + 82, 62,-32768, 104,-32768 +}; + +static const short MiniXftConfigpgoto[] = {-32768, +-32768, 90,-32768,-32768, 125,-32768,-32768, 111, -34, 120, +-32768,-32768, -54 +}; + + +#define YYLAST 143 + + +static const short MiniXftConfigtable[] = { 60, + 71, 72, 73, 74, -13, 12, 13, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 47, 48, 49, 50, 75, 32, 57, 58, 17, 36, + 37, 38, 51, 52, 53, 92, 8, 42, 94, 33, + 89, 39, 40, 41, 73, 74, 42, 2, 3, 4, + 5, 6, 61, 54, 91, 62, 9, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 62, + 90, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 62, 19, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 24, 10, 11, + 45, 46, 93, 95, 18, 25, 26, 27, 28, 29, + 30, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 67, 68, 69, 70, 71, 72, 73, 74, + 20, 44, 35 +}; + +static const short MiniXftConfigcheck[] = { 54, + 32, 33, 34, 35, 6, 7, 8, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 3, 4, 5, 6, 59, 18, 3, 4, 14, 3, + 4, 5, 15, 16, 17, 90, 5, 20, 0, 32, + 75, 15, 16, 17, 34, 35, 20, 9, 10, 11, + 12, 13, 19, 36, 89, 22, 5, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 22, 6, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 18, 5, 5, + 32, 18, 21, 0, 15, 26, 27, 28, 29, 30, + 31, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 28, 29, 30, 31, 32, 33, 34, 35, + 16, 31, 23 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/lib/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 +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define MiniXftConfigerrok (MiniXftConfigerrstatus = 0) +#define MiniXftConfigclearin (MiniXftConfigchar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto MiniXftConfigacceptlab +#define YYABORT goto MiniXftConfigabortlab +#define YYERROR goto MiniXftConfigerrlab1 +/* Like YYERROR except do call MiniXftConfigerror. + 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 MiniXftConfigerrlab +#define YYRECOVERING() (!!MiniXftConfigerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (MiniXftConfigchar == YYEMPTY && MiniXftConfiglen == 1) \ + { MiniXftConfigchar = (token), MiniXftConfiglval = (value); \ + MiniXftConfigchar1 = YYTRANSLATE (MiniXftConfigchar); \ + YYPOPSTACK; \ + goto MiniXftConfigbackup; \ + } \ + else \ + { MiniXftConfigerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX MiniXftConfiglex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, &MiniXftConfiglloc, YYLEX_PARAM) +#else +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, &MiniXftConfiglloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval, YYLEX_PARAM) +#else +#define YYLEX MiniXftConfiglex(&MiniXftConfiglval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int MiniXftConfigchar; /* the lookahead symbol */ +YYSTYPE MiniXftConfiglval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE MiniXftConfiglloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int MiniXftConfignerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int MiniXftConfigdebug; /* 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 __MiniXftConfig_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 __MiniXftConfig_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 +__MiniXftConfig_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__MiniXftConfig_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/lib/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into MiniXftConfigparse. 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 MiniXftConfigparse (void *); +#else +int MiniXftConfigparse (void); +#endif +#endif + +int +MiniXftConfigparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int MiniXftConfigstate; + register int MiniXftConfign; + register short *MiniXftConfigssp; + register YYSTYPE *MiniXftConfigvsp; + int MiniXftConfigerrstatus; /* number of tokens to shift before error messages enabled */ + int MiniXftConfigchar1 = 0; /* lookahead token as an internal (translated) token number */ + + short MiniXftConfigssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE MiniXftConfigvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *MiniXftConfigss = MiniXftConfigssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *MiniXftConfigvs = MiniXftConfigvsa; /* to allow MiniXftConfigoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE MiniXftConfiglsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *MiniXftConfigls = MiniXftConfiglsa; + YYLTYPE *MiniXftConfiglsp; + +#define YYPOPSTACK (MiniXftConfigvsp--, MiniXftConfigssp--, MiniXftConfiglsp--) +#else +#define YYPOPSTACK (MiniXftConfigvsp--, MiniXftConfigssp--) +#endif + + int MiniXftConfigstacksize = YYINITDEPTH; + int MiniXftConfigfree_stacks = 0; + +#ifdef YYPURE + int MiniXftConfigchar; + YYSTYPE MiniXftConfiglval; + int MiniXftConfignerrs; +#ifdef YYLSP_NEEDED + YYLTYPE MiniXftConfiglloc; +#endif +#endif + + YYSTYPE MiniXftConfigval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int MiniXftConfiglen; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Starting parse\n"); +#endif + + MiniXftConfigstate = 0; + MiniXftConfigerrstatus = 0; + MiniXftConfignerrs = 0; + MiniXftConfigchar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + MiniXftConfigssp = MiniXftConfigss - 1; + MiniXftConfigvsp = MiniXftConfigvs; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp = MiniXftConfigls; +#endif + +/* Push a new state, which is found in MiniXftConfigstate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +MiniXftConfignewstate: + + *++MiniXftConfigssp = MiniXftConfigstate; + + if (MiniXftConfigssp >= MiniXftConfigss + MiniXftConfigstacksize - 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 *MiniXftConfigvs1 = MiniXftConfigvs; + short *MiniXftConfigss1 = MiniXftConfigss; +#ifdef YYLSP_NEEDED + YYLTYPE *MiniXftConfigls1 = MiniXftConfigls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = MiniXftConfigssp - MiniXftConfigss + 1; + +#ifdef MiniXftConfigoverflow + /* 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 MiniXftConfigoverflow is a macro. */ + MiniXftConfigoverflow("parser stack overflow", + &MiniXftConfigss1, size * sizeof (*MiniXftConfigssp), + &MiniXftConfigvs1, size * sizeof (*MiniXftConfigvsp), + &MiniXftConfigls1, size * sizeof (*MiniXftConfiglsp), + &MiniXftConfigstacksize); +#else + MiniXftConfigoverflow("parser stack overflow", + &MiniXftConfigss1, size * sizeof (*MiniXftConfigssp), + &MiniXftConfigvs1, size * sizeof (*MiniXftConfigvsp), + &MiniXftConfigstacksize); +#endif + + MiniXftConfigss = MiniXftConfigss1; MiniXftConfigvs = MiniXftConfigvs1; +#ifdef YYLSP_NEEDED + MiniXftConfigls = MiniXftConfigls1; +#endif +#else /* no MiniXftConfigoverflow */ + /* Extend the stack our own way. */ + if (MiniXftConfigstacksize >= YYMAXDEPTH) + { + MiniXftConfigerror("parser stack overflow"); + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 2; + } + MiniXftConfigstacksize *= 2; + if (MiniXftConfigstacksize > YYMAXDEPTH) + MiniXftConfigstacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + MiniXftConfigfree_stacks = 1; +#endif + MiniXftConfigss = (short *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfigssp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigss, (char *)MiniXftConfigss1, + size * (unsigned int) sizeof (*MiniXftConfigssp)); + MiniXftConfigvs = (YYSTYPE *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfigvsp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigvs, (char *)MiniXftConfigvs1, + size * (unsigned int) sizeof (*MiniXftConfigvsp)); +#ifdef YYLSP_NEEDED + MiniXftConfigls = (YYLTYPE *) YYSTACK_ALLOC (MiniXftConfigstacksize * sizeof (*MiniXftConfiglsp)); + __MiniXftConfig_memcpy ((char *)MiniXftConfigls, (char *)MiniXftConfigls1, + size * (unsigned int) sizeof (*MiniXftConfiglsp)); +#endif +#endif /* no MiniXftConfigoverflow */ + + MiniXftConfigssp = MiniXftConfigss + size - 1; + MiniXftConfigvsp = MiniXftConfigvs + size - 1; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp = MiniXftConfigls + size - 1; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Stack size increased to %d\n", MiniXftConfigstacksize); +#endif + + if (MiniXftConfigssp >= MiniXftConfigss + MiniXftConfigstacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Entering state %d\n", MiniXftConfigstate); +#endif + + goto MiniXftConfigbackup; + MiniXftConfigbackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* MiniXftConfigresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigdefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* MiniXftConfigchar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (MiniXftConfigchar == YYEMPTY) + { +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Reading a token: "); +#endif + MiniXftConfigchar = YYLEX; + } + + /* Convert token to internal form (in MiniXftConfigchar1) for indexing tables with */ + + if (MiniXftConfigchar <= 0) /* This means end of input. */ + { + MiniXftConfigchar1 = 0; + MiniXftConfigchar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + MiniXftConfigchar1 = YYTRANSLATE(MiniXftConfigchar); + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + fprintf (stderr, "Next token is %d (%s", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, MiniXftConfigchar, MiniXftConfiglval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + MiniXftConfign += MiniXftConfigchar1; + if (MiniXftConfign < 0 || MiniXftConfign > YYLAST || MiniXftConfigcheck[MiniXftConfign] != MiniXftConfigchar1) + goto MiniXftConfigdefault; + + MiniXftConfign = MiniXftConfigtable[MiniXftConfign]; + + /* MiniXftConfign is what to do for this token type in this state. + Negative => reduce, -MiniXftConfign is rule number. + Positive => shift, MiniXftConfign is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (MiniXftConfign < 0) + { + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrlab; + MiniXftConfign = -MiniXftConfign; + goto MiniXftConfigreduce; + } + else if (MiniXftConfign == 0) + goto MiniXftConfigerrlab; + + if (MiniXftConfign == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Shifting token %d (%s), ", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (MiniXftConfigchar != YYEOF) + MiniXftConfigchar = YYEMPTY; + + *++MiniXftConfigvsp = MiniXftConfiglval; +#ifdef YYLSP_NEEDED + *++MiniXftConfiglsp = MiniXftConfiglloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (MiniXftConfigerrstatus) MiniXftConfigerrstatus--; + + MiniXftConfigstate = MiniXftConfign; + goto MiniXftConfignewstate; + +/* Do the default action for the current state. */ +MiniXftConfigdefault: + + MiniXftConfign = MiniXftConfigdefact[MiniXftConfigstate]; + if (MiniXftConfign == 0) + goto MiniXftConfigerrlab; + +/* Do a reduction. MiniXftConfign is the number of a rule to reduce with. */ +MiniXftConfigreduce: + MiniXftConfiglen = MiniXftConfigr2[MiniXftConfign]; + if (MiniXftConfiglen > 0) + MiniXftConfigval = MiniXftConfigvsp[1-MiniXftConfiglen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + MiniXftConfign, MiniXftConfigrline[MiniXftConfign]); + + /* Print the symbols being reduced, and their result. */ + for (i = MiniXftConfigprhs[MiniXftConfign]; MiniXftConfigrhs[i] > 0; i++) + fprintf (stderr, "%s ", MiniXftConfigtname[MiniXftConfigrhs[i]]); + fprintf (stderr, " -> %s\n", MiniXftConfigtname[MiniXftConfigr1[MiniXftConfign]]); + } +#endif + + + switch (MiniXftConfign) { + +case 3: +#line 81 "minixftgram.y" +{ MiniXftConfigAddDir (MiniXftConfigvsp[0].sval); ; + break;} +case 4: +#line 83 "minixftgram.y" +{ MiniXftConfigSetCache (MiniXftConfigvsp[0].sval); ; + break;} +case 5: +#line 85 "minixftgram.y" +{ MiniXftConfigPushInput (MiniXftConfigvsp[0].sval, True); ; + break;} +case 6: +#line 87 "minixftgram.y" +{ MiniXftConfigPushInput (MiniXftConfigvsp[0].sval, False); ; + break;} +case 7: +#line 89 "minixftgram.y" +{ MiniXftConfigAddEdit (MiniXftConfigvsp[-2].tval, MiniXftConfigvsp[0].Eval); ; + break;} +case 8: +#line 92 "minixftgram.y" +{ MiniXftConfigvsp[-1].tval->next = MiniXftConfigvsp[0].tval; MiniXftConfigval.tval = MiniXftConfigvsp[-1].tval; ; + break;} +case 9: +#line 94 "minixftgram.y" +{ MiniXftConfigval.tval = 0; ; + break;} +case 10: +#line 97 "minixftgram.y" +{ MiniXftConfigval.tval = MiniXftTestCreate (MiniXftConfigvsp[-3].qval, MiniXftConfigvsp[-2].sval, MiniXftConfigvsp[-1].oval, MiniXftConfigvsp[0].vval); ; + break;} +case 11: +#line 100 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAny; ; + break;} +case 12: +#line 102 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAll; ; + break;} +case 13: +#line 104 "minixftgram.y" +{ MiniXftConfigval.qval = MiniXftQualAny; ; + break;} +case 14: +#line 107 "minixftgram.y" +{ + MiniXftConfigval.sval = MiniXftConfigSaveField (MiniXftConfigvsp[0].sval); + ; + break;} +case 15: +#line 112 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpEqual; ; + break;} +case 16: +#line 114 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpEqual; ; + break;} +case 17: +#line 116 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpNotEqual; ; + break;} +case 18: +#line 118 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpLess; ; + break;} +case 19: +#line 120 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpLessEqual; ; + break;} +case 20: +#line 122 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpMore; ; + break;} +case 21: +#line 124 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpMoreEqual; ; + break;} +case 22: +#line 127 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeInteger; + MiniXftConfigval.vval.u.i = MiniXftConfigvsp[0].ival; + ; + break;} +case 23: +#line 132 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeDouble; + MiniXftConfigval.vval.u.d = MiniXftConfigvsp[0].dval; + ; + break;} +case 24: +#line 137 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeString; + MiniXftConfigval.vval.u.s = MiniXftConfigvsp[0].sval; + ; + break;} +case 25: +#line 142 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeBool; + MiniXftConfigval.vval.u.b = True; + ; + break;} +case 26: +#line 147 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeBool; + MiniXftConfigval.vval.u.b = False; + ; + break;} +case 27: +#line 152 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeVoid; + ; + break;} +case 28: +#line 156 "minixftgram.y" +{ + MiniXftConfigval.vval.type = MiniXftTypeMatrix; + MiniXftConfigval.vval.u.m = &matrix; + ; + break;} +case 29: +#line 162 "minixftgram.y" +{ + matrix.xx = MiniXftConfigvsp[-4].dval; + matrix.xy = MiniXftConfigvsp[-3].dval; + matrix.yx = MiniXftConfigvsp[-2].dval; + matrix.yy = MiniXftConfigvsp[-1].dval; + ; + break;} +case 30: +#line 169 "minixftgram.y" +{ MiniXftConfigval.dval = (double) MiniXftConfigvsp[0].ival; ; + break;} +case 32: +#line 173 "minixftgram.y" +{ MiniXftConfigvsp[-1].Eval->next = MiniXftConfigvsp[0].Eval; MiniXftConfigval.Eval = MiniXftConfigvsp[-1].Eval; ; + break;} +case 33: +#line 175 "minixftgram.y" +{ MiniXftConfigval.Eval = 0; ; + break;} +case 34: +#line 178 "minixftgram.y" +{ MiniXftConfigval.Eval = MiniXftEditCreate (MiniXftConfigvsp[-3].sval, MiniXftConfigvsp[-2].oval, MiniXftConfigvsp[-1].eval); ; + break;} +case 35: +#line 181 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpAssign; ; + break;} +case 36: +#line 183 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpPrepend; ; + break;} +case 37: +#line 185 "minixftgram.y" +{ MiniXftConfigval.oval = MiniXftOpAppend; ; + break;} +case 38: +#line 188 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateInteger (MiniXftConfigvsp[0].ival); ; + break;} +case 39: +#line 190 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateDouble (MiniXftConfigvsp[0].dval); ; + break;} +case 40: +#line 192 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateString (MiniXftConfigvsp[0].sval); ; + break;} +case 41: +#line 194 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateBool (True); ; + break;} +case 42: +#line 196 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateBool (False); ; + break;} +case 43: +#line 198 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateNil (); ; + break;} +case 44: +#line 200 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateMatrix (&matrix); ; + break;} +case 45: +#line 202 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateField (MiniXftConfigvsp[0].sval); ; + break;} +case 46: +#line 204 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpOr, MiniXftConfigvsp[0].eval); ; + break;} +case 47: +#line 206 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpAnd, MiniXftConfigvsp[0].eval); ; + break;} +case 48: +#line 208 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 49: +#line 210 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpNotEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 50: +#line 212 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpLess, MiniXftConfigvsp[0].eval); ; + break;} +case 51: +#line 214 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpLessEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 52: +#line 216 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMore, MiniXftConfigvsp[0].eval); ; + break;} +case 53: +#line 218 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMoreEqual, MiniXftConfigvsp[0].eval); ; + break;} +case 54: +#line 220 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpPlus, MiniXftConfigvsp[0].eval); ; + break;} +case 55: +#line 222 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpMinus, MiniXftConfigvsp[0].eval); ; + break;} +case 56: +#line 224 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpTimes, MiniXftConfigvsp[0].eval); ; + break;} +case 57: +#line 226 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpDivide, MiniXftConfigvsp[0].eval); ; + break;} +case 58: +#line 228 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[0].eval, MiniXftOpNot, (MiniXftExpr *) 0); ; + break;} +case 59: +#line 230 "minixftgram.y" +{ MiniXftConfigval.eval = MiniXftExprCreateOp (MiniXftConfigvsp[-4].eval, MiniXftOpQuest, MiniXftExprCreateOp (MiniXftConfigvsp[-2].eval, MiniXftOpQuest, MiniXftConfigvsp[0].eval)); ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/lib/bison.simple" + + MiniXftConfigvsp -= MiniXftConfiglen; + MiniXftConfigssp -= MiniXftConfiglen; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp -= MiniXftConfiglen; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + short *ssp1 = MiniXftConfigss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != MiniXftConfigssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++MiniXftConfigvsp = MiniXftConfigval; + +#ifdef YYLSP_NEEDED + MiniXftConfiglsp++; + if (MiniXftConfiglen == 0) + { + MiniXftConfiglsp->first_line = MiniXftConfiglloc.first_line; + MiniXftConfiglsp->first_column = MiniXftConfiglloc.first_column; + MiniXftConfiglsp->last_line = (MiniXftConfiglsp-1)->last_line; + MiniXftConfiglsp->last_column = (MiniXftConfiglsp-1)->last_column; + MiniXftConfiglsp->text = 0; + } + else + { + MiniXftConfiglsp->last_line = (MiniXftConfiglsp+MiniXftConfiglen-1)->last_line; + MiniXftConfiglsp->last_column = (MiniXftConfiglsp+MiniXftConfiglen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + MiniXftConfign = MiniXftConfigr1[MiniXftConfign]; + + MiniXftConfigstate = MiniXftConfigpgoto[MiniXftConfign - YYNTBASE] + *MiniXftConfigssp; + if (MiniXftConfigstate >= 0 && MiniXftConfigstate <= YYLAST && MiniXftConfigcheck[MiniXftConfigstate] == *MiniXftConfigssp) + MiniXftConfigstate = MiniXftConfigtable[MiniXftConfigstate]; + else + MiniXftConfigstate = MiniXftConfigdefgoto[MiniXftConfign - YYNTBASE]; + + goto MiniXftConfignewstate; + +MiniXftConfigerrlab: /* here on detecting error */ + + if (! MiniXftConfigerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++MiniXftConfignerrs; + +#ifdef YYERROR_VERBOSE + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + + if (MiniXftConfign > YYFLAG && MiniXftConfign < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -MiniXftConfign if nec to avoid negative indexes in MiniXftConfigcheck. */ + for (x = (MiniXftConfign < 0 ? -MiniXftConfign : 0); + x < (sizeof(MiniXftConfigtname) / sizeof(char *)); x++) + if (MiniXftConfigcheck[x + MiniXftConfign] == x) + size += strlen(MiniXftConfigtname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (MiniXftConfign < 0 ? -MiniXftConfign : 0); + x < (sizeof(MiniXftConfigtname) / sizeof(char *)); x++) + if (MiniXftConfigcheck[x + MiniXftConfign] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, MiniXftConfigtname[x]); + strcat(msg, "'"); + count++; + } + } + MiniXftConfigerror(msg); + free(msg); + } + else + MiniXftConfigerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + MiniXftConfigerror("parse error"); + } + + goto MiniXftConfigerrlab1; +MiniXftConfigerrlab1: /* here on error raised explicitly by an action */ + + if (MiniXftConfigerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (MiniXftConfigchar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Discarding token %d (%s).\n", MiniXftConfigchar, MiniXftConfigtname[MiniXftConfigchar1]); +#endif + + MiniXftConfigchar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + MiniXftConfigerrstatus = 3; /* Each real token shifted decrements this */ + + goto MiniXftConfigerrhandle; + +MiniXftConfigerrdefault: /* 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. */ + MiniXftConfign = MiniXftConfigdefact[MiniXftConfigstate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (MiniXftConfign) goto MiniXftConfigdefault; +#endif + +MiniXftConfigerrpop: /* pop the current state because it cannot handle the error token */ + + if (MiniXftConfigssp == MiniXftConfigss) YYABORT; + MiniXftConfigvsp--; + MiniXftConfigstate = *--MiniXftConfigssp; +#ifdef YYLSP_NEEDED + MiniXftConfiglsp--; +#endif + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + { + short *ssp1 = MiniXftConfigss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != MiniXftConfigssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +MiniXftConfigerrhandle: + + MiniXftConfign = MiniXftConfigpact[MiniXftConfigstate]; + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrdefault; + + MiniXftConfign += YYTERROR; + if (MiniXftConfign < 0 || MiniXftConfign > YYLAST || MiniXftConfigcheck[MiniXftConfign] != YYTERROR) + goto MiniXftConfigerrdefault; + + MiniXftConfign = MiniXftConfigtable[MiniXftConfign]; + if (MiniXftConfign < 0) + { + if (MiniXftConfign == YYFLAG) + goto MiniXftConfigerrpop; + MiniXftConfign = -MiniXftConfign; + goto MiniXftConfigreduce; + } + else if (MiniXftConfign == 0) + goto MiniXftConfigerrpop; + + if (MiniXftConfign == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (MiniXftConfigdebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++MiniXftConfigvsp = MiniXftConfiglval; +#ifdef YYLSP_NEEDED + *++MiniXftConfiglsp = MiniXftConfiglloc; +#endif + + MiniXftConfigstate = MiniXftConfign; + goto MiniXftConfignewstate; + + MiniXftConfigacceptlab: + /* YYACCEPT comes here. */ + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 0; + + MiniXftConfigabortlab: + /* YYABORT comes here. */ + if (MiniXftConfigfree_stacks) + { + free (MiniXftConfigss); + free (MiniXftConfigvs); +#ifdef YYLSP_NEEDED + free (MiniXftConfigls); +#endif + } + return 1; +} +#line 232 "minixftgram.y" + + +int +MiniXftConfigwrap (void) +{ + return 1; +} + +void +MiniXftConfigerror (char *fmt, ...) +{ + va_list args; + + fprintf (stderr, "\"%s\": line %d, ", MiniXftConfigFile, MiniXftConfigLineno); + va_start (args, fmt); + vfprintf (stderr, fmt, args); + va_end (args); + fprintf (stderr, "\n"); +} + +MiniXftTest * +MiniXftTestCreate (MiniXftQual qual, const char *field, MiniXftOp compare, MiniXftValue value) +{ + MiniXftTest *test = (MiniXftTest *) malloc (sizeof (MiniXftTest));; + + if (test) + { + test->next = 0; + test->qual = qual; + test->field = field; /* already saved in grammar */ + test->op = compare; + if (value.type == MiniXftTypeString) + value.u.s = _MiniXftSaveString (value.u.s); + else if (value.type == MiniXftTypeMatrix) + value.u.m = _MiniXftSaveMatrix (value.u.m); + test->value = value; + } + return test; +} + +MiniXftExpr * +MiniXftExprCreateInteger (int i) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpInteger; + e->u.ival = i; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateDouble (double d) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpDouble; + e->u.dval = d; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateString (const char *s) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpString; + e->u.sval = _MiniXftSaveString (s); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateMatrix (const MiniXftMatrix *m) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpMatrix; + e->u.mval = _MiniXftSaveMatrix (m); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateBool (Bool b) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpBool; + e->u.bval = b; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateNil (void) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpNil; + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateField (const char *field) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = MiniXftOpField; + e->u.field = _MiniXftSaveString (field); + } + return e; +} + +MiniXftExpr * +MiniXftExprCreateOp (MiniXftExpr *left, MiniXftOp op, MiniXftExpr *right) +{ + MiniXftExpr *e = (MiniXftExpr *) malloc (sizeof (MiniXftExpr)); + + if (e) + { + e->op = op; + e->u.tree.left = left; + e->u.tree.right = right; + } + return e; +} + +void +MiniXftExprDestroy (MiniXftExpr *e) +{ + switch (e->op) { + case MiniXftOpInteger: + break; + case MiniXftOpDouble: + break; + case MiniXftOpString: + free (e->u.sval); + break; + case MiniXftOpMatrix: + free (e->u.mval); + break; + case MiniXftOpBool: + break; + case MiniXftOpField: + free (e->u.field); + break; + case MiniXftOpAssign: + case MiniXftOpPrepend: + case MiniXftOpAppend: + break; + case MiniXftOpOr: + case MiniXftOpAnd: + case MiniXftOpEqual: + case MiniXftOpNotEqual: + case MiniXftOpLess: + case MiniXftOpLessEqual: + case MiniXftOpMore: + case MiniXftOpMoreEqual: + case MiniXftOpPlus: + case MiniXftOpMinus: + case MiniXftOpTimes: + case MiniXftOpDivide: + case MiniXftOpQuest: + MiniXftExprDestroy (e->u.tree.right); + /* fall through */ + case MiniXftOpNot: + MiniXftExprDestroy (e->u.tree.left); + break; + case MiniXftOpNil: + break; + } + free (e); +} + +MiniXftEdit * +MiniXftEditCreate (const char *field, MiniXftOp op, MiniXftExpr *expr) +{ + MiniXftEdit *e = (MiniXftEdit *) malloc (sizeof (MiniXftEdit)); + + if (e) + { + e->next = 0; + e->field = field; /* already saved in grammar */ + e->op = op; + e->expr = expr; + } + return e; +} + +void +MiniXftEditDestroy (MiniXftEdit *e) +{ + if (e->next) + MiniXftEditDestroy (e->next); + free ((void *) e->field); + if (e->expr) + MiniXftExprDestroy (e->expr); +} + +char * +MiniXftConfigSaveField (const char *field) +{ + return _MiniXftSaveString (field); +} |