source: OGRE/trunk/ogrenew/RenderSystems/GL/src/nvparse/_rc1.0_parser.cpp @ 692

Revision 692, 69.7 KB checked in by mattausch, 18 years ago (diff)

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