Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/RenderSystems/GL/src/nvparse/_rc1.0_parser.cpp @ 3

Last change on this file since 3 was 3, checked in by anonymous, 17 years ago

=update
File size: 68.7 KB
Line 
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2006 Torus Knot Software Ltd
8Also see acknowledgements in Readme.html
9
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://www.gnu.org/copyleft/lesser.txt.
23
24You may alternatively use this source under the terms of a specific version of
25the OGRE Unrestricted License provided you have obtained such a license from
26Torus Knot Software Ltd.
27-----------------------------------------------------------------------------
28*/
29/* A Bison parser, made by GNU Bison 1.875.  */
30
31/* Skeleton parser for Yacc-like parsing with Bison,
32   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
33
34   This program is free software; you can redistribute it and/or modify
35   it under the terms of the GNU General Public License as published by
36   the Free Software Foundation; either version 2, or (at your option)
37   any later version.
38
39   This program is distributed in the hope that it will be useful,
40   but WITHOUT ANY WARRANTY; without even the implied warranty of
41   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
42   GNU General Public License for more details.
43
44   You should have received a copy of the GNU General Public License
45   along with this program; if not, write to the Free Software
46   Foundation, Inc., 59 Temple Place - Suite 330,
47   Boston, MA 02111-1307, USA.  */
48
49/* As a special exception, when this file is copied by Bison into a
50   Bison output file, you may use that output file without restriction.
51   This special exception was added by the Free Software Foundation
52   in version 1.24 of Bison.  */
53
54/* Written by Richard Stallman by simplifying the original so called
55   ``semantic'' parser.  */
56
57/* All symbols defined below should begin with yy or YY, to avoid
58   infringing on user name space.  This should be done even for local
59   variables, as they might otherwise be expanded by user macros.
60   There are some unavoidable exceptions within include files to
61   define necessary library symbols; they are noted "INFRINGES ON
62   USER NAME SPACE" below.  */
63
64/* Identify Bison output.  */
65#define YYBISON 1
66
67/* Skeleton name.  */
68#define YYSKELETON_NAME "yacc.c"
69
70/* Pure parsers.  */
71#define YYPURE 0
72
73/* Using locations.  */
74#define YYLSP_NEEDED 0
75
76/* If NAME_PREFIX is specified substitute the variables and functions
77   names.  */
78#define yyparse rc10_parse
79#define yylex   rc10_lex
80#define yyerror rc10_error
81#define yylval  rc10_lval
82#define yychar  rc10_char
83#define yydebug rc10_debug
84#define yynerrs rc10_nerrs
85
86
87/* Tokens.  */
88#ifndef YYTOKENTYPE
89# define YYTOKENTYPE
90   /* Put the tokens into the symbol table, so that GDB and other debuggers
91      know about them.  */
92   enum yytokentype {
93     regVariable = 258,
94     constVariable = 259,
95     color_sum = 260,
96     final_product = 261,
97     expandString = 262,
98     halfBiasString = 263,
99     unsignedString = 264,
100     unsignedInvertString = 265,
101     muxString = 266,
102     sumString = 267,
103     rgb_portion = 268,
104     alpha_portion = 269,
105     openParen = 270,
106     closeParen = 271,
107     openBracket = 272,
108     closeBracket = 273,
109     semicolon = 274,
110     comma = 275,
111     dot = 276,
112     times = 277,
113     minus = 278,
114     equals = 279,
115     plus = 280,
116     bias_by_negative_one_half_scale_by_two = 281,
117     bias_by_negative_one_half = 282,
118     scale_by_one_half = 283,
119     scale_by_two = 284,
120     scale_by_four = 285,
121     clamp_color_sum = 286,
122     lerp = 287,
123     fragment_rgb = 288,
124     fragment_alpha = 289,
125     floatValue = 290
126   };
127#endif
128#define regVariable 258
129#define constVariable 259
130#define color_sum 260
131#define final_product 261
132#define expandString 262
133#define halfBiasString 263
134#define unsignedString 264
135#define unsignedInvertString 265
136#define muxString 266
137#define sumString 267
138#define rgb_portion 268
139#define alpha_portion 269
140#define openParen 270
141#define closeParen 271
142#define openBracket 272
143#define closeBracket 273
144#define semicolon 274
145#define comma 275
146#define dot 276
147#define times 277
148#define minus 278
149#define equals 279
150#define plus 280
151#define bias_by_negative_one_half_scale_by_two 281
152#define bias_by_negative_one_half 282
153#define scale_by_one_half 283
154#define scale_by_two 284
155#define scale_by_four 285
156#define clamp_color_sum 286
157#define lerp 287
158#define fragment_rgb 288
159#define fragment_alpha 289
160#define floatValue 290
161
162
163
164
165/* Copy the first part of user declarations.  */
166#line 3 "rc1.0_grammar.y"
167
168void yyerror(char* s);
169int yylex ( void );
170
171#ifdef _WIN32
172# include <windows.h>
173#endif
174
175#include <stdio.h>
176#include <stdlib.h>
177
178#include "rc1.0_combiners.h"
179#include "nvparse_errors.h"
180#include "nvparse_externs.h"
181
182
183
184
185/* Enabling traces.  */
186#ifndef YYDEBUG
187# define YYDEBUG 0
188#endif
189
190/* Enabling verbose error messages.  */
191#ifdef YYERROR_VERBOSE
192# undef YYERROR_VERBOSE
193# define YYERROR_VERBOSE 1
194#else
195# define YYERROR_VERBOSE 0
196#endif
197
198#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
199#line 20 "rc1.0_grammar.y"
200typedef union YYSTYPE {
201  int ival;
202  float fval;
203  RegisterEnum registerEnum;
204  BiasScaleEnum biasScaleEnum;
205  MappedRegisterStruct mappedRegisterStruct;
206  ConstColorStruct constColorStruct;
207  GeneralPortionStruct generalPortionStruct;
208  GeneralFunctionStruct generalFunctionStruct;
209  OpStruct opStruct;
210  GeneralCombinerStruct generalCombinerStruct;
211  GeneralCombinersStruct generalCombinersStruct;
212  FinalProductStruct finalProductStruct;
213  FinalRgbFunctionStruct finalRgbFunctionStruct;
214  FinalAlphaFunctionStruct finalAlphaFunctionStruct;
215  FinalCombinerStruct finalCombinerStruct;
216  CombinersStruct combinersStruct;
217} YYSTYPE;
218/* Line 191 of yacc.c.  */
219#line 191 "_rc1.0_parser.c"
220# define yystype YYSTYPE /* obsolescent; will be withdrawn */
221# define YYSTYPE_IS_DECLARED 1
222# define YYSTYPE_IS_TRIVIAL 1
223#endif
224
225
226
227/* Copy the second part of user declarations.  */
228
229
230/* Line 214 of yacc.c.  */
231#line 203 "_rc1.0_parser.c"
232
233#if ! defined (yyoverflow) || YYERROR_VERBOSE
234
235/* The parser invokes alloca or malloc; define the necessary symbols.  */
236
237# if YYSTACK_USE_ALLOCA
238#  define YYSTACK_ALLOC alloca
239# else
240#  ifndef YYSTACK_USE_ALLOCA
241#   if defined (alloca) || defined (_ALLOCA_H)
242#    define YYSTACK_ALLOC alloca
243#   else
244#    ifdef __GNUC__
245#     define YYSTACK_ALLOC __builtin_alloca
246#    endif
247#   endif
248#  endif
249# endif
250
251# ifdef YYSTACK_ALLOC
252   /* Pacify GCC's `empty if-body' warning. */
253#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
254# else
255#  if defined (__STDC__) || defined (__cplusplus)
256#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
257#   define YYSIZE_T size_t
258#  endif
259#  define YYSTACK_ALLOC malloc
260#  define YYSTACK_FREE free
261# endif
262#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
263
264
265#if (! defined (yyoverflow) \
266     && (! defined (__cplusplus) \
267         || (YYSTYPE_IS_TRIVIAL)))
268
269/* A type that is properly aligned for any stack member.  */
270union yyalloc
271{
272  short yyss;
273  YYSTYPE yyvs;
274  };
275
276/* The size of the maximum gap between one aligned stack and the next.  */
277# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
278
279/* The size of an array large to enough to hold all stacks, each with
280   N elements.  */
281# define YYSTACK_BYTES(N) \
282     ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
283      + YYSTACK_GAP_MAXIMUM)
284
285/* Copy COUNT objects from FROM to TO.  The source and destination do
286   not overlap.  */
287# ifndef YYCOPY
288#  if 1 < __GNUC__
289#   define YYCOPY(To, From, Count) \
290      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
291#  else
292#   define YYCOPY(To, From, Count)              \
293      do                                        \
294        {                                       \
295          register YYSIZE_T yyi;                \
296          for (yyi = 0; yyi < (Count); yyi++)   \
297            (To)[yyi] = (From)[yyi];            \
298        }                                       \
299      while (0)
300#  endif
301# endif
302
303/* Relocate STACK from its old location to the new one.  The
304   local variables YYSIZE and YYSTACKSIZE give the old and new number of
305   elements in the stack, and YYPTR gives the new location of the
306   stack.  Advance YYPTR to a properly aligned location for the next
307   stack.  */
308# define YYSTACK_RELOCATE(Stack)                                        \
309    do                                                                  \
310      {                                                                 \
311        YYSIZE_T yynewbytes;                                            \
312        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
313        Stack = &yyptr->Stack;                                          \
314        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
315        yyptr += yynewbytes / sizeof (*yyptr);                          \
316      }                                                                 \
317    while (0)
318
319#endif
320
321#if defined (__STDC__) || defined (__cplusplus)
322   typedef signed char yysigned_char;
323#else
324   typedef short yysigned_char;
325#endif
326
327/* YYFINAL -- State number of the termination state. */
328#define YYFINAL  27
329/* YYLAST -- Last index in YYTABLE.  */
330#define YYLAST   258
331
332/* YYNTOKENS -- Number of terminals. */
333#define YYNTOKENS  36
334/* YYNNTS -- Number of nonterminals. */
335#define YYNNTS  22
336/* YYNRULES -- Number of rules. */
337#define YYNRULES  88
338/* YYNRULES -- Number of states. */
339#define YYNSTATES  220
340
341/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
342#define YYUNDEFTOK  2
343#define YYMAXUTOK   290
344
345#define YYTRANSLATE(YYX)                                                \
346  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
347
348/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
349static const unsigned char yytranslate[] =
350{
351       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
352       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
353       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
354       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
355       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
356       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
357       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
358       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
359       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
360       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
361       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
362       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
363       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
364       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
365       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
366       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
367       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
368       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
369       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
370       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
371       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
372       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
373       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
374       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
375       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
376       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
377       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
378      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
379      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
380      35
381};
382
383#if YYDEBUG
384/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
385   YYRHS.  */
386static const unsigned short yyprhs[] =
387{
388       0,     0,     3,     5,     9,    14,    17,    20,    24,    26,
389      39,    42,    44,    49,    55,    62,    66,    71,    77,    83,
390      88,    90,    92,    94,    97,   102,   108,   113,   119,   124,
391     129,   132,   135,   138,   140,   143,   147,   151,   153,   160,
392     167,   172,   179,   186,   191,   196,   201,   206,   211,   213,
393     218,   223,   225,   230,   235,   237,   242,   247,   250,   254,
394     258,   263,   268,   271,   275,   279,   284,   289,   291,   294,
395     297,   301,   305,   307,   310,   313,   317,   321,   326,   333,
396     347,   361,   373,   380,   389,   394,   401,   406,   408
397};
398
399/* YYRHS -- A `-1'-separated list of the rules' RHS. */
400static const yysigned_char yyrhs[] =
401{
402      37,     0,    -1,    38,    -1,    39,    40,    52,    -1,    39,
403      39,    40,    52,    -1,    40,    52,    -1,    39,    52,    -1,
404      39,    39,    52,    -1,    52,    -1,     4,    24,    15,    35,
405      20,    35,    20,    35,    20,    35,    16,    19,    -1,    40,
406      41,    -1,    41,    -1,    17,    42,    42,    18,    -1,    17,
407      39,    42,    42,    18,    -1,    17,    39,    39,    42,    42,
408      18,    -1,    17,    42,    18,    -1,    17,    39,    42,    18,
409      -1,    17,    39,    39,    42,    18,    -1,    43,    17,    45,
410      50,    18,    -1,    43,    17,    45,    18,    -1,    13,    -1,
411      14,    -1,    57,    -1,    23,    57,    -1,     7,    15,    57,
412      16,    -1,    23,     7,    15,    57,    16,    -1,     8,    15,
413      57,    16,    -1,    23,     8,    15,    57,    16,    -1,     9,
414      15,    57,    16,    -1,    10,    15,    57,    16,    -1,    46,
415      46,    -1,    46,    47,    -1,    47,    46,    -1,    46,    -1,
416      47,    47,    -1,    47,    47,    48,    -1,    47,    47,    49,
417      -1,    47,    -1,    57,    24,    44,    21,    44,    19,    -1,
418      57,    24,    44,    22,    44,    19,    -1,    57,    24,    44,
419      19,    -1,    57,    24,    11,    15,    16,    19,    -1,    57,
420      24,    12,    15,    16,    19,    -1,    26,    15,    16,    19,
421      -1,    27,    15,    16,    19,    -1,    28,    15,    16,    19,
422      -1,    29,    15,    16,    19,    -1,    30,    15,    16,    19,
423      -1,    57,    -1,     9,    15,    57,    16,    -1,    10,    15,
424      57,    16,    -1,     5,    -1,     9,    15,     5,    16,    -1,
425      10,    15,     5,    16,    -1,     6,    -1,     9,    15,     6,
426      16,    -1,    10,    15,     6,    16,    -1,    56,    55,    -1,
427      53,    56,    55,    -1,    54,    56,    55,    -1,    53,    54,
428      56,    55,    -1,    54,    53,    56,    55,    -1,    55,    56,
429      -1,    53,    55,    56,    -1,    54,    55,    56,    -1,    53,
430      54,    55,    56,    -1,    54,    53,    55,    56,    -1,    55,
431      -1,    53,    55,    -1,    54,    55,    -1,    53,    54,    55,
432      -1,    54,    53,    55,    -1,    56,    -1,    53,    56,    -1,
433      54,    56,    -1,    53,    54,    56,    -1,    54,    53,    56,
434      -1,    31,    15,    16,    19,    -1,     6,    24,    51,    22,
435      51,    19,    -1,    33,    24,    32,    15,    51,    20,    51,
436      20,    51,    16,    25,    51,    19,    -1,    33,    24,    51,
437      25,    32,    15,    51,    20,    51,    20,    51,    16,    19,
438      -1,    33,    24,    32,    15,    51,    20,    51,    20,    51,
439      16,    19,    -1,    33,    24,    51,    22,    51,    19,    -1,
440      33,    24,    51,    22,    51,    25,    51,    19,    -1,    33,
441      24,    51,    19,    -1,    33,    24,    51,    25,    51,    19,
442      -1,    34,    24,    51,    19,    -1,     4,    -1,     3,    -1
443};
444
445/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
446static const unsigned short yyrline[] =
447{
448       0,    73,    73,    80,    86,    92,    98,   106,   114,   124,
449     133,   138,   146,   152,   158,   164,   170,   176,   184,   190,
450     200,   204,   210,   216,   222,   228,   234,   240,   246,   252,
451     260,   266,   272,   278,   284,   290,   296,   302,   310,   318,
452     324,   336,   344,   352,   356,   360,   364,   368,   374,   380,
453     386,   392,   398,   404,   410,   416,   422,   430,   436,   442,
454     448,   454,   461,   467,   473,   479,   485,   492,   500,   508,
455     516,   524,   533,   541,   549,   557,   565,   575,   581,   589,
456     595,   601,   611,   623,   633,   647,   661,   669,   673
457};
458#endif
459
460#if YYDEBUG || YYERROR_VERBOSE
461/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
462   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
463static const char *const yytname[] =
464{
465  "$end", "error", "$undefined", "regVariable", "constVariable", 
466  "color_sum", "final_product", "expandString", "halfBiasString", 
467  "unsignedString", "unsignedInvertString", "muxString", "sumString", 
468  "rgb_portion", "alpha_portion", "openParen", "closeParen", 
469  "openBracket", "closeBracket", "semicolon", "comma", "dot", "times", 
470  "minus", "equals", "plus", "bias_by_negative_one_half_scale_by_two", 
471  "bias_by_negative_one_half", "scale_by_one_half", "scale_by_two", 
472  "scale_by_four", "clamp_color_sum", "lerp", "fragment_rgb", 
473  "fragment_alpha", "floatValue", "$accept", "WholeEnchilada", 
474  "Combiners", "ConstColor", "GeneralCombiners", "GeneralCombiner", 
475  "GeneralPortion", "PortionDesignator", "GeneralMappedRegister", 
476  "GeneralFunction", "Dot", "Mul", "Mux", "Sum", "BiasScale", 
477  "FinalMappedRegister", "FinalCombiner", "ClampColorSum", "FinalProduct", 
478  "FinalRgbFunction", "FinalAlphaFunction", "Register", 0
479};
480#endif
481
482# ifdef YYPRINT
483/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
484   token YYLEX-NUM.  */
485static const unsigned short yytoknum[] =
486{
487       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
488     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
489     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
490     285,   286,   287,   288,   289,   290
491};
492# endif
493
494/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
495static const unsigned char yyr1[] =
496{
497       0,    36,    37,    38,    38,    38,    38,    38,    38,    39,
498      40,    40,    41,    41,    41,    41,    41,    41,    42,    42,
499      43,    43,    44,    44,    44,    44,    44,    44,    44,    44,
500      45,    45,    45,    45,    45,    45,    45,    45,    46,    47,
501      47,    48,    49,    50,    50,    50,    50,    50,    51,    51,
502      51,    51,    51,    51,    51,    51,    51,    52,    52,    52,
503      52,    52,    52,    52,    52,    52,    52,    52,    52,    52,
504      52,    52,    52,    52,    52,    52,    52,    53,    54,    55,
505      55,    55,    55,    55,    55,    55,    56,    57,    57
506};
507
508/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
509static const unsigned char yyr2[] =
510{
511       0,     2,     1,     3,     4,     2,     2,     3,     1,    12,
512       2,     1,     4,     5,     6,     3,     4,     5,     5,     4,
513       1,     1,     1,     2,     4,     5,     4,     5,     4,     4,
514       2,     2,     2,     1,     2,     3,     3,     1,     6,     6,
515       4,     6,     6,     4,     4,     4,     4,     4,     1,     4,
516       4,     1,     4,     4,     1,     4,     4,     2,     3,     3,
517       4,     4,     2,     3,     3,     4,     4,     1,     2,     2,
518       3,     3,     1,     2,     2,     3,     3,     4,     6,    13,
519      13,    11,     6,     8,     4,     6,     4,     1,     1
520};
521
522/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
523   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
524   means the default is an error.  */
525static const unsigned char yydefact[] =
526{
527       0,     0,     0,     0,     0,     0,     0,     0,     2,     0,
528       0,    11,     8,     0,     0,    67,    72,     0,     0,    20,
529      21,     0,     0,     0,     0,     0,     0,     1,     0,     0,
530       6,    10,     5,     0,    68,    73,     0,    69,    74,    62,
531      57,     0,    88,    87,    51,    54,     0,     0,     0,    48,
532       0,     0,    15,     0,     0,     0,     0,     0,     0,     0,
533       7,     3,    70,    75,    63,    58,    71,    76,    64,    59,
534       0,     0,     0,     0,     0,    16,     0,    12,     0,    33,
535      37,     0,    77,     0,    84,     0,     0,    86,     4,    65,
536      60,    66,    61,     0,     0,     0,     0,     0,     0,     0,
537       0,    17,     0,    13,    19,     0,     0,     0,     0,     0,
538       0,    30,    31,    32,    34,     0,     0,     0,     0,     0,
539       0,    52,    55,    49,    53,    56,    50,    78,    14,     0,
540       0,     0,     0,     0,    18,    35,    36,     0,     0,     0,
541       0,     0,     0,     0,    22,     0,    82,     0,     0,    85,
542       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
543       0,     0,     0,    23,    40,     0,     0,     0,     0,     0,
544       0,    43,    44,    45,    46,    47,     0,     0,     0,     0,
545       0,     0,     0,     0,     0,     0,     0,    83,     0,     0,
546       0,     0,    24,    26,    28,    29,     0,     0,    38,    39,
547       0,     0,     0,     0,     0,    25,    27,     0,     0,     0,
548      41,    42,    81,     0,     0,     9,     0,     0,    79,    80
549};
550
551/* YYDEFGOTO[NTERM-NUM]. */
552static const short yydefgoto[] =
553{
554      -1,     7,     8,     9,    10,    11,    22,    23,   143,    78,
555      79,    80,   135,   136,   110,    48,    12,    13,    14,    15,
556      16,    49
557};
558
559/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
560   STATE-NUM.  */
561#define YYPACT_NINF -63
562static const short yypact[] =
563{
564      48,   -13,    -8,    53,    16,    11,    14,    73,   -63,    48,
565      94,   -63,   -63,    43,   147,    44,    47,    70,   144,   -63,
566     -63,    53,    -5,    74,    78,    83,   144,   -63,    94,    94,
567     -63,   -63,   -63,    17,    44,    47,    17,    44,    47,   -63,
568     -63,    64,   -63,   -63,   -63,   -63,    97,   111,   107,   -63,
569      58,   103,   -63,   117,    80,   132,   142,    21,   139,    94,
570     -63,   -63,    44,    47,   -63,   -63,    44,    47,   -63,   -63,
571     146,   167,   171,   144,   151,   -63,   149,   -63,   116,    80,
572      80,   138,   -63,   144,   -63,   144,    92,   -63,   -63,   -63,
573     -63,   -63,   -63,   133,   170,   173,   174,   175,   176,   177,
574     160,   -63,   169,   -63,   -63,   179,   180,   181,   182,   183,
575     184,   -63,   -63,   -63,    80,   129,   185,    28,   186,   187,
576     188,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   191,
577     193,   194,   195,   196,   -63,   -63,   -63,   189,   199,   200,
578     201,   202,   152,   163,   -63,   144,   -63,   144,   144,   -63,
579     164,   203,   204,   205,   206,   207,    98,    80,    80,    80,
580      80,   212,   213,   -63,   -63,   129,   129,   198,   210,   211,
581     214,   -63,   -63,   -63,   -63,   -63,   215,   217,   219,   220,
582     221,   222,    80,    80,   223,   224,   144,   -63,   144,   165,
583     225,   228,   -63,   -63,   -63,   -63,   229,   230,   -63,   -63,
584     231,   232,   233,   234,   235,   -63,   -63,    50,   144,   236,
585     -63,   -63,   -63,   144,   240,   -63,   238,   239,   -63,   -63
586};
587
588/* YYPGOTO[NTERM-NUM].  */
589static const short yypgoto[] =
590{
591     -63,   -63,   -63,     9,    -2,     0,   -18,   -63,   -62,   -63,
592      39,    61,   -63,   -63,   -63,   -25,    -4,   190,   208,     1,
593       8,   -52
594};
595
596/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
597   positive, shift that token.  If negative, reduce the rule which
598   number is the opposite.  If zero, do what YYDEFACT says.
599   If YYTABLE_NINF, syntax error.  */
600#define YYTABLE_NINF -1
601static const unsigned char yytable[] =
602{
603      57,    58,    81,    51,    53,    30,    32,    29,    19,    20,
604      31,    17,    21,    52,    34,    37,    18,    40,    28,    96,
605      99,    35,    38,    39,    60,    61,    59,    81,    81,    31,
606      50,    24,    74,    76,    62,    25,    65,    66,    26,    69,
607      84,    63,    64,    85,    67,    68,    86,   146,   100,     2,
608       5,     6,     1,   147,     2,    88,   102,     1,   116,    31,
609     117,   119,   137,   144,    90,     3,    19,    20,    92,   212,
610      89,    19,    20,    27,    91,   213,     5,     6,     6,     4,
611       5,     5,     6,    42,    43,    41,    42,    43,    44,    45,
612     163,    54,    46,    47,    55,    42,    43,    44,    45,    70,
613       2,    46,    47,   184,   185,   178,   179,   180,   181,   176,
614     177,     3,    71,   144,   144,    56,    19,    20,   111,   113,
615     167,    75,   168,   169,   118,     4,    72,     5,     6,    73,
616     196,   197,    42,    43,   104,    77,   138,   139,   140,   141,
617     112,   114,   105,   106,   107,   108,   109,    42,    43,    44,
618      45,    82,   142,    46,    47,    42,    43,    83,    87,   161,
619     162,   200,   115,   201,    19,    20,    93,   103,   120,   101,
620      42,    43,    94,    95,    42,    43,    97,    98,     4,   127,
621       5,     6,   164,   214,   165,   166,   121,   128,   216,   122,
622     123,   124,   125,   126,   129,   130,   131,   132,   133,   170,
623     202,   148,   134,     0,    36,   145,   149,   151,   150,   152,
624     153,   154,   155,   156,   157,   158,   159,   160,   186,     0,
625       0,    33,   171,   172,   173,   174,   175,   182,   183,   187,
626     190,   188,   191,     0,   189,   192,   193,   194,   195,     0,
627       0,   203,   198,   199,   204,   205,   206,   207,     0,   209,
628       0,     0,   208,   210,   211,   215,   217,   218,   219
629};
630
631static const short yycheck[] =
632{
633      25,    26,    54,    21,    22,     9,    10,     9,    13,    14,
634      10,    24,     3,    18,    13,    14,    24,    16,     9,    71,
635      72,    13,    14,    15,    28,    29,    28,    79,    80,    29,
636      21,    15,    50,    51,    33,    24,    35,    36,    24,    38,
637      19,    33,    34,    22,    36,    37,    25,    19,    73,     6,
638      33,    34,     4,    25,     6,    59,    74,     4,    83,    59,
639      85,    86,   114,   115,    63,    17,    13,    14,    67,    19,
640      62,    13,    14,     0,    66,    25,    33,    34,    34,    31,
641      33,    33,    34,     3,     4,    15,     3,     4,     5,     6,
642     142,    17,     9,    10,    16,     3,     4,     5,     6,    35,
643       6,     9,    10,   165,   166,   157,   158,   159,   160,    11,
644      12,    17,    15,   165,   166,    32,    13,    14,    79,    80,
645     145,    18,   147,   148,    32,    31,    15,    33,    34,    22,
646     182,   183,     3,     4,    18,    18,     7,     8,     9,    10,
647      79,    80,    26,    27,    28,    29,    30,     3,     4,     5,
648       6,    19,    23,     9,    10,     3,     4,    15,    19,     7,
649       8,   186,    24,   188,    13,    14,    20,    18,    35,    18,
650       3,     4,     5,     6,     3,     4,     5,     6,    31,    19,
651      33,    34,    19,   208,    21,    22,    16,    18,   213,    16,
652      16,    16,    16,    16,    15,    15,    15,    15,    15,    35,
653      35,    15,    18,    -1,    14,    20,    19,    16,    20,    16,
654      16,    16,    16,    24,    15,    15,    15,    15,    20,    -1,
655      -1,    13,    19,    19,    19,    19,    19,    15,    15,    19,
656      15,    20,    15,    -1,    20,    16,    16,    16,    16,    -1,
657      -1,    16,    19,    19,    16,    16,    16,    16,    -1,    16,
658      -1,    -1,    20,    19,    19,    19,    16,    19,    19
659};
660
661/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
662   symbol of state STATE-NUM.  */
663static const unsigned char yystos[] =
664{
665       0,     4,     6,    17,    31,    33,    34,    37,    38,    39,
666      40,    41,    52,    53,    54,    55,    56,    24,    24,    13,
667      14,    39,    42,    43,    15,    24,    24,     0,    39,    40,
668      52,    41,    52,    54,    55,    56,    53,    55,    56,    56,
669      55,    15,     3,     4,     5,     6,     9,    10,    51,    57,
670      39,    42,    18,    42,    17,    16,    32,    51,    51,    40,
671      52,    52,    55,    56,    56,    55,    55,    56,    56,    55,
672      35,    15,    15,    22,    42,    18,    42,    18,    45,    46,
673      47,    57,    19,    15,    19,    22,    25,    19,    52,    56,
674      55,    56,    55,    20,     5,     6,    57,     5,     6,    57,
675      51,    18,    42,    18,    18,    26,    27,    28,    29,    30,
676      50,    46,    47,    46,    47,    24,    51,    51,    32,    51,
677      35,    16,    16,    16,    16,    16,    16,    19,    18,    15,
678      15,    15,    15,    15,    18,    48,    49,    57,     7,     8,
679       9,    10,    23,    44,    57,    20,    19,    25,    15,    19,
680      20,    16,    16,    16,    16,    16,    24,    15,    15,    15,
681      15,     7,     8,    57,    19,    21,    22,    51,    51,    51,
682      35,    19,    19,    19,    19,    19,    11,    12,    57,    57,
683      57,    57,    15,    15,    44,    44,    20,    19,    20,    20,
684      15,    15,    16,    16,    16,    16,    57,    57,    19,    19,
685      51,    51,    35,    16,    16,    16,    16,    16,    20,    16,
686      19,    19,    19,    25,    51,    19,    51,    16,    19,    19
687};
688
689#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
690# define YYSIZE_T __SIZE_TYPE__
691#endif
692#if ! defined (YYSIZE_T) && defined (size_t)
693# define YYSIZE_T size_t
694#endif
695#if ! defined (YYSIZE_T)
696# if defined (__STDC__) || defined (__cplusplus)
697#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
698#  define YYSIZE_T size_t
699# endif
700#endif
701#if ! defined (YYSIZE_T)
702# define YYSIZE_T unsigned int
703#endif
704
705#define yyerrok         (yyerrstatus = 0)
706#define yyclearin       (yychar = YYEMPTY)
707#define YYEMPTY         (-2)
708#define YYEOF           0
709
710#define YYACCEPT        goto yyacceptlab
711#define YYABORT         goto yyabortlab
712#define YYERROR         goto yyerrlab1
713
714
715/* Like YYERROR except do call yyerror.  This remains here temporarily
716   to ease the transition to the new meaning of YYERROR, for GCC.
717   Once GCC version 2 has supplanted version 1, this can go.  */
718
719#define YYFAIL          goto yyerrlab
720
721#define YYRECOVERING()  (!!yyerrstatus)
722
723#define YYBACKUP(Token, Value)                                  \
724do                                                              \
725  if (yychar == YYEMPTY && yylen == 1)                          \
726    {                                                           \
727      yychar = (Token);                                         \
728      yylval = (Value);                                         \
729      yytoken = YYTRANSLATE (yychar);                           \
730      YYPOPSTACK;                                               \
731      goto yybackup;                                            \
732    }                                                           \
733  else                                                          \
734    {                                                           \
735      yyerror ("syntax error: cannot back up");\
736      YYERROR;                                                  \
737    }                                                           \
738while (0)
739
740#define YYTERROR        1
741#define YYERRCODE       256
742
743/* YYLLOC_DEFAULT -- Compute the default location (before the actions
744   are run).  */
745
746#ifndef YYLLOC_DEFAULT
747# define YYLLOC_DEFAULT(Current, Rhs, N)         \
748  Current.first_line   = Rhs[1].first_line;      \
749  Current.first_column = Rhs[1].first_column;    \
750  Current.last_line    = Rhs[N].last_line;       \
751  Current.last_column  = Rhs[N].last_column;
752#endif
753
754/* YYLEX -- calling `yylex' with the right arguments.  */
755
756#ifdef YYLEX_PARAM
757# define YYLEX yylex (YYLEX_PARAM)
758#else
759# define YYLEX yylex ()
760#endif
761
762/* Enable debugging if requested.  */
763#if YYDEBUG
764
765# ifndef YYFPRINTF
766#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
767#  define YYFPRINTF fprintf
768# endif
769
770# define YYDPRINTF(Args)                        \
771do {                                            \
772  if (yydebug)                                  \
773    YYFPRINTF Args;                             \
774} while (0)
775
776# define YYDSYMPRINT(Args)                      \
777do {                                            \
778  if (yydebug)                                  \
779    yysymprint Args;                            \
780} while (0)
781
782# define YYDSYMPRINTF(Title, Token, Value, Location)            \
783do {                                                            \
784  if (yydebug)                                                  \
785    {                                                           \
786      YYFPRINTF (stderr, "%s ", Title);                         \
787      yysymprint (stderr,                                       \
788                  Token, Value);        \
789      YYFPRINTF (stderr, "\n");                                 \
790    }                                                           \
791} while (0)
792
793/*------------------------------------------------------------------.
794| yy_stack_print -- Print the state stack from its BOTTOM up to its |
795| TOP (cinluded).                                                   |
796`------------------------------------------------------------------*/
797
798#if defined (__STDC__) || defined (__cplusplus)
799static void
800yy_stack_print (short *bottom, short *top)
801#else
802static void
803yy_stack_print (bottom, top)
804    short *bottom;
805    short *top;
806#endif
807{
808  YYFPRINTF (stderr, "Stack now");
809  for (/* Nothing. */; bottom <= top; ++bottom)
810    YYFPRINTF (stderr, " %d", *bottom);
811  YYFPRINTF (stderr, "\n");
812}
813
814# define YY_STACK_PRINT(Bottom, Top)                            \
815do {                                                            \
816  if (yydebug)                                                  \
817    yy_stack_print ((Bottom), (Top));                           \
818} while (0)
819
820
821/*------------------------------------------------.
822| Report that the YYRULE is going to be reduced.  |
823`------------------------------------------------*/
824
825#if defined (__STDC__) || defined (__cplusplus)
826static void
827yy_reduce_print (int yyrule)
828#else
829static void
830yy_reduce_print (yyrule)
831    int yyrule;
832#endif
833{
834  int yyi;
835  unsigned int yylineno = yyrline[yyrule];
836  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
837             yyrule - 1, yylineno);
838  /* Print the symbols being reduced, and their result.  */
839  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
840    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
841  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
842}
843
844# define YY_REDUCE_PRINT(Rule)          \
845do {                                    \
846  if (yydebug)                          \
847    yy_reduce_print (Rule);             \
848} while (0)
849
850/* Nonzero means print parse trace.  It is left uninitialized so that
851   multiple parsers can coexist.  */
852int yydebug;
853#else /* !YYDEBUG */
854# define YYDPRINTF(Args)
855# define YYDSYMPRINT(Args)
856# define YYDSYMPRINTF(Title, Token, Value, Location)
857# define YY_STACK_PRINT(Bottom, Top)
858# define YY_REDUCE_PRINT(Rule)
859#endif /* !YYDEBUG */
860
861
862/* YYINITDEPTH -- initial size of the parser's stacks.  */
863#ifndef YYINITDEPTH
864# define YYINITDEPTH 200
865#endif
866
867/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
868   if the built-in stack extension method is used).
869
870   Do not make this value too large; the results are undefined if
871   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
872   evaluated with infinite-precision integer arithmetic.  */
873
874#if YYMAXDEPTH == 0
875# undef YYMAXDEPTH
876#endif
877
878#ifndef YYMAXDEPTH
879# define YYMAXDEPTH 10000
880#endif
881
882
883
884#if YYERROR_VERBOSE
885
886# ifndef yystrlen
887#  if defined (__GLIBC__) && defined (_STRING_H)
888#   define yystrlen strlen
889#  else
890/* Return the length of YYSTR.  */
891static YYSIZE_T
892#   if defined (__STDC__) || defined (__cplusplus)
893yystrlen (const char *yystr)
894#   else
895yystrlen (yystr)
896     const char *yystr;
897#   endif
898{
899  register const char *yys = yystr;
900
901  while (*yys++ != '\0')
902    continue;
903
904  return yys - yystr - 1;
905}
906#  endif
907# endif
908
909# ifndef yystpcpy
910#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
911#   define yystpcpy stpcpy
912#  else
913/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
914   YYDEST.  */
915static char *
916#   if defined (__STDC__) || defined (__cplusplus)
917yystpcpy (char *yydest, const char *yysrc)
918#   else
919yystpcpy (yydest, yysrc)
920     char *yydest;
921     const char *yysrc;
922#   endif
923{
924  register char *yyd = yydest;
925  register const char *yys = yysrc;
926
927  while ((*yyd++ = *yys++) != '\0')
928    continue;
929
930  return yyd - 1;
931}
932#  endif
933# endif
934
935#endif /* !YYERROR_VERBOSE */
936
937
938
939#if YYDEBUG
940/*--------------------------------.
941| Print this symbol on YYOUTPUT.  |
942`--------------------------------*/
943
944#if defined (__STDC__) || defined (__cplusplus)
945static void
946yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
947#else
948static void
949yysymprint (yyoutput, yytype, yyvaluep)
950    FILE *yyoutput;
951    int yytype;
952    YYSTYPE *yyvaluep;
953#endif
954{
955  /* Pacify ``unused variable'' warnings.  */
956  (void) yyvaluep;
957
958  if (yytype < YYNTOKENS)
959    {
960      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
961# ifdef YYPRINT
962      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
963# endif
964    }
965  else
966    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
967
968  switch (yytype)
969    {
970      default:
971        break;
972    }
973  YYFPRINTF (yyoutput, ")");
974}
975
976#endif /* ! YYDEBUG */
977/*-----------------------------------------------.
978| Release the memory associated to this symbol.  |
979`-----------------------------------------------*/
980
981#if defined (__STDC__) || defined (__cplusplus)
982static void
983yydestruct (int yytype, YYSTYPE *yyvaluep)
984#else
985static void
986yydestruct (yytype, yyvaluep)
987    int yytype;
988    YYSTYPE *yyvaluep;
989#endif
990{
991  /* Pacify ``unused variable'' warnings.  */
992  (void) yyvaluep;
993
994  switch (yytype)
995    {
996
997      default:
998        break;
999    }
1000}
1001
1002
1003/* Prevent warnings from -Wmissing-prototypes.  */
1004
1005#ifdef YYPARSE_PARAM
1006# if defined (__STDC__) || defined (__cplusplus)
1007int yyparse (void *YYPARSE_PARAM);
1008# else
1009int yyparse ();
1010# endif
1011#else /* ! YYPARSE_PARAM */
1012#if defined (__STDC__) || defined (__cplusplus)
1013int yyparse (void);
1014#else
1015int yyparse ();
1016#endif
1017#endif /* ! YYPARSE_PARAM */
1018
1019
1020
1021/* The lookahead symbol.  */
1022int yychar;
1023
1024/* The semantic value of the lookahead symbol.  */
1025YYSTYPE yylval;
1026
1027/* Number of syntax errors so far.  */
1028int yynerrs;
1029
1030
1031
1032/*----------.
1033| yyparse.  |
1034`----------*/
1035
1036#ifdef YYPARSE_PARAM
1037# if defined (__STDC__) || defined (__cplusplus)
1038int yyparse (void *YYPARSE_PARAM)
1039# else
1040int yyparse (YYPARSE_PARAM)
1041  void *YYPARSE_PARAM;
1042# endif
1043#else /* ! YYPARSE_PARAM */
1044#if defined (__STDC__) || defined (__cplusplus)
1045int
1046yyparse (void)
1047#else
1048int
1049yyparse ()
1050
1051#endif
1052#endif
1053{
1054 
1055  register int yystate;
1056  register int yyn;
1057  int yyresult;
1058  /* Number of tokens to shift before error messages enabled.  */
1059  int yyerrstatus;
1060  /* Lookahead token as an internal (translated) token number.  */
1061  int yytoken = 0;
1062
1063  /* Three stacks and their tools:
1064     `yyss': related to states,
1065     `yyvs': related to semantic values,
1066     `yyls': related to locations.
1067
1068     Refer to the stacks thru separate pointers, to allow yyoverflow
1069     to reallocate them elsewhere.  */
1070
1071  /* The state stack.  */
1072  short yyssa[YYINITDEPTH];
1073  short *yyss = yyssa;
1074  register short *yyssp;
1075
1076  /* The semantic value stack.  */
1077  YYSTYPE yyvsa[YYINITDEPTH];
1078  YYSTYPE *yyvs = yyvsa;
1079  register YYSTYPE *yyvsp;
1080
1081
1082
1083#define YYPOPSTACK   (yyvsp--, yyssp--)
1084
1085  YYSIZE_T yystacksize = YYINITDEPTH;
1086
1087  /* The variables used to return semantic value and location from the
1088     action routines.  */
1089  YYSTYPE yyval;
1090
1091
1092  /* When reducing, the number of symbols on the RHS of the reduced
1093     rule.  */
1094  int yylen;
1095
1096  YYDPRINTF ((stderr, "Starting parse\n"));
1097
1098  yystate = 0;
1099  yyerrstatus = 0;
1100  yynerrs = 0;
1101  yychar = YYEMPTY;             /* Cause a token to be read.  */
1102
1103  /* Initialize stack pointers.
1104     Waste one element of value and location stack
1105     so that they stay on the same level as the state stack.
1106     The wasted elements are never initialized.  */
1107
1108  yyssp = yyss;
1109  yyvsp = yyvs;
1110
1111  goto yysetstate;
1112
1113/*------------------------------------------------------------.
1114| yynewstate -- Push a new state, which is found in yystate.  |
1115`------------------------------------------------------------*/
1116 yynewstate:
1117  /* In all cases, when you get here, the value and location stacks
1118     have just been pushed. so pushing a state here evens the stacks.
1119     */
1120  yyssp++;
1121
1122 yysetstate:
1123  *yyssp = yystate;
1124
1125  if (yyss + yystacksize - 1 <= yyssp)
1126    {
1127      /* Get the current used size of the three stacks, in elements.  */
1128      YYSIZE_T yysize = yyssp - yyss + 1;
1129
1130#ifdef yyoverflow
1131      {
1132        /* Give user a chance to reallocate the stack. Use copies of
1133           these so that the &'s don't force the real ones into
1134           memory.  */
1135        YYSTYPE *yyvs1 = yyvs;
1136        short *yyss1 = yyss;
1137
1138
1139        /* Each stack pointer address is followed by the size of the
1140           data in use in that stack, in bytes.  This used to be a
1141           conditional around just the two extra args, but that might
1142           be undefined if yyoverflow is a macro.  */
1143        yyoverflow ("parser stack overflow",
1144                    &yyss1, yysize * sizeof (*yyssp),
1145                    &yyvs1, yysize * sizeof (*yyvsp),
1146
1147                    &yystacksize);
1148
1149        yyss = yyss1;
1150        yyvs = yyvs1;
1151      }
1152#else /* no yyoverflow */
1153# ifndef YYSTACK_RELOCATE
1154      goto yyoverflowlab;
1155# else
1156      /* Extend the stack our own way.  */
1157      if (YYMAXDEPTH <= yystacksize)
1158        goto yyoverflowlab;
1159      yystacksize *= 2;
1160      if (YYMAXDEPTH < yystacksize)
1161        yystacksize = YYMAXDEPTH;
1162
1163      {
1164        short *yyss1 = yyss;
1165        union yyalloc *yyptr =
1166          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1167        if (! yyptr)
1168          goto yyoverflowlab;
1169        YYSTACK_RELOCATE (yyss);
1170        YYSTACK_RELOCATE (yyvs);
1171
1172#  undef YYSTACK_RELOCATE
1173        if (yyss1 != yyssa)
1174          YYSTACK_FREE (yyss1);
1175      }
1176# endif
1177#endif /* no yyoverflow */
1178
1179      yyssp = yyss + yysize - 1;
1180      yyvsp = yyvs + yysize - 1;
1181
1182
1183      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1184                  (unsigned long int) yystacksize));
1185
1186      if (yyss + yystacksize - 1 <= yyssp)
1187        YYABORT;
1188    }
1189
1190  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1191
1192  goto yybackup;
1193
1194/*-----------.
1195| yybackup.  |
1196`-----------*/
1197yybackup:
1198
1199/* Do appropriate processing given the current state.  */
1200/* Read a lookahead token if we need one and don't already have one.  */
1201/* yyresume: */
1202
1203  /* First try to decide what to do without reference to lookahead token.  */
1204
1205  yyn = yypact[yystate];
1206  if (yyn == YYPACT_NINF)
1207    goto yydefault;
1208
1209  /* Not known => get a lookahead token if don't already have one.  */
1210
1211  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1212  if (yychar == YYEMPTY)
1213    {
1214      YYDPRINTF ((stderr, "Reading a token: "));
1215      yychar = YYLEX;
1216    }
1217
1218  if (yychar <= YYEOF)
1219    {
1220      yychar = yytoken = YYEOF;
1221      YYDPRINTF ((stderr, "Now at end of input.\n"));
1222    }
1223  else
1224    {
1225      yytoken = YYTRANSLATE (yychar);
1226      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1227    }
1228
1229  /* If the proper action on seeing token YYTOKEN is to reduce or to
1230     detect an error, take that action.  */
1231  yyn += yytoken;
1232  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1233    goto yydefault;
1234  yyn = yytable[yyn];
1235  if (yyn <= 0)
1236    {
1237      if (yyn == 0 || yyn == YYTABLE_NINF)
1238        goto yyerrlab;
1239      yyn = -yyn;
1240      goto yyreduce;
1241    }
1242
1243  if (yyn == YYFINAL)
1244    YYACCEPT;
1245
1246  /* Shift the lookahead token.  */
1247  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1248
1249  /* Discard the token being shifted unless it is eof.  */
1250  if (yychar != YYEOF)
1251    yychar = YYEMPTY;
1252
1253  *++yyvsp = yylval;
1254
1255
1256  /* Count tokens shifted since error; after three, turn off error
1257     status.  */
1258  if (yyerrstatus)
1259    yyerrstatus--;
1260
1261  yystate = yyn;
1262  goto yynewstate;
1263
1264
1265/*-----------------------------------------------------------.
1266| yydefault -- do the default action for the current state.  |
1267`-----------------------------------------------------------*/
1268yydefault:
1269  yyn = yydefact[yystate];
1270  if (yyn == 0)
1271    goto yyerrlab;
1272  goto yyreduce;
1273
1274
1275/*-----------------------------.
1276| yyreduce -- Do a reduction.  |
1277`-----------------------------*/
1278yyreduce:
1279  /* yyn is the number of a rule to reduce with.  */
1280  yylen = yyr2[yyn];
1281
1282  /* If YYLEN is nonzero, implement the default value of the action:
1283     `$$ = $1'.
1284
1285     Otherwise, the following line sets YYVAL to garbage.
1286     This behavior is undocumented and Bison
1287     users should not rely upon it.  Assigning to YYVAL
1288     unconditionally makes the parser a bit smaller, and it avoids a
1289     GCC warning that YYVAL may be used uninitialized.  */
1290  yyval = yyvsp[1-yylen];
1291
1292
1293  YY_REDUCE_PRINT (yyn);
1294  switch (yyn)
1295    {
1296        case 2:
1297#line 74 "rc1.0_grammar.y"
1298    {
1299                        yyvsp[0].combinersStruct.Validate();
1300                        yyvsp[0].combinersStruct.Invoke();
1301                ;}
1302    break;
1303
1304  case 3:
1305#line 81 "rc1.0_grammar.y"
1306    {
1307                        CombinersStruct combinersStruct;
1308                        combinersStruct.Init(yyvsp[-1].generalCombinersStruct, yyvsp[0].finalCombinerStruct, yyvsp[-2].constColorStruct);
1309                        yyval.combinersStruct = combinersStruct;
1310                ;}
1311    break;
1312
1313  case 4:
1314#line 87 "rc1.0_grammar.y"
1315    {
1316                        CombinersStruct combinersStruct;
1317                        combinersStruct.Init(yyvsp[-1].generalCombinersStruct, yyvsp[0].finalCombinerStruct, yyvsp[-3].constColorStruct, yyvsp[-2].constColorStruct);
1318                        yyval.combinersStruct = combinersStruct;
1319                ;}
1320    break;
1321
1322  case 5:
1323#line 93 "rc1.0_grammar.y"
1324    {
1325                        CombinersStruct combinersStruct;
1326                        combinersStruct.Init(yyvsp[-1].generalCombinersStruct, yyvsp[0].finalCombinerStruct);
1327                        yyval.combinersStruct = combinersStruct;
1328                ;}
1329    break;
1330
1331  case 6:
1332#line 99 "rc1.0_grammar.y"
1333    {
1334                        GeneralCombinersStruct generalCombinersStruct;
1335                        generalCombinersStruct.Init();
1336                        CombinersStruct combinersStruct;
1337                        combinersStruct.Init(generalCombinersStruct, yyvsp[0].finalCombinerStruct, yyvsp[-1].constColorStruct);
1338                        yyval.combinersStruct = combinersStruct;
1339                ;}
1340    break;
1341
1342  case 7:
1343#line 107 "rc1.0_grammar.y"
1344    {
1345                        GeneralCombinersStruct generalCombinersStruct;
1346                        generalCombinersStruct.Init();
1347                        CombinersStruct combinersStruct;
1348                        combinersStruct.Init(generalCombinersStruct, yyvsp[0].finalCombinerStruct, yyvsp[-2].constColorStruct, yyvsp[-1].constColorStruct);
1349                        yyval.combinersStruct = combinersStruct;
1350                ;}
1351    break;
1352
1353  case 8:
1354#line 115 "rc1.0_grammar.y"
1355    {
1356                        GeneralCombinersStruct generalCombinersStruct;
1357                        generalCombinersStruct.Init();
1358                        CombinersStruct combinersStruct;
1359                        combinersStruct.Init(generalCombinersStruct, yyvsp[0].finalCombinerStruct);
1360                        yyval.combinersStruct = combinersStruct;
1361                ;}
1362    break;
1363
1364  case 9:
1365#line 125 "rc1.0_grammar.y"
1366    {
1367                        ConstColorStruct constColorStruct;
1368                        constColorStruct.Init(yyvsp[-11].registerEnum, yyvsp[-8].fval, yyvsp[-6].fval, yyvsp[-4].fval, yyvsp[-2].fval);
1369                        yyval.constColorStruct = constColorStruct;
1370                ;}
1371    break;
1372
1373  case 10:
1374#line 134 "rc1.0_grammar.y"
1375    {
1376                        yyvsp[-1].generalCombinersStruct += yyvsp[0].generalCombinerStruct;
1377                        yyval.generalCombinersStruct = yyvsp[-1].generalCombinersStruct;
1378                ;}
1379    break;
1380
1381  case 11:
1382#line 139 "rc1.0_grammar.y"
1383    {
1384                        GeneralCombinersStruct generalCombinersStruct;
1385                        generalCombinersStruct.Init(yyvsp[0].generalCombinerStruct);
1386                        yyval.generalCombinersStruct = generalCombinersStruct;
1387                ;}
1388    break;
1389
1390  case 12:
1391#line 147 "rc1.0_grammar.y"
1392    {
1393                        GeneralCombinerStruct generalCombinerStruct;
1394                        generalCombinerStruct.Init(yyvsp[-2].generalPortionStruct, yyvsp[-1].generalPortionStruct);
1395                        yyval.generalCombinerStruct = generalCombinerStruct;
1396                ;}
1397    break;
1398
1399  case 13:
1400#line 153 "rc1.0_grammar.y"
1401    {
1402                        GeneralCombinerStruct generalCombinerStruct;
1403                        generalCombinerStruct.Init(yyvsp[-2].generalPortionStruct, yyvsp[-1].generalPortionStruct, yyvsp[-3].constColorStruct);
1404                        yyval.generalCombinerStruct = generalCombinerStruct;
1405                ;}
1406    break;
1407
1408  case 14:
1409#line 159 "rc1.0_grammar.y"
1410    {
1411                        GeneralCombinerStruct generalCombinerStruct;
1412                        generalCombinerStruct.Init(yyvsp[-2].generalPortionStruct, yyvsp[-1].generalPortionStruct, yyvsp[-4].constColorStruct, yyvsp[-3].constColorStruct);
1413                        yyval.generalCombinerStruct = generalCombinerStruct;
1414                ;}
1415    break;
1416
1417  case 15:
1418#line 165 "rc1.0_grammar.y"
1419    {
1420                        GeneralCombinerStruct generalCombinerStruct;
1421                        generalCombinerStruct.Init(yyvsp[-1].generalPortionStruct);
1422                        yyval.generalCombinerStruct = generalCombinerStruct;
1423                ;}
1424    break;
1425
1426  case 16:
1427#line 171 "rc1.0_grammar.y"
1428    {
1429                        GeneralCombinerStruct generalCombinerStruct;
1430                        generalCombinerStruct.Init(yyvsp[-1].generalPortionStruct, yyvsp[-2].constColorStruct);
1431                        yyval.generalCombinerStruct = generalCombinerStruct;
1432                ;}
1433    break;
1434
1435  case 17:
1436#line 177 "rc1.0_grammar.y"
1437    {
1438                        GeneralCombinerStruct generalCombinerStruct;
1439                        generalCombinerStruct.Init(yyvsp[-1].generalPortionStruct, yyvsp[-3].constColorStruct, yyvsp[-2].constColorStruct);
1440                        yyval.generalCombinerStruct = generalCombinerStruct;
1441                ;}
1442    break;
1443
1444  case 18:
1445#line 185 "rc1.0_grammar.y"
1446    {
1447                        GeneralPortionStruct generalPortionStruct;
1448                        generalPortionStruct.Init(yyvsp[-4].ival, yyvsp[-2].generalFunctionStruct, yyvsp[-1].biasScaleEnum);
1449                        yyval.generalPortionStruct = generalPortionStruct;
1450                ;}
1451    break;
1452
1453  case 19:
1454#line 191 "rc1.0_grammar.y"
1455    {
1456                        BiasScaleEnum noScale;
1457                        noScale.word = RCP_SCALE_BY_ONE;
1458                        GeneralPortionStruct generalPortionStruct;
1459                        generalPortionStruct.Init(yyvsp[-3].ival, yyvsp[-1].generalFunctionStruct, noScale);
1460                        yyval.generalPortionStruct = generalPortionStruct;
1461                ;}
1462    break;
1463
1464  case 20:
1465#line 201 "rc1.0_grammar.y"
1466    {
1467                        yyval.ival = yyvsp[0].ival;
1468                ;}
1469    break;
1470
1471  case 21:
1472#line 205 "rc1.0_grammar.y"
1473    {
1474                        yyval.ival = yyvsp[0].ival;
1475                ;}
1476    break;
1477
1478  case 22:
1479#line 211 "rc1.0_grammar.y"
1480    {
1481                        MappedRegisterStruct reg;
1482                        reg.Init(yyvsp[0].registerEnum, GL_SIGNED_IDENTITY_NV);
1483                        yyval.mappedRegisterStruct = reg;
1484                ;}
1485    break;
1486
1487  case 23:
1488#line 217 "rc1.0_grammar.y"
1489    {
1490                        MappedRegisterStruct reg;
1491                        reg.Init(yyvsp[0].registerEnum, GL_SIGNED_NEGATE_NV);
1492                        yyval.mappedRegisterStruct = reg;
1493                ;}
1494    break;
1495
1496  case 24:
1497#line 223 "rc1.0_grammar.y"
1498    {
1499                        MappedRegisterStruct reg;
1500                        reg.Init(yyvsp[-1].registerEnum, GL_EXPAND_NORMAL_NV);
1501                        yyval.mappedRegisterStruct = reg;
1502                ;}
1503    break;
1504
1505  case 25:
1506#line 229 "rc1.0_grammar.y"
1507    {
1508                        MappedRegisterStruct reg;
1509                        reg.Init(yyvsp[-1].registerEnum, GL_EXPAND_NEGATE_NV);
1510                        yyval.mappedRegisterStruct = reg;
1511                ;}
1512    break;
1513
1514  case 26:
1515#line 235 "rc1.0_grammar.y"
1516    {
1517                        MappedRegisterStruct reg;
1518                        reg.Init(yyvsp[-1].registerEnum, GL_HALF_BIAS_NORMAL_NV);
1519                        yyval.mappedRegisterStruct = reg;
1520                ;}
1521    break;
1522
1523  case 27:
1524#line 241 "rc1.0_grammar.y"
1525    {
1526                        MappedRegisterStruct reg;
1527                        reg.Init(yyvsp[-1].registerEnum, GL_HALF_BIAS_NEGATE_NV);
1528                        yyval.mappedRegisterStruct = reg;
1529                ;}
1530    break;
1531
1532  case 28:
1533#line 247 "rc1.0_grammar.y"
1534    {
1535                        MappedRegisterStruct reg;
1536                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_IDENTITY_NV);
1537                        yyval.mappedRegisterStruct = reg;
1538                ;}
1539    break;
1540
1541  case 29:
1542#line 253 "rc1.0_grammar.y"
1543    {
1544                        MappedRegisterStruct reg;
1545                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_INVERT_NV);
1546                        yyval.mappedRegisterStruct = reg;
1547                ;}
1548    break;
1549
1550  case 30:
1551#line 261 "rc1.0_grammar.y"
1552    {
1553                        GeneralFunctionStruct generalFunction;
1554                        generalFunction.Init(yyvsp[-1].opStruct, yyvsp[0].opStruct);
1555                        yyval.generalFunctionStruct = generalFunction;
1556                ;}
1557    break;
1558
1559  case 31:
1560#line 267 "rc1.0_grammar.y"
1561    {
1562                        GeneralFunctionStruct generalFunction;
1563                        generalFunction.Init(yyvsp[-1].opStruct, yyvsp[0].opStruct);
1564                        yyval.generalFunctionStruct = generalFunction;
1565                ;}
1566    break;
1567
1568  case 32:
1569#line 273 "rc1.0_grammar.y"
1570    {
1571                        GeneralFunctionStruct generalFunction;
1572                        generalFunction.Init(yyvsp[-1].opStruct, yyvsp[0].opStruct);
1573                        yyval.generalFunctionStruct = generalFunction;
1574                ;}
1575    break;
1576
1577  case 33:
1578#line 279 "rc1.0_grammar.y"
1579    {
1580                        GeneralFunctionStruct generalFunction;
1581                        generalFunction.Init(yyvsp[0].opStruct);
1582                        yyval.generalFunctionStruct = generalFunction;
1583                ;}
1584    break;
1585
1586  case 34:
1587#line 285 "rc1.0_grammar.y"
1588    {
1589                        GeneralFunctionStruct generalFunction;
1590                        generalFunction.Init(yyvsp[-1].opStruct, yyvsp[0].opStruct);
1591                        yyval.generalFunctionStruct = generalFunction;
1592                ;}
1593    break;
1594
1595  case 35:
1596#line 291 "rc1.0_grammar.y"
1597    {
1598                        GeneralFunctionStruct generalFunction;
1599                        generalFunction.Init(yyvsp[-2].opStruct, yyvsp[-1].opStruct, yyvsp[0].opStruct);
1600                        yyval.generalFunctionStruct = generalFunction;
1601                ;}
1602    break;
1603
1604  case 36:
1605#line 297 "rc1.0_grammar.y"
1606    {
1607                        GeneralFunctionStruct generalFunction;
1608                        generalFunction.Init(yyvsp[-2].opStruct, yyvsp[-1].opStruct, yyvsp[0].opStruct);
1609                        yyval.generalFunctionStruct = generalFunction;
1610                ;}
1611    break;
1612
1613  case 37:
1614#line 303 "rc1.0_grammar.y"
1615    {
1616                        GeneralFunctionStruct generalFunction;
1617                        generalFunction.Init(yyvsp[0].opStruct);
1618                        yyval.generalFunctionStruct = generalFunction;
1619                ;}
1620    break;
1621
1622  case 38:
1623#line 311 "rc1.0_grammar.y"
1624    {
1625                        OpStruct dotFunction;
1626                        dotFunction.Init(RCP_DOT, yyvsp[-5].registerEnum, yyvsp[-3].mappedRegisterStruct, yyvsp[-1].mappedRegisterStruct);
1627                        yyval.opStruct = dotFunction;
1628                ;}
1629    break;
1630
1631  case 39:
1632#line 319 "rc1.0_grammar.y"
1633    {
1634                        OpStruct mulFunction;
1635                        mulFunction.Init(RCP_MUL, yyvsp[-5].registerEnum, yyvsp[-3].mappedRegisterStruct, yyvsp[-1].mappedRegisterStruct);
1636                        yyval.opStruct = mulFunction;
1637                ;}
1638    break;
1639
1640  case 40:
1641#line 325 "rc1.0_grammar.y"
1642    {
1643                        RegisterEnum zero;
1644                        zero.word = RCP_ZERO;
1645                        MappedRegisterStruct one;
1646                        one.Init(zero, GL_UNSIGNED_INVERT_NV);
1647                        OpStruct mulFunction;
1648                        mulFunction.Init(RCP_MUL, yyvsp[-3].registerEnum, yyvsp[-1].mappedRegisterStruct, one);
1649                        yyval.opStruct = mulFunction;
1650                ;}
1651    break;
1652
1653  case 41:
1654#line 337 "rc1.0_grammar.y"
1655    {
1656                        OpStruct muxFunction;
1657                        muxFunction.Init(RCP_MUX, yyvsp[-5].registerEnum);
1658                        yyval.opStruct = muxFunction;
1659                ;}
1660    break;
1661
1662  case 42:
1663#line 345 "rc1.0_grammar.y"
1664    {
1665                        OpStruct sumFunction;
1666                        sumFunction.Init(RCP_SUM, yyvsp[-5].registerEnum);
1667                        yyval.opStruct = sumFunction;
1668                ;}
1669    break;
1670
1671  case 43:
1672#line 353 "rc1.0_grammar.y"
1673    {
1674                        yyval.biasScaleEnum = yyvsp[-3].biasScaleEnum;
1675                ;}
1676    break;
1677
1678  case 44:
1679#line 357 "rc1.0_grammar.y"
1680    {
1681                        yyval.biasScaleEnum = yyvsp[-3].biasScaleEnum;
1682                ;}
1683    break;
1684
1685  case 45:
1686#line 361 "rc1.0_grammar.y"
1687    {
1688                        yyval.biasScaleEnum = yyvsp[-3].biasScaleEnum;
1689                ;}
1690    break;
1691
1692  case 46:
1693#line 365 "rc1.0_grammar.y"
1694    {
1695                        yyval.biasScaleEnum = yyvsp[-3].biasScaleEnum;
1696                ;}
1697    break;
1698
1699  case 47:
1700#line 369 "rc1.0_grammar.y"
1701    {
1702                        yyval.biasScaleEnum = yyvsp[-3].biasScaleEnum;
1703                ;}
1704    break;
1705
1706  case 48:
1707#line 375 "rc1.0_grammar.y"
1708    {
1709                        MappedRegisterStruct reg;
1710                        reg.Init(yyvsp[0].registerEnum, GL_UNSIGNED_IDENTITY_NV);
1711                        yyval.mappedRegisterStruct = reg;
1712                ;}
1713    break;
1714
1715  case 49:
1716#line 381 "rc1.0_grammar.y"
1717    {
1718                        MappedRegisterStruct reg;
1719                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_IDENTITY_NV);
1720                        yyval.mappedRegisterStruct = reg;
1721                ;}
1722    break;
1723
1724  case 50:
1725#line 387 "rc1.0_grammar.y"
1726    {
1727                        MappedRegisterStruct reg;
1728                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_INVERT_NV);
1729                        yyval.mappedRegisterStruct = reg;
1730                ;}
1731    break;
1732
1733  case 51:
1734#line 393 "rc1.0_grammar.y"
1735    {
1736                        MappedRegisterStruct reg;
1737                        reg.Init(yyvsp[0].registerEnum);
1738                        yyval.mappedRegisterStruct = reg;
1739                ;}
1740    break;
1741
1742  case 52:
1743#line 399 "rc1.0_grammar.y"
1744    {
1745                        MappedRegisterStruct reg;
1746                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_IDENTITY_NV);
1747                        yyval.mappedRegisterStruct = reg;
1748                ;}
1749    break;
1750
1751  case 53:
1752#line 405 "rc1.0_grammar.y"
1753    {
1754                        MappedRegisterStruct reg;
1755                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_INVERT_NV);
1756                        yyval.mappedRegisterStruct = reg;
1757                ;}
1758    break;
1759
1760  case 54:
1761#line 411 "rc1.0_grammar.y"
1762    {
1763                        MappedRegisterStruct reg;
1764                        reg.Init(yyvsp[0].registerEnum);
1765                        yyval.mappedRegisterStruct = reg;
1766                ;}
1767    break;
1768
1769  case 55:
1770#line 417 "rc1.0_grammar.y"
1771    {
1772                        MappedRegisterStruct reg;
1773                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_IDENTITY_NV);
1774                        yyval.mappedRegisterStruct = reg;
1775                ;}
1776    break;
1777
1778  case 56:
1779#line 423 "rc1.0_grammar.y"
1780    {
1781                        MappedRegisterStruct reg;
1782                        reg.Init(yyvsp[-1].registerEnum, GL_UNSIGNED_INVERT_NV);
1783                        yyval.mappedRegisterStruct = reg;
1784                ;}
1785    break;
1786
1787  case 57:
1788#line 431 "rc1.0_grammar.y"
1789    {
1790                        FinalCombinerStruct finalCombinerStruct;
1791                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, yyvsp[-1].finalAlphaFunctionStruct, false);
1792                        yyval.finalCombinerStruct = finalCombinerStruct;
1793                ;}
1794    break;
1795
1796  case 58:
1797#line 437 "rc1.0_grammar.y"
1798    {
1799                        FinalCombinerStruct finalCombinerStruct;
1800                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, yyvsp[-1].finalAlphaFunctionStruct, true);
1801                        yyval.finalCombinerStruct = finalCombinerStruct;
1802                ;}
1803    break;
1804
1805  case 59:
1806#line 443 "rc1.0_grammar.y"
1807    {
1808                        FinalCombinerStruct finalCombinerStruct;
1809                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, yyvsp[-1].finalAlphaFunctionStruct, false, yyvsp[-2].finalProductStruct);
1810                        yyval.finalCombinerStruct = finalCombinerStruct;
1811                ;}
1812    break;
1813
1814  case 60:
1815#line 449 "rc1.0_grammar.y"
1816    {
1817                        FinalCombinerStruct finalCombinerStruct;
1818                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, yyvsp[-1].finalAlphaFunctionStruct, true, yyvsp[-2].finalProductStruct);
1819                        yyval.finalCombinerStruct = finalCombinerStruct;
1820                ;}
1821    break;
1822
1823  case 61:
1824#line 455 "rc1.0_grammar.y"
1825    {
1826                        FinalCombinerStruct finalCombinerStruct;
1827                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, yyvsp[-1].finalAlphaFunctionStruct, true, yyvsp[-3].finalProductStruct);
1828                        yyval.finalCombinerStruct = finalCombinerStruct;
1829                ;}
1830    break;
1831
1832  case 62:
1833#line 462 "rc1.0_grammar.y"
1834    {
1835                        FinalCombinerStruct finalCombinerStruct;
1836                        finalCombinerStruct.Init(yyvsp[-1].finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, false);
1837                        yyval.finalCombinerStruct = finalCombinerStruct;
1838                ;}
1839    break;
1840
1841  case 63:
1842#line 468 "rc1.0_grammar.y"
1843    {
1844                        FinalCombinerStruct finalCombinerStruct;
1845                        finalCombinerStruct.Init(yyvsp[-1].finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true);
1846                        yyval.finalCombinerStruct = finalCombinerStruct;
1847                ;}
1848    break;
1849
1850  case 64:
1851#line 474 "rc1.0_grammar.y"
1852    {
1853                        FinalCombinerStruct finalCombinerStruct;
1854                        finalCombinerStruct.Init(yyvsp[-1].finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, false, yyvsp[-2].finalProductStruct);
1855                        yyval.finalCombinerStruct = finalCombinerStruct;
1856                ;}
1857    break;
1858
1859  case 65:
1860#line 480 "rc1.0_grammar.y"
1861    {
1862                        FinalCombinerStruct finalCombinerStruct;
1863                        finalCombinerStruct.Init(yyvsp[-1].finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true, yyvsp[-2].finalProductStruct);
1864                        yyval.finalCombinerStruct = finalCombinerStruct;
1865                ;}
1866    break;
1867
1868  case 66:
1869#line 486 "rc1.0_grammar.y"
1870    {
1871                        FinalCombinerStruct finalCombinerStruct;
1872                        finalCombinerStruct.Init(yyvsp[-1].finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true, yyvsp[-3].finalProductStruct);
1873                        yyval.finalCombinerStruct = finalCombinerStruct;
1874                ;}
1875    break;
1876
1877  case 67:
1878#line 493 "rc1.0_grammar.y"
1879    {
1880                        FinalCombinerStruct finalCombinerStruct;
1881                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
1882                        finalAlphaFunctionStruct.ZeroOut();
1883                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, finalAlphaFunctionStruct, false);
1884                        yyval.finalCombinerStruct = finalCombinerStruct;
1885                ;}
1886    break;
1887
1888  case 68:
1889#line 501 "rc1.0_grammar.y"
1890    {
1891                        FinalCombinerStruct finalCombinerStruct;
1892                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
1893                        finalAlphaFunctionStruct.ZeroOut();
1894                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, finalAlphaFunctionStruct, true);
1895                        yyval.finalCombinerStruct = finalCombinerStruct;
1896                ;}
1897    break;
1898
1899  case 69:
1900#line 509 "rc1.0_grammar.y"
1901    {
1902                        FinalCombinerStruct finalCombinerStruct;
1903                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
1904                        finalAlphaFunctionStruct.ZeroOut();
1905                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, finalAlphaFunctionStruct, false, yyvsp[-1].finalProductStruct);
1906                        yyval.finalCombinerStruct = finalCombinerStruct;
1907                ;}
1908    break;
1909
1910  case 70:
1911#line 517 "rc1.0_grammar.y"
1912    {
1913                        FinalCombinerStruct finalCombinerStruct;
1914                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
1915                        finalAlphaFunctionStruct.ZeroOut();
1916                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, finalAlphaFunctionStruct, true, yyvsp[-1].finalProductStruct);
1917                        yyval.finalCombinerStruct = finalCombinerStruct;
1918                ;}
1919    break;
1920
1921  case 71:
1922#line 525 "rc1.0_grammar.y"
1923    {
1924                        FinalCombinerStruct finalCombinerStruct;
1925                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
1926                        finalAlphaFunctionStruct.ZeroOut();
1927                        finalCombinerStruct.Init(yyvsp[0].finalRgbFunctionStruct, finalAlphaFunctionStruct, true, yyvsp[-2].finalProductStruct);
1928                        yyval.finalCombinerStruct = finalCombinerStruct;
1929                ;}
1930    break;
1931
1932  case 72:
1933#line 534 "rc1.0_grammar.y"
1934    {
1935                        FinalCombinerStruct finalCombinerStruct;
1936                        FinalRgbFunctionStruct finalRgbFunctionStruct;
1937                        finalRgbFunctionStruct.ZeroOut();
1938                        finalCombinerStruct.Init(finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, false);
1939                        yyval.finalCombinerStruct = finalCombinerStruct;
1940                ;}
1941    break;
1942
1943  case 73:
1944#line 542 "rc1.0_grammar.y"
1945    {
1946                        FinalCombinerStruct finalCombinerStruct;
1947                        FinalRgbFunctionStruct finalRgbFunctionStruct;
1948                        finalRgbFunctionStruct.ZeroOut();
1949                        finalCombinerStruct.Init(finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true);
1950                        yyval.finalCombinerStruct = finalCombinerStruct;
1951                ;}
1952    break;
1953
1954  case 74:
1955#line 550 "rc1.0_grammar.y"
1956    {
1957                        FinalCombinerStruct finalCombinerStruct;
1958                        FinalRgbFunctionStruct finalRgbFunctionStruct;
1959                        finalRgbFunctionStruct.ZeroOut();
1960                        finalCombinerStruct.Init(finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, false, yyvsp[-1].finalProductStruct);
1961                        yyval.finalCombinerStruct = finalCombinerStruct;
1962                ;}
1963    break;
1964
1965  case 75:
1966#line 558 "rc1.0_grammar.y"
1967    {
1968                        FinalCombinerStruct finalCombinerStruct;
1969                        FinalRgbFunctionStruct finalRgbFunctionStruct;
1970                        finalRgbFunctionStruct.ZeroOut();
1971                        finalCombinerStruct.Init(finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true, yyvsp[-1].finalProductStruct);
1972                        yyval.finalCombinerStruct = finalCombinerStruct;
1973                ;}
1974    break;
1975
1976  case 76:
1977#line 566 "rc1.0_grammar.y"
1978    {
1979                        FinalCombinerStruct finalCombinerStruct;
1980                        FinalRgbFunctionStruct finalRgbFunctionStruct;
1981                        finalRgbFunctionStruct.ZeroOut();
1982                        finalCombinerStruct.Init(finalRgbFunctionStruct, yyvsp[0].finalAlphaFunctionStruct, true, yyvsp[-2].finalProductStruct);
1983                        yyval.finalCombinerStruct = finalCombinerStruct;
1984                ;}
1985    break;
1986
1987  case 77:
1988#line 576 "rc1.0_grammar.y"
1989    {
1990                        yyval.ival = yyvsp[-3].ival;
1991                ;}
1992    break;
1993
1994  case 78:
1995#line 582 "rc1.0_grammar.y"
1996    {
1997                        FinalProductStruct finalProductStruct;
1998                        finalProductStruct.Init(yyvsp[-3].mappedRegisterStruct, yyvsp[-1].mappedRegisterStruct);
1999                        yyval.finalProductStruct = finalProductStruct;
2000                ;}
2001    break;
2002
2003  case 79:
2004#line 590 "rc1.0_grammar.y"
2005    {
2006                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2007                        finalRgbFunctionStruct.Init(yyvsp[-8].mappedRegisterStruct, yyvsp[-6].mappedRegisterStruct, yyvsp[-4].mappedRegisterStruct, yyvsp[-1].mappedRegisterStruct);
2008                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2009                ;}
2010    break;
2011
2012  case 80:
2013#line 596 "rc1.0_grammar.y"
2014    {
2015                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2016                        finalRgbFunctionStruct.Init(yyvsp[-6].mappedRegisterStruct, yyvsp[-4].mappedRegisterStruct, yyvsp[-2].mappedRegisterStruct, yyvsp[-10].mappedRegisterStruct);
2017                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2018                ;}
2019    break;
2020
2021  case 81:
2022#line 602 "rc1.0_grammar.y"
2023    {
2024                        RegisterEnum zero;
2025                        zero.word = RCP_ZERO;
2026                        MappedRegisterStruct reg;
2027                        reg.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2028                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2029                        finalRgbFunctionStruct.Init(yyvsp[-6].mappedRegisterStruct, yyvsp[-4].mappedRegisterStruct, yyvsp[-2].mappedRegisterStruct, reg);
2030                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2031                ;}
2032    break;
2033
2034  case 82:
2035#line 612 "rc1.0_grammar.y"
2036    {
2037                        RegisterEnum zero;
2038                        zero.word = RCP_ZERO;
2039                        MappedRegisterStruct reg1;
2040                        reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2041                        MappedRegisterStruct reg2;
2042                        reg2.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2043                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2044                        finalRgbFunctionStruct.Init(yyvsp[-3].mappedRegisterStruct, yyvsp[-1].mappedRegisterStruct, reg1, reg2);
2045                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2046                ;}
2047    break;
2048
2049  case 83:
2050#line 624 "rc1.0_grammar.y"
2051    {
2052                        RegisterEnum zero;
2053                        zero.word = RCP_ZERO;
2054                        MappedRegisterStruct reg1;
2055                        reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2056                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2057                        finalRgbFunctionStruct.Init(yyvsp[-5].mappedRegisterStruct, yyvsp[-3].mappedRegisterStruct, reg1, yyvsp[-1].mappedRegisterStruct);
2058                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2059                ;}
2060    break;
2061
2062  case 84:
2063#line 634 "rc1.0_grammar.y"
2064    {
2065                        RegisterEnum zero;
2066                        zero.word = RCP_ZERO;
2067                        MappedRegisterStruct reg1;
2068                        reg1.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2069                        MappedRegisterStruct reg2;
2070                        reg2.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2071                        MappedRegisterStruct reg3;
2072                        reg3.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2073                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2074                        finalRgbFunctionStruct.Init(reg1, reg2, reg3, yyvsp[-1].mappedRegisterStruct);
2075                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2076                ;}
2077    break;
2078
2079  case 85:
2080#line 648 "rc1.0_grammar.y"
2081    {
2082                        RegisterEnum zero;
2083                        zero.word = RCP_ZERO;
2084                        MappedRegisterStruct reg2;
2085                        reg2.Init(zero, GL_UNSIGNED_INVERT_NV);
2086                        MappedRegisterStruct reg3;
2087                        reg3.Init(zero, GL_UNSIGNED_IDENTITY_NV);
2088                        FinalRgbFunctionStruct finalRgbFunctionStruct;
2089                        finalRgbFunctionStruct.Init(yyvsp[-3].mappedRegisterStruct, reg2, reg3, yyvsp[-1].mappedRegisterStruct);
2090                        yyval.finalRgbFunctionStruct = finalRgbFunctionStruct;
2091                ;}
2092    break;
2093
2094  case 86:
2095#line 662 "rc1.0_grammar.y"
2096    {
2097                        FinalAlphaFunctionStruct finalAlphaFunctionStruct;
2098                        finalAlphaFunctionStruct.Init(yyvsp[-1].mappedRegisterStruct);
2099                        yyval.finalAlphaFunctionStruct = finalAlphaFunctionStruct;
2100                ;}
2101    break;
2102
2103  case 87:
2104#line 670 "rc1.0_grammar.y"
2105    {
2106                        yyval.registerEnum = yyvsp[0].registerEnum;
2107                ;}
2108    break;
2109
2110  case 88:
2111#line 674 "rc1.0_grammar.y"
2112    {
2113                        yyval.registerEnum = yyvsp[0].registerEnum;
2114                ;}
2115    break;
2116
2117
2118    }
2119
2120/* Line 999 of yacc.c.  */
2121#line 2093 "_rc1.0_parser.c"
2122
2123  yyvsp -= yylen;
2124  yyssp -= yylen;
2125
2126
2127  YY_STACK_PRINT (yyss, yyssp);
2128
2129  *++yyvsp = yyval;
2130
2131
2132  /* Now `shift' the result of the reduction.  Determine what state
2133     that goes to, based on the state we popped back to and the rule
2134     number reduced by.  */
2135
2136  yyn = yyr1[yyn];
2137
2138  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2139  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2140    yystate = yytable[yystate];
2141  else
2142    yystate = yydefgoto[yyn - YYNTOKENS];
2143
2144  goto yynewstate;
2145
2146
2147/*------------------------------------.
2148| yyerrlab -- here on detecting error |
2149`------------------------------------*/
2150yyerrlab:
2151  /* If not already recovering from an error, report this error.  */
2152  if (!yyerrstatus)
2153    {
2154      ++yynerrs;
2155#if YYERROR_VERBOSE
2156      yyn = yypact[yystate];
2157
2158      if (YYPACT_NINF < yyn && yyn < YYLAST)
2159        {
2160          YYSIZE_T yysize = 0;
2161          int yytype = YYTRANSLATE (yychar);
2162          char *yymsg;
2163          int yyx, yycount;
2164
2165          yycount = 0;
2166          /* Start YYX at -YYN if negative to avoid negative indexes in
2167             YYCHECK.  */
2168          for (yyx = yyn < 0 ? -yyn : 0;
2169               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
2170            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2171              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
2172          yysize += yystrlen ("syntax error, unexpected ") + 1;
2173          yysize += yystrlen (yytname[yytype]);
2174          yymsg = (char *) YYSTACK_ALLOC (yysize);
2175          if (yymsg != 0)
2176            {
2177              char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
2178              yyp = yystpcpy (yyp, yytname[yytype]);
2179
2180              if (yycount < 5)
2181                {
2182                  yycount = 0;
2183                  for (yyx = yyn < 0 ? -yyn : 0;
2184                       yyx < (int) (sizeof (yytname) / sizeof (char *));
2185                       yyx++)
2186                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2187                      {
2188                        const char *yyq = ! yycount ? ", expecting " : " or ";
2189                        yyp = yystpcpy (yyp, yyq);
2190                        yyp = yystpcpy (yyp, yytname[yyx]);
2191                        yycount++;
2192                      }
2193                }
2194              yyerror (yymsg);
2195              YYSTACK_FREE (yymsg);
2196            }
2197          else
2198            yyerror ("syntax error; also virtual memory exhausted");
2199        }
2200      else
2201#endif /* YYERROR_VERBOSE */
2202        yyerror ("syntax error");
2203    }
2204
2205
2206
2207  if (yyerrstatus == 3)
2208    {
2209      /* If just tried and failed to reuse lookahead token after an
2210         error, discard it.  */
2211
2212      /* Return failure if at end of input.  */
2213      if (yychar == YYEOF)
2214        {
2215          /* Pop the error token.  */
2216          YYPOPSTACK;
2217          /* Pop the rest of the stack.  */
2218          while (yyss < yyssp)
2219            {
2220              YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2221              yydestruct (yystos[*yyssp], yyvsp);
2222              YYPOPSTACK;
2223            }
2224          YYABORT;
2225        }
2226
2227      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
2228      yydestruct (yytoken, &yylval);
2229      yychar = YYEMPTY;
2230
2231    }
2232
2233  /* Else will try to reuse lookahead token after shifting the error
2234     token.  */
2235  goto yyerrlab1;
2236
2237
2238/*----------------------------------------------------.
2239| yyerrlab1 -- error raised explicitly by an action.  |
2240`----------------------------------------------------*/
2241yyerrlab1:
2242  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2243
2244  for (;;)
2245    {
2246      yyn = yypact[yystate];
2247      if (yyn != YYPACT_NINF)
2248        {
2249          yyn += YYTERROR;
2250          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2251            {
2252              yyn = yytable[yyn];
2253              if (0 < yyn)
2254                break;
2255            }
2256        }
2257
2258      /* Pop the current state because it cannot handle the error token.  */
2259      if (yyssp == yyss)
2260        YYABORT;
2261
2262      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2263      yydestruct (yystos[yystate], yyvsp);
2264      yyvsp--;
2265      yystate = *--yyssp;
2266
2267      YY_STACK_PRINT (yyss, yyssp);
2268    }
2269
2270  if (yyn == YYFINAL)
2271    YYACCEPT;
2272
2273  YYDPRINTF ((stderr, "Shifting error token, "));
2274
2275  *++yyvsp = yylval;
2276
2277
2278  yystate = yyn;
2279  goto yynewstate;
2280
2281
2282/*-------------------------------------.
2283| yyacceptlab -- YYACCEPT comes here.  |
2284`-------------------------------------*/
2285yyacceptlab:
2286  yyresult = 0;
2287  goto yyreturn;
2288
2289/*-----------------------------------.
2290| yyabortlab -- YYABORT comes here.  |
2291`-----------------------------------*/
2292yyabortlab:
2293  yyresult = 1;
2294  goto yyreturn;
2295
2296#ifndef yyoverflow
2297/*----------------------------------------------.
2298| yyoverflowlab -- parser overflow comes here.  |
2299`----------------------------------------------*/
2300yyoverflowlab:
2301  yyerror ("parser stack overflow");
2302  yyresult = 2;
2303  /* Fall through.  */
2304#endif
2305
2306yyreturn:
2307#ifndef yyoverflow
2308  if (yyss != yyssa)
2309    YYSTACK_FREE (yyss);
2310#endif
2311  return yyresult;
2312}
2313
2314
2315#line 679 "rc1.0_grammar.y"
2316
2317void yyerror(char* s)
2318{
2319     errors.set("unrecognized token");
2320}
2321
Note: See TracBrowser for help on using the repository browser.