ppdparser.cpp

00001 /* A Bison parser, made by GNU Bison 1.875.  */
00002 
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019    Boston, MA 02110-1301, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with yy or YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define YYBISON 1
00038 
00039 /* Skeleton name.  */
00040 #define YYSKELETON_NAME "yacc.c"
00041 
00042 /* Pure parsers.  */
00043 #define YYPURE 0
00044 
00045 /* Using locations.  */
00046 #define YYLSP_NEEDED 0
00047 
00048 /* If NAME_PREFIX is specified substitute the variables and functions
00049    names.  */
00050 #define yyparse kdeprint_ppdparse
00051 #define yylex   kdeprint_ppdlex
00052 #define yyerror kdeprint_ppderror
00053 #define yylval  kdeprint_ppdlval
00054 #define yychar  kdeprint_ppdchar
00055 #define yydebug kdeprint_ppddebug
00056 #define yynerrs kdeprint_ppdnerrs
00057 
00058 
00059 /* Tokens.  */
00060 #ifndef YYTOKENTYPE
00061 # define YYTOKENTYPE
00062    /* Put the tokens into the symbol table, so that GDB and other debuggers
00063       know about them.  */
00064    enum yytokentype {
00065      TRANSLATION = 258,
00066      OPENUI = 259,
00067      CLOSEUI = 260,
00068      OPENGROUP = 261,
00069      CLOSEGROUP = 262,
00070      DEFAULT = 263,
00071      KEYWORD = 264,
00072      OPTION = 265,
00073      STRINGPART = 266,
00074      QUOTED = 267,
00075      CONSTRAINT = 268,
00076      PAPERDIM = 269,
00077      IMGAREA = 270,
00078      FOODATA = 271,
00079      COMMENT = 272
00080    };
00081 #endif
00082 #define TRANSLATION 258
00083 #define OPENUI 259
00084 #define CLOSEUI 260
00085 #define OPENGROUP 261
00086 #define CLOSEGROUP 262
00087 #define DEFAULT 263
00088 #define KEYWORD 264
00089 #define OPTION 265
00090 #define STRINGPART 266
00091 #define QUOTED 267
00092 #define CONSTRAINT 268
00093 #define PAPERDIM 269
00094 #define IMGAREA 270
00095 #define FOODATA 271
00096 #define COMMENT 272
00097 
00098 
00099 
00100 
00101 /* Copy the first part of user declarations.  */
00102 #line 1 "./ppdparser.y"
00103 
00104 /*
00105  *  This file is part of the KDE libraries
00106  *  Copyright (c) 2001-2003 Michael Goffioul <kdeprint@swing.be>
00107  *
00108  *  This library is free software; you can redistribute it and/or
00109  *  modify it under the terms of the GNU Library General Public
00110  *  License version 2 as published by the Free Software Foundation.
00111  *
00112  *  This library is distributed in the hope that it will be useful,
00113  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00114  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00115  *  Library General Public License for more details.
00116  *
00117  *  You should have received a copy of the GNU Library General Public License
00118  *  along with this library; see the file COPYING.LIB.  If not, write to
00119  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00120  *  Boston, MA 02110-1301, USA.
00121  **/
00122 
00123 #define YYSTYPE QStringList
00124 #define YYPARSE_PARAM ppdloader
00125 #define YYDEBUG 1
00126 #define YYERROR_VERBOSE 1
00127 #include <stdlib.h>
00128 #include <qstringlist.h>
00129 
00130 #include "ppdloader.h"
00131 
00132 #define builder static_cast<PPDLoader*>( ppdloader )
00133 
00134 int kdeprint_ppdlex();
00135 #define kdeprint_ppderror(msg) static_cast<PPDLoader*>( ppdloader )->setErrorMsg( msg )
00136 
00137 
00138 /* Enabling traces.  */
00139 #ifndef YYDEBUG
00140 # define YYDEBUG 0
00141 #endif
00142 
00143 /* Enabling verbose error messages.  */
00144 #ifdef YYERROR_VERBOSE
00145 # undef YYERROR_VERBOSE
00146 # define YYERROR_VERBOSE 1
00147 #else
00148 # define YYERROR_VERBOSE 0
00149 #endif
00150 
00151 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00152 typedef int YYSTYPE;
00153 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00154 # define YYSTYPE_IS_DECLARED 1
00155 # define YYSTYPE_IS_TRIVIAL 1
00156 #endif
00157 
00158 
00159 
00160 /* Copy the second part of user declarations.  */
00161 
00162 
00163 /* Line 214 of yacc.c.  */
00164 #line 164 "./ppdparser.cpp"
00165 
00166 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00167 
00168 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00169 
00170 # if YYSTACK_USE_ALLOCA
00171 #  define YYSTACK_ALLOC alloca
00172 # else
00173 #  ifndef YYSTACK_USE_ALLOCA
00174 #   if defined (alloca) || defined (_ALLOCA_H)
00175 #    define YYSTACK_ALLOC alloca
00176 #   else
00177 #    ifdef __GNUC__
00178 #     define YYSTACK_ALLOC __builtin_alloca
00179 #    endif
00180 #   endif
00181 #  endif
00182 # endif
00183 
00184 # ifdef YYSTACK_ALLOC
00185    /* Pacify GCC's `empty if-body' warning. */
00186 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00187 # else
00188 #  if defined (__STDC__) || defined (__cplusplus)
00189 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00190 #   define YYSIZE_T size_t
00191 #  endif
00192 #  define YYSTACK_ALLOC malloc
00193 #  define YYSTACK_FREE free
00194 # endif
00195 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
00196 
00197 
00198 #if (! defined (yyoverflow) \
00199      && (! defined (__cplusplus) \
00200      || (YYSTYPE_IS_TRIVIAL)))
00201 
00202 /* A type that is properly aligned for any stack member.  */
00203 union yyalloc
00204 {
00205   short yyss;
00206   YYSTYPE yyvs;
00207   };
00208 
00209 /* The size of the maximum gap between one aligned stack and the next.  */
00210 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00211 
00212 /* The size of an array large to enough to hold all stacks, each with
00213    N elements.  */
00214 # define YYSTACK_BYTES(N) \
00215      ((N) * (sizeof (short) + sizeof (YYSTYPE))             \
00216       + YYSTACK_GAP_MAXIMUM)
00217 
00218 /* Copy COUNT objects from FROM to TO.  The source and destination do
00219    not overlap.  */
00220 # ifndef YYCOPY
00221 #  if 1 < __GNUC__
00222 #   define YYCOPY(To, From, Count) \
00223       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00224 #  else
00225 #   define YYCOPY(To, From, Count)      \
00226       do                    \
00227     {                   \
00228       register YYSIZE_T yyi;        \
00229       for (yyi = 0; yyi < (Count); yyi++)   \
00230         (To)[yyi] = (From)[yyi];        \
00231     }                   \
00232       while (0)
00233 #  endif
00234 # endif
00235 
00236 /* Relocate STACK from its old location to the new one.  The
00237    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00238    elements in the stack, and YYPTR gives the new location of the
00239    stack.  Advance YYPTR to a properly aligned location for the next
00240    stack.  */
00241 # define YYSTACK_RELOCATE(Stack)                    \
00242     do                                  \
00243       {                                 \
00244     YYSIZE_T yynewbytes;                        \
00245     YYCOPY (&yyptr->Stack, Stack, yysize);              \
00246     Stack = &yyptr->Stack;                      \
00247     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00248     yyptr += yynewbytes / sizeof (*yyptr);              \
00249       }                                 \
00250     while (0)
00251 
00252 #endif
00253 
00254 #if defined (__STDC__) || defined (__cplusplus)
00255    typedef signed char yysigned_char;
00256 #else
00257    typedef short yysigned_char;
00258 #endif
00259 
00260 /* YYFINAL -- State number of the termination state. */
00261 #define YYFINAL  33
00262 /* YYLAST -- Last index in YYTABLE.  */
00263 #define YYLAST   99
00264 
00265 /* YYNTOKENS -- Number of terminals. */
00266 #define YYNTOKENS  20
00267 /* YYNNTS -- Number of nonterminals. */
00268 #define YYNNTS  12
00269 /* YYNRULES -- Number of rules. */
00270 #define YYNRULES  41
00271 /* YYNRULES -- Number of states. */
00272 #define YYNSTATES  86
00273 
00274 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00275 #define YYUNDEFTOK  2
00276 #define YYMAXUTOK   272
00277 
00278 #define YYTRANSLATE(YYX)                        \
00279   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00280 
00281 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00282 static const unsigned char yytranslate[] =
00283 {
00284        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00285        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00286        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00287        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00288        2,     2,     2,     2,     2,     2,     2,    18,     2,     2,
00289        2,     2,     2,     2,     2,     2,     2,     2,    19,     2,
00290        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00291        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00292        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00293        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00294        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00295        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00296        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00297        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00298        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00299        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00300        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00301        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00302        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00303        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00304        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00305        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00306        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00307        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00308        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00309        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00310        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00311       15,    16,    17
00312 };
00313 
00314 #if YYDEBUG
00315 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00316    YYRHS.  */
00317 static const unsigned char yyprhs[] =
00318 {
00319        0,     0,     3,     5,     8,    10,    13,    16,    18,    20,
00320       24,    28,    33,    40,    45,    52,    57,    64,    68,    71,
00321       75,    81,    85,    91,    98,   104,   110,   115,   119,   124,
00322      131,   137,   141,   147,   149,   151,   153,   155,   157,   159,
00323      161,   163
00324 };
00325 
00326 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
00327 static const yysigned_char yyrhs[] =
00328 {
00329       21,     0,    -1,    31,    -1,    21,    31,    -1,    11,    -1,
00330       22,    11,    -1,    22,    12,    -1,    22,    -1,    12,    -1,
00331       12,    18,     3,    -1,    22,    18,     3,    -1,    14,    10,
00332       19,    12,    -1,    14,    10,    18,     3,    19,    12,    -1,
00333       15,    10,    19,    12,    -1,    15,    10,    18,     3,    19,
00334       12,    -1,     4,    10,    19,    22,    -1,     4,    10,    18,
00335        3,    19,    22,    -1,     5,    19,    22,    -1,     5,    22,
00336       -1,     6,    19,    22,    -1,     6,    19,    22,    18,     3,
00337       -1,     7,    19,    22,    -1,     7,    19,    22,    18,     3,
00338       -1,    13,    19,     9,    10,     9,    10,    -1,    13,    19,
00339        9,    10,     9,    -1,    13,    19,     9,     9,    10,    -1,
00340       13,    19,     9,     9,    -1,     9,    19,    23,    -1,     9,
00341       10,    19,    23,    -1,     9,    10,    18,     3,    19,    23,
00342       -1,     9,    10,    18,    19,    23,    -1,     8,    19,    22,
00343       -1,     8,    19,    22,    18,     3,    -1,    26,    -1,    27,
00344       -1,    28,    -1,    29,    -1,    24,    -1,    25,    -1,    30,
00345       -1,    17,    -1,    16,    -1
00346 };
00347 
00348 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00349 static const unsigned char yyrline[] =
00350 {
00351        0,    54,    54,    55,    58,    59,    60,    63,    64,    65,
00352       66,    69,    70,    73,    74,    77,    78,    81,    82,    85,
00353       86,    89,    90,    93,    94,    95,    96,    99,   100,   101,
00354      102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
00355      112,   113
00356 };
00357 #endif
00358 
00359 #if YYDEBUG || YYERROR_VERBOSE
00360 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00361    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
00362 static const char *const yytname[] =
00363 {
00364   "$end", "error", "$undefined", "TRANSLATION", "OPENUI", "CLOSEUI", 
00365   "OPENGROUP", "CLOSEGROUP", "DEFAULT", "KEYWORD", "OPTION", "STRINGPART", 
00366   "QUOTED", "CONSTRAINT", "PAPERDIM", "IMGAREA", "FOODATA", "COMMENT", 
00367   "'/'", "':'", "$accept", "ppdfile", "string", "value", "paperdim", 
00368   "imgarea", "openui", "endui", "opengroup", "endgroup", "constraint", 
00369   "ppdelement", 0
00370 };
00371 #endif
00372 
00373 # ifdef YYPRINT
00374 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00375    token YYLEX-NUM.  */
00376 static const unsigned short yytoknum[] =
00377 {
00378        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00379      265,   266,   267,   268,   269,   270,   271,   272,    47,    58
00380 };
00381 # endif
00382 
00383 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00384 static const unsigned char yyr1[] =
00385 {
00386        0,    20,    21,    21,    22,    22,    22,    23,    23,    23,
00387       23,    24,    24,    25,    25,    26,    26,    27,    27,    28,
00388       28,    29,    29,    30,    30,    30,    30,    31,    31,    31,
00389       31,    31,    31,    31,    31,    31,    31,    31,    31,    31,
00390       31,    31
00391 };
00392 
00393 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00394 static const unsigned char yyr2[] =
00395 {
00396        0,     2,     1,     2,     1,     2,     2,     1,     1,     3,
00397        3,     4,     6,     4,     6,     4,     6,     3,     2,     3,
00398        5,     3,     5,     6,     5,     5,     4,     3,     4,     6,
00399        5,     3,     5,     1,     1,     1,     1,     1,     1,     1,
00400        1,     1
00401 };
00402 
00403 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00404    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00405    means the default is an error.  */
00406 static const unsigned char yydefact[] =
00407 {
00408        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00409       41,    40,     0,    37,    38,    33,    34,    35,    36,    39,
00410        2,     0,     4,     0,    18,     0,     0,     0,     0,     0,
00411        0,     0,     0,     1,     3,     0,     0,    17,     5,     6,
00412       19,    21,    31,     0,     0,     8,     7,    27,     0,     0,
00413        0,     0,     0,     0,    15,     0,     0,     0,     0,     0,
00414       28,     0,     0,    26,     0,     0,    11,     0,    13,     0,
00415       20,    22,    32,     0,    30,     9,    10,    25,    24,     0,
00416        0,    16,    29,    23,    12,    14
00417 };
00418 
00419 /* YYDEFGOTO[NTERM-NUM]. */
00420 static const yysigned_char yydefgoto[] =
00421 {
00422       -1,    12,    46,    47,    13,    14,    15,    16,    17,    18,
00423       19,    20
00424 };
00425 
00426 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00427    STATE-NUM.  */
00428 #define YYPACT_NINF -44
00429 static const yysigned_char yypact[] =
00430 {
00431       45,     1,    -6,   -15,   -13,     3,    -7,    10,     5,     7,
00432      -44,   -44,    31,   -44,   -44,   -44,   -44,   -44,   -44,   -44,
00433      -44,    -9,   -44,    32,    16,    32,    32,    32,    14,    30,
00434       48,    37,    50,   -44,   -44,    68,    32,    16,   -44,   -44,
00435       -4,     8,    52,    -1,    30,    57,    54,   -44,    64,    73,
00436       65,    75,    67,    61,    16,    78,    79,    80,    66,    30,
00437      -44,    81,    83,    77,    82,    69,   -44,    70,   -44,    32,
00438      -44,   -44,   -44,    30,   -44,   -44,   -44,   -44,    84,    85,
00439       86,    16,   -44,   -44,   -44,   -44
00440 };
00441 
00442 /* YYPGOTO[NTERM-NUM].  */
00443 static const yysigned_char yypgoto[] =
00444 {
00445      -44,   -44,    -2,   -43,   -44,   -44,   -44,   -44,   -44,   -44,
00446      -44,    87
00447 };
00448 
00449 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00450    positive, shift that token.  If negative, reduce the rule which
00451    number is the opposite.  If zero, do what YYDEFACT says.
00452    If YYTABLE_NINF, syntax error.  */
00453 #define YYTABLE_NINF -1
00454 static const unsigned char yytable[] =
00455 {
00456       24,    60,    58,    28,    25,    22,    26,    38,    39,    35,
00457       36,    21,    29,    23,    55,    31,    74,    32,    59,    38,
00458       39,    37,    27,    40,    41,    42,    56,    38,    39,    30,
00459       82,    33,    43,    44,    54,     1,     2,     3,     4,     5,
00460        6,    22,    45,    22,     7,     8,     9,    10,    11,     1,
00461        2,     3,     4,     5,     6,    49,    50,    48,     7,     8,
00462        9,    10,    11,    38,    39,    38,    39,    81,    51,    52,
00463       57,    53,    62,    63,    64,    61,    65,    66,    67,    68,
00464       69,    70,    71,    72,    75,    73,    76,    77,    79,    80,
00465        0,    78,     0,     0,    83,     0,     0,    84,    85,    34
00466 };
00467 
00468 static const yysigned_char yycheck[] =
00469 {
00470        2,    44,     3,    10,    19,    11,    19,    11,    12,    18,
00471       19,    10,    19,    19,    18,    10,    59,    10,    19,    11,
00472       12,    23,    19,    25,    26,    27,    18,    11,    12,    19,
00473       73,     0,    18,    19,    36,     4,     5,     6,     7,     8,
00474        9,    11,    12,    11,    13,    14,    15,    16,    17,     4,
00475        5,     6,     7,     8,     9,    18,    19,     9,    13,    14,
00476       15,    16,    17,    11,    12,    11,    12,    69,    18,    19,
00477       18,     3,    18,     9,    10,    18,     3,    12,     3,    12,
00478       19,     3,     3,     3,     3,    19,     3,    10,    19,    19,
00479       -1,     9,    -1,    -1,    10,    -1,    -1,    12,    12,    12
00480 };
00481 
00482 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00483    symbol of state STATE-NUM.  */
00484 static const unsigned char yystos[] =
00485 {
00486        0,     4,     5,     6,     7,     8,     9,    13,    14,    15,
00487       16,    17,    21,    24,    25,    26,    27,    28,    29,    30,
00488       31,    10,    11,    19,    22,    19,    19,    19,    10,    19,
00489       19,    10,    10,     0,    31,    18,    19,    22,    11,    12,
00490       22,    22,    22,    18,    19,    12,    22,    23,     9,    18,
00491       19,    18,    19,     3,    22,    18,    18,    18,     3,    19,
00492       23,    18,    18,     9,    10,     3,    12,     3,    12,    19,
00493        3,     3,     3,    19,    23,     3,     3,    10,     9,    19,
00494       19,    22,    23,    10,    12,    12
00495 };
00496 
00497 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00498 # define YYSIZE_T __SIZE_TYPE__
00499 #endif
00500 #if ! defined (YYSIZE_T) && defined (size_t)
00501 # define YYSIZE_T size_t
00502 #endif
00503 #if ! defined (YYSIZE_T)
00504 # if defined (__STDC__) || defined (__cplusplus)
00505 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00506 #  define YYSIZE_T size_t
00507 # endif
00508 #endif
00509 #if ! defined (YYSIZE_T)
00510 # define YYSIZE_T unsigned int
00511 #endif
00512 
00513 #define yyerrok     (yyerrstatus = 0)
00514 #define yyclearin   (yychar = YYEMPTY)
00515 #define YYEMPTY     (-2)
00516 #define YYEOF       0
00517 
00518 #define YYACCEPT    goto yyacceptlab
00519 #define YYABORT     goto yyabortlab
00520 #define YYERROR     goto yyerrlab1
00521 
00522 
00523 /* Like YYERROR except do call yyerror.  This remains here temporarily
00524    to ease the transition to the new meaning of YYERROR, for GCC.
00525    Once GCC version 2 has supplanted version 1, this can go.  */
00526 
00527 #define YYFAIL      goto yyerrlab
00528 
00529 #define YYRECOVERING()  (!!yyerrstatus)
00530 
00531 #define YYBACKUP(Token, Value)                  \
00532 do                              \
00533   if (yychar == YYEMPTY && yylen == 1)              \
00534     {                               \
00535       yychar = (Token);                     \
00536       yylval = (Value);                     \
00537       yytoken = YYTRANSLATE (yychar);               \
00538       YYPOPSTACK;                       \
00539       goto yybackup;                        \
00540     }                               \
00541   else                              \
00542     {                               \
00543       yyerror ("syntax error: cannot back up");\
00544       YYERROR;                          \
00545     }                               \
00546 while (0)
00547 
00548 #define YYTERROR    1
00549 #define YYERRCODE   256
00550 
00551 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
00552    are run).  */
00553 
00554 #ifndef YYLLOC_DEFAULT
00555 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
00556   Current.first_line   = Rhs[1].first_line;      \
00557   Current.first_column = Rhs[1].first_column;    \
00558   Current.last_line    = Rhs[N].last_line;       \
00559   Current.last_column  = Rhs[N].last_column;
00560 #endif
00561 
00562 /* YYLEX -- calling `yylex' with the right arguments.  */
00563 
00564 #ifdef YYLEX_PARAM
00565 # define YYLEX yylex (YYLEX_PARAM)
00566 #else
00567 # define YYLEX yylex ()
00568 #endif
00569 
00570 /* Enable debugging if requested.  */
00571 #if YYDEBUG
00572 
00573 # ifndef YYFPRINTF
00574 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00575 #  define YYFPRINTF fprintf
00576 # endif
00577 
00578 # define YYDPRINTF(Args)            \
00579 do {                        \
00580   if (yydebug)                  \
00581     YYFPRINTF Args;             \
00582 } while (0)
00583 
00584 # define YYDSYMPRINT(Args)          \
00585 do {                        \
00586   if (yydebug)                  \
00587     yysymprint Args;                \
00588 } while (0)
00589 
00590 # define YYDSYMPRINTF(Title, Token, Value, Location)        \
00591 do {                                \
00592   if (yydebug)                          \
00593     {                               \
00594       YYFPRINTF (stderr, "%s ", Title);             \
00595       yysymprint (stderr,                   \
00596                   Token, Value);    \
00597       YYFPRINTF (stderr, "\n");                 \
00598     }                               \
00599 } while (0)
00600 
00601 /*------------------------------------------------------------------.
00602 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
00603 | TOP (cinluded).                                                   |
00604 `------------------------------------------------------------------*/
00605 
00606 #if defined (__STDC__) || defined (__cplusplus)
00607 static void
00608 yy_stack_print (short *bottom, short *top)
00609 #else
00610 static void
00611 yy_stack_print (bottom, top)
00612     short *bottom;
00613     short *top;
00614 #endif
00615 {
00616   YYFPRINTF (stderr, "Stack now");
00617   for (/* Nothing. */; bottom <= top; ++bottom)
00618     YYFPRINTF (stderr, " %d", *bottom);
00619   YYFPRINTF (stderr, "\n");
00620 }
00621 
00622 # define YY_STACK_PRINT(Bottom, Top)                \
00623 do {                                \
00624   if (yydebug)                          \
00625     yy_stack_print ((Bottom), (Top));               \
00626 } while (0)
00627 
00628 
00629 /*------------------------------------------------.
00630 | Report that the YYRULE is going to be reduced.  |
00631 `------------------------------------------------*/
00632 
00633 #if defined (__STDC__) || defined (__cplusplus)
00634 static void
00635 yy_reduce_print (int yyrule)
00636 #else
00637 static void
00638 yy_reduce_print (yyrule)
00639     int yyrule;
00640 #endif
00641 {
00642   int yyi;
00643   unsigned int yylineno = yyrline[yyrule];
00644   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
00645              yyrule - 1, yylineno);
00646   /* Print the symbols being reduced, and their result.  */
00647   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
00648     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
00649   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
00650 }
00651 
00652 # define YY_REDUCE_PRINT(Rule)      \
00653 do {                    \
00654   if (yydebug)              \
00655     yy_reduce_print (Rule);     \
00656 } while (0)
00657 
00658 /* Nonzero means print parse trace.  It is left uninitialized so that
00659    multiple parsers can coexist.  */
00660 int yydebug;
00661 #else /* !YYDEBUG */
00662 # define YYDPRINTF(Args)
00663 # define YYDSYMPRINT(Args)
00664 # define YYDSYMPRINTF(Title, Token, Value, Location)
00665 # define YY_STACK_PRINT(Bottom, Top)
00666 # define YY_REDUCE_PRINT(Rule)
00667 #endif /* !YYDEBUG */
00668 
00669 
00670 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00671 #ifndef YYINITDEPTH
00672 # define YYINITDEPTH 200
00673 #endif
00674 
00675 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00676    if the built-in stack extension method is used).
00677 
00678    Do not make this value too large; the results are undefined if
00679    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
00680    evaluated with infinite-precision integer arithmetic.  */
00681 
00682 #if YYMAXDEPTH == 0
00683 # undef YYMAXDEPTH
00684 #endif
00685 
00686 #ifndef YYMAXDEPTH
00687 # define YYMAXDEPTH 10000
00688 #endif
00689 
00690 
00691 
00692 #if YYERROR_VERBOSE
00693 
00694 # ifndef yystrlen
00695 #  if defined (__GLIBC__) && defined (_STRING_H)
00696 #   define yystrlen strlen
00697 #  else
00698 /* Return the length of YYSTR.  */
00699 static YYSIZE_T
00700 #   if defined (__STDC__) || defined (__cplusplus)
00701 yystrlen (const char *yystr)
00702 #   else
00703 yystrlen (yystr)
00704      const char *yystr;
00705 #   endif
00706 {
00707   register const char *yys = yystr;
00708 
00709   while (*yys++ != '\0')
00710     continue;
00711 
00712   return yys - yystr - 1;
00713 }
00714 #  endif
00715 # endif
00716 
00717 # ifndef yystpcpy
00718 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00719 #   define yystpcpy stpcpy
00720 #  else
00721 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
00722    YYDEST.  */
00723 static char *
00724 #   if defined (__STDC__) || defined (__cplusplus)
00725 yystpcpy (char *yydest, const char *yysrc)
00726 #   else
00727 yystpcpy (yydest, yysrc)
00728      char *yydest;
00729      const char *yysrc;
00730 #   endif
00731 {
00732   register char *yyd = yydest;
00733   register const char *yys = yysrc;
00734 
00735   while ((*yyd++ = *yys++) != '\0')
00736     continue;
00737 
00738   return yyd - 1;
00739 }
00740 #  endif
00741 # endif
00742 
00743 #endif /* !YYERROR_VERBOSE */
00744 
00745 
00746 
00747 #if YYDEBUG
00748 /*--------------------------------.
00749 | Print this symbol on YYOUTPUT.  |
00750 `--------------------------------*/
00751 
00752 #if defined (__STDC__) || defined (__cplusplus)
00753 static void
00754 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
00755 #else
00756 static void
00757 yysymprint (yyoutput, yytype, yyvaluep)
00758     FILE *yyoutput;
00759     int yytype;
00760     YYSTYPE *yyvaluep;
00761 #endif
00762 {
00763   /* Pacify ``unused variable'' warnings.  */
00764   (void) yyvaluep;
00765 
00766   if (yytype < YYNTOKENS)
00767     {
00768       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00769 # ifdef YYPRINT
00770       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00771 # endif
00772     }
00773   else
00774     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00775 
00776   switch (yytype)
00777     {
00778       default:
00779         break;
00780     }
00781   YYFPRINTF (yyoutput, ")");
00782 }
00783 
00784 #endif /* ! YYDEBUG */
00785 /*-----------------------------------------------.
00786 | Release the memory associated to this symbol.  |
00787 `-----------------------------------------------*/
00788 
00789 #if defined (__STDC__) || defined (__cplusplus)
00790 static void
00791 yydestruct (int yytype, YYSTYPE *yyvaluep)
00792 #else
00793 static void
00794 yydestruct (yytype, yyvaluep)
00795     int yytype;
00796     YYSTYPE *yyvaluep;
00797 #endif
00798 {
00799   /* Pacify ``unused variable'' warnings.  */
00800   (void) yyvaluep;
00801 
00802   switch (yytype)
00803     {
00804 
00805       default:
00806         break;
00807     }
00808 }
00809 
00810 
00811 /* Prevent warnings from -Wmissing-prototypes.  */
00812 
00813 #ifdef YYPARSE_PARAM
00814 # if defined (__STDC__) || defined (__cplusplus)
00815 int yyparse (void *YYPARSE_PARAM);
00816 # else
00817 int yyparse ();
00818 # endif
00819 #else /* ! YYPARSE_PARAM */
00820 #if defined (__STDC__) || defined (__cplusplus)
00821 int yyparse (void);
00822 #else
00823 int yyparse ();
00824 #endif
00825 #endif /* ! YYPARSE_PARAM */
00826 
00827 
00828 
00829 /* The lookahead symbol.  */
00830 int yychar;
00831 
00832 /* The semantic value of the lookahead symbol.  */
00833 YYSTYPE yylval;
00834 
00835 /* Number of syntax errors so far.  */
00836 int yynerrs;
00837 
00838 
00839 
00840 /*----------.
00841 | yyparse.  |
00842 `----------*/
00843 
00844 #ifdef YYPARSE_PARAM
00845 # if defined (__STDC__) || defined (__cplusplus)
00846 int yyparse (void *YYPARSE_PARAM)
00847 # else
00848 int yyparse (YYPARSE_PARAM)
00849   void *YYPARSE_PARAM;
00850 # endif
00851 #else /* ! YYPARSE_PARAM */
00852 #if defined (__STDC__) || defined (__cplusplus)
00853 int
00854 yyparse (void)
00855 #else
00856 int
00857 yyparse ()
00858 
00859 #endif
00860 #endif
00861 {
00862   
00863   register int yystate;
00864   register int yyn;
00865   int yyresult;
00866   /* Number of tokens to shift before error messages enabled.  */
00867   int yyerrstatus;
00868   /* Lookahead token as an internal (translated) token number.  */
00869   int yytoken = 0;
00870 
00871   /* Three stacks and their tools:
00872      `yyss': related to states,
00873      `yyvs': related to semantic values,
00874      `yyls': related to locations.
00875 
00876      Refer to the stacks thru separate pointers, to allow yyoverflow
00877      to reallocate them elsewhere.  */
00878 
00879   /* The state stack.  */
00880   short yyssa[YYINITDEPTH];
00881   short *yyss = yyssa;
00882   register short *yyssp;
00883 
00884   /* The semantic value stack.  */
00885   YYSTYPE yyvsa[YYINITDEPTH];
00886   YYSTYPE *yyvs = yyvsa;
00887   register YYSTYPE *yyvsp;
00888 
00889 
00890 
00891 #define YYPOPSTACK   (yyvsp--, yyssp--)
00892 
00893   YYSIZE_T yystacksize = YYINITDEPTH;
00894 
00895   /* The variables used to return semantic value and location from the
00896      action routines.  */
00897   YYSTYPE yyval;
00898 
00899 
00900   /* When reducing, the number of symbols on the RHS of the reduced
00901      rule.  */
00902   int yylen;
00903 
00904   YYDPRINTF ((stderr, "Starting parse\n"));
00905 
00906   yystate = 0;
00907   yyerrstatus = 0;
00908   yynerrs = 0;
00909   yychar = YYEMPTY;     /* Cause a token to be read.  */
00910 
00911   /* Initialize stack pointers.
00912      Waste one element of value and location stack
00913      so that they stay on the same level as the state stack.
00914      The wasted elements are never initialized.  */
00915 
00916   yyssp = yyss;
00917   yyvsp = yyvs;
00918 
00919   goto yysetstate;
00920 
00921 /*------------------------------------------------------------.
00922 | yynewstate -- Push a new state, which is found in yystate.  |
00923 `------------------------------------------------------------*/
00924  yynewstate:
00925   /* In all cases, when you get here, the value and location stacks
00926      have just been pushed. so pushing a state here evens the stacks.
00927      */
00928   yyssp++;
00929 
00930  yysetstate:
00931   *yyssp = yystate;
00932 
00933   if (yyss + yystacksize - 1 <= yyssp)
00934     {
00935       /* Get the current used size of the three stacks, in elements.  */
00936       YYSIZE_T yysize = yyssp - yyss + 1;
00937 
00938 #ifdef yyoverflow
00939       {
00940     /* Give user a chance to reallocate the stack. Use copies of
00941        these so that the &'s don't force the real ones into
00942        memory.  */
00943     YYSTYPE *yyvs1 = yyvs;
00944     short *yyss1 = yyss;
00945 
00946 
00947     /* Each stack pointer address is followed by the size of the
00948        data in use in that stack, in bytes.  This used to be a
00949        conditional around just the two extra args, but that might
00950        be undefined if yyoverflow is a macro.  */
00951     yyoverflow ("parser stack overflow",
00952             &yyss1, yysize * sizeof (*yyssp),
00953             &yyvs1, yysize * sizeof (*yyvsp),
00954 
00955             &yystacksize);
00956 
00957     yyss = yyss1;
00958     yyvs = yyvs1;
00959       }
00960 #else /* no yyoverflow */
00961 # ifndef YYSTACK_RELOCATE
00962       goto yyoverflowlab;
00963 # else
00964       /* Extend the stack our own way.  */
00965       if (YYMAXDEPTH <= yystacksize)
00966     goto yyoverflowlab;
00967       yystacksize *= 2;
00968       if (YYMAXDEPTH < yystacksize)
00969     yystacksize = YYMAXDEPTH;
00970 
00971       {
00972     short *yyss1 = yyss;
00973     union yyalloc *yyptr =
00974       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
00975     if (! yyptr)
00976       goto yyoverflowlab;
00977     YYSTACK_RELOCATE (yyss);
00978     YYSTACK_RELOCATE (yyvs);
00979 
00980 #  undef YYSTACK_RELOCATE
00981     if (yyss1 != yyssa)
00982       YYSTACK_FREE (yyss1);
00983       }
00984 # endif
00985 #endif /* no yyoverflow */
00986 
00987       yyssp = yyss + yysize - 1;
00988       yyvsp = yyvs + yysize - 1;
00989 
00990 
00991       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
00992           (unsigned long int) yystacksize));
00993 
00994       if (yyss + yystacksize - 1 <= yyssp)
00995     YYABORT;
00996     }
00997 
00998   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
00999 
01000   goto yybackup;
01001 
01002 /*-----------.
01003 | yybackup.  |
01004 `-----------*/
01005 yybackup:
01006 
01007 /* Do appropriate processing given the current state.  */
01008 /* Read a lookahead token if we need one and don't already have one.  */
01009 /* yyresume: */
01010 
01011   /* First try to decide what to do without reference to lookahead token.  */
01012 
01013   yyn = yypact[yystate];
01014   if (yyn == YYPACT_NINF)
01015     goto yydefault;
01016 
01017   /* Not known => get a lookahead token if don't already have one.  */
01018 
01019   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01020   if (yychar == YYEMPTY)
01021     {
01022       YYDPRINTF ((stderr, "Reading a token: "));
01023       yychar = YYLEX;
01024     }
01025 
01026   if (yychar <= YYEOF)
01027     {
01028       yychar = yytoken = YYEOF;
01029       YYDPRINTF ((stderr, "Now at end of input.\n"));
01030     }
01031   else
01032     {
01033       yytoken = YYTRANSLATE (yychar);
01034       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
01035     }
01036 
01037   /* If the proper action on seeing token YYTOKEN is to reduce or to
01038      detect an error, take that action.  */
01039   yyn += yytoken;
01040   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01041     goto yydefault;
01042   yyn = yytable[yyn];
01043   if (yyn <= 0)
01044     {
01045       if (yyn == 0 || yyn == YYTABLE_NINF)
01046     goto yyerrlab;
01047       yyn = -yyn;
01048       goto yyreduce;
01049     }
01050 
01051   if (yyn == YYFINAL)
01052     YYACCEPT;
01053 
01054   /* Shift the lookahead token.  */
01055   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
01056 
01057   /* Discard the token being shifted unless it is eof.  */
01058   if (yychar != YYEOF)
01059     yychar = YYEMPTY;
01060 
01061   *++yyvsp = yylval;
01062 
01063 
01064   /* Count tokens shifted since error; after three, turn off error
01065      status.  */
01066   if (yyerrstatus)
01067     yyerrstatus--;
01068 
01069   yystate = yyn;
01070   goto yynewstate;
01071 
01072 
01073 /*-----------------------------------------------------------.
01074 | yydefault -- do the default action for the current state.  |
01075 `-----------------------------------------------------------*/
01076 yydefault:
01077   yyn = yydefact[yystate];
01078   if (yyn == 0)
01079     goto yyerrlab;
01080   goto yyreduce;
01081 
01082 
01083 /*-----------------------------.
01084 | yyreduce -- Do a reduction.  |
01085 `-----------------------------*/
01086 yyreduce:
01087   /* yyn is the number of a rule to reduce with.  */
01088   yylen = yyr2[yyn];
01089 
01090   /* If YYLEN is nonzero, implement the default value of the action:
01091      `$$ = $1'.
01092 
01093      Otherwise, the following line sets YYVAL to garbage.
01094      This behavior is undocumented and Bison
01095      users should not rely upon it.  Assigning to YYVAL
01096      unconditionally makes the parser a bit smaller, and it avoids a
01097      GCC warning that YYVAL may be used uninitialized.  */
01098   yyval = yyvsp[1-yylen];
01099 
01100 
01101   YY_REDUCE_PRINT (yyn);
01102   switch (yyn)
01103     {
01104         case 4:
01105 #line 58 "./ppdparser.y"
01106     { yyval = yyvsp[0]; ;}
01107     break;
01108 
01109   case 5:
01110 #line 59 "./ppdparser.y"
01111     { yyvsp[-1] += yyvsp[0]; yyval = yyvsp[-1]; ;}
01112     break;
01113 
01114   case 6:
01115 #line 60 "./ppdparser.y"
01116     { yyvsp[-1] += yyvsp[0]; yyval = yyvsp[-1]; ;}
01117     break;
01118 
01119   case 7:
01120 #line 63 "./ppdparser.y"
01121     { yyval = yyvsp[0]; ;}
01122     break;
01123 
01124   case 8:
01125 #line 64 "./ppdparser.y"
01126     { yyval = yyvsp[0][0].mid(1,yyvsp[0][0].length()-2); ;}
01127     break;
01128 
01129   case 9:
01130 #line 65 "./ppdparser.y"
01131     { yyval = yyvsp[-2][0].mid(1,yyvsp[-2][0].length()-2); ;}
01132     break;
01133 
01134   case 10:
01135 #line 66 "./ppdparser.y"
01136     { yyval = yyvsp[-2]; ;}
01137     break;
01138 
01139   case 11:
01140 #line 69 "./ppdparser.y"
01141     { builder->putPaperDimension(yyvsp[-2][0], yyvsp[0][0]); ;}
01142     break;
01143 
01144   case 12:
01145 #line 70 "./ppdparser.y"
01146     { builder->putPaperDimension(yyvsp[-4][0], yyvsp[0][0]); ;}
01147     break;
01148 
01149   case 13:
01150 #line 73 "./ppdparser.y"
01151     { builder->putImageableArea(yyvsp[-2][0], yyvsp[0][0]); ;}
01152     break;
01153 
01154   case 14:
01155 #line 74 "./ppdparser.y"
01156     { builder->putImageableArea(yyvsp[-4][0], yyvsp[0][0]); ;}
01157     break;
01158 
01159   case 15:
01160 #line 77 "./ppdparser.y"
01161     { builder->openUi(yyvsp[-2][0], QString::null, yyvsp[0][0]); ;}
01162     break;
01163 
01164   case 16:
01165 #line 78 "./ppdparser.y"
01166     { builder->openUi(yyvsp[-4][0], yyvsp[-2][0], yyvsp[0][0]); ;}
01167     break;
01168 
01169   case 17:
01170 #line 81 "./ppdparser.y"
01171     { builder->endUi(yyvsp[0][0]); ;}
01172     break;
01173 
01174   case 18:
01175 #line 82 "./ppdparser.y"
01176     { builder->endUi(yyvsp[0][0]); ;}
01177     break;
01178 
01179   case 19:
01180 #line 85 "./ppdparser.y"
01181     { builder->openGroup(yyvsp[0].join(" "), QString::null); ;}
01182     break;
01183 
01184   case 20:
01185 #line 86 "./ppdparser.y"
01186     { builder->openGroup(yyvsp[-2].join(" "), yyvsp[0][0]); ;}
01187     break;
01188 
01189   case 21:
01190 #line 89 "./ppdparser.y"
01191     { builder->endGroup(yyvsp[0].join(" ")); ;}
01192     break;
01193 
01194   case 22:
01195 #line 90 "./ppdparser.y"
01196     { builder->endGroup(yyvsp[-2].join(" ")); ;}
01197     break;
01198 
01199   case 23:
01200 #line 93 "./ppdparser.y"
01201     { builder->putConstraint(yyvsp[-3][0], yyvsp[-1][0], yyvsp[-2][0], yyvsp[0][0]); ;}
01202     break;
01203 
01204   case 24:
01205 #line 94 "./ppdparser.y"
01206     { builder->putConstraint(yyvsp[-2][0], yyvsp[0][0], yyvsp[-1][0], QString::null); ;}
01207     break;
01208 
01209   case 25:
01210 #line 95 "./ppdparser.y"
01211     { builder->putConstraint(yyvsp[-2][0], yyvsp[-1][0], QString::null, yyvsp[0][0]); ;}
01212     break;
01213 
01214   case 26:
01215 #line 96 "./ppdparser.y"
01216     { builder->putConstraint(yyvsp[-1][0], yyvsp[0][0], QString::null, QString::null); ;}
01217     break;
01218 
01219   case 27:
01220 #line 99 "./ppdparser.y"
01221     { builder->putStatement2(yyvsp[-2][0], yyvsp[0][0]); ;}
01222     break;
01223 
01224   case 28:
01225 #line 100 "./ppdparser.y"
01226     { builder->putStatement(yyvsp[-3][0], yyvsp[-2][0], QString::null, yyvsp[0]); ;}
01227     break;
01228 
01229   case 29:
01230 #line 101 "./ppdparser.y"
01231     { builder->putStatement(yyvsp[-5][0], yyvsp[-4][0], yyvsp[-2][0], yyvsp[0]); ;}
01232     break;
01233 
01234   case 30:
01235 #line 102 "./ppdparser.y"
01236     { builder->putStatement(yyvsp[-4][0], yyvsp[-3][0], QString::null, yyvsp[-1]); ;}
01237     break;
01238 
01239   case 31:
01240 #line 103 "./ppdparser.y"
01241     { builder->putDefault(yyvsp[-2][0], yyvsp[0][0]); ;}
01242     break;
01243 
01244   case 32:
01245 #line 104 "./ppdparser.y"
01246     { builder->putDefault(yyvsp[-4][0], yyvsp[-2][0]); ;}
01247     break;
01248 
01249   case 41:
01250 #line 113 "./ppdparser.y"
01251     { builder->putFooData(yyvsp[0][0]); ;}
01252     break;
01253 
01254 
01255     }
01256 
01257 /* Line 999 of yacc.c.  */
01258 #line 1258 "./ppdparser.cpp"
01259 
01260   yyvsp -= yylen;
01261   yyssp -= yylen;
01262 
01263 
01264   YY_STACK_PRINT (yyss, yyssp);
01265 
01266   *++yyvsp = yyval;
01267 
01268 
01269   /* Now `shift' the result of the reduction.  Determine what state
01270      that goes to, based on the state we popped back to and the rule
01271      number reduced by.  */
01272 
01273   yyn = yyr1[yyn];
01274 
01275   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01276   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01277     yystate = yytable[yystate];
01278   else
01279     yystate = yydefgoto[yyn - YYNTOKENS];
01280 
01281   goto yynewstate;
01282 
01283 
01284 /*------------------------------------.
01285 | yyerrlab -- here on detecting error |
01286 `------------------------------------*/
01287 yyerrlab:
01288   /* If not already recovering from an error, report this error.  */
01289   if (!yyerrstatus)
01290     {
01291       ++yynerrs;
01292 #if YYERROR_VERBOSE
01293       yyn = yypact[yystate];
01294 
01295       if (YYPACT_NINF < yyn && yyn < YYLAST)
01296     {
01297       YYSIZE_T yysize = 0;
01298       int yytype = YYTRANSLATE (yychar);
01299       char *yymsg;
01300       int yyx, yycount;
01301 
01302       yycount = 0;
01303       /* Start YYX at -YYN if negative to avoid negative indexes in
01304          YYCHECK.  */
01305       for (yyx = yyn < 0 ? -yyn : 0;
01306            yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
01307         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01308           yysize += yystrlen (yytname[yyx]) + 15, yycount++;
01309       yysize += yystrlen ("syntax error, unexpected ") + 1;
01310       yysize += yystrlen (yytname[yytype]);
01311       yymsg = (char *) YYSTACK_ALLOC (yysize);
01312       if (yymsg != 0)
01313         {
01314           char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
01315           yyp = yystpcpy (yyp, yytname[yytype]);
01316 
01317           if (yycount < 5)
01318         {
01319           yycount = 0;
01320           for (yyx = yyn < 0 ? -yyn : 0;
01321                yyx < (int) (sizeof (yytname) / sizeof (char *));
01322                yyx++)
01323             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01324               {
01325             const char *yyq = ! yycount ? ", expecting " : " or ";
01326             yyp = yystpcpy (yyp, yyq);
01327             yyp = yystpcpy (yyp, yytname[yyx]);
01328             yycount++;
01329               }
01330         }
01331           yyerror (yymsg);
01332           YYSTACK_FREE (yymsg);
01333         }
01334       else
01335         yyerror ("syntax error; also virtual memory exhausted");
01336     }
01337       else
01338 #endif /* YYERROR_VERBOSE */
01339     yyerror ("syntax error");
01340     }
01341 
01342 
01343 
01344   if (yyerrstatus == 3)
01345     {
01346       /* If just tried and failed to reuse lookahead token after an
01347      error, discard it.  */
01348 
01349       /* Return failure if at end of input.  */
01350       if (yychar == YYEOF)
01351         {
01352       /* Pop the error token.  */
01353           YYPOPSTACK;
01354       /* Pop the rest of the stack.  */
01355       while (yyss < yyssp)
01356         {
01357           YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
01358           yydestruct (yystos[*yyssp], yyvsp);
01359           YYPOPSTACK;
01360         }
01361       YYABORT;
01362         }
01363 
01364       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
01365       yydestruct (yytoken, &yylval);
01366       yychar = YYEMPTY;
01367 
01368     }
01369 
01370   /* Else will try to reuse lookahead token after shifting the error
01371      token.  */
01372   goto yyerrlab1;
01373 
01374 
01375 /*----------------------------------------------------.
01376 | yyerrlab1 -- error raised explicitly by an action.  |
01377 `----------------------------------------------------*/
01378 yyerrlab1:
01379   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
01380 
01381   for (;;)
01382     {
01383       yyn = yypact[yystate];
01384       if (yyn != YYPACT_NINF)
01385     {
01386       yyn += YYTERROR;
01387       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01388         {
01389           yyn = yytable[yyn];
01390           if (0 < yyn)
01391         break;
01392         }
01393     }
01394 
01395       /* Pop the current state because it cannot handle the error token.  */
01396       if (yyssp == yyss)
01397     YYABORT;
01398 
01399       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
01400       yydestruct (yystos[yystate], yyvsp);
01401       yyvsp--;
01402       yystate = *--yyssp;
01403 
01404       YY_STACK_PRINT (yyss, yyssp);
01405     }
01406 
01407   if (yyn == YYFINAL)
01408     YYACCEPT;
01409 
01410   YYDPRINTF ((stderr, "Shifting error token, "));
01411 
01412   *++yyvsp = yylval;
01413 
01414 
01415   yystate = yyn;
01416   goto yynewstate;
01417 
01418 
01419 /*-------------------------------------.
01420 | yyacceptlab -- YYACCEPT comes here.  |
01421 `-------------------------------------*/
01422 yyacceptlab:
01423   yyresult = 0;
01424   goto yyreturn;
01425 
01426 /*-----------------------------------.
01427 | yyabortlab -- YYABORT comes here.  |
01428 `-----------------------------------*/
01429 yyabortlab:
01430   yyresult = 1;
01431   goto yyreturn;
01432 
01433 #ifndef yyoverflow
01434 /*----------------------------------------------.
01435 | yyoverflowlab -- parser overflow comes here.  |
01436 `----------------------------------------------*/
01437 yyoverflowlab:
01438   yyerror ("parser stack overflow");
01439   yyresult = 2;
01440   /* Fall through.  */
01441 #endif
01442 
01443 yyreturn:
01444 #ifndef yyoverflow
01445   if (yyss != yyssa)
01446     YYSTACK_FREE (yyss);
01447 #endif
01448   return yyresult;
01449 }
01450 
01451 
01452 #line 116 "./ppdparser.y"
01453 
01454 
01455 #undef builder
01456 
KDE Home | KDE Accessibility Home | Description of Access Keys