#define YYBISON 1
#define YYBISON_VERSION "2.3"
#define YYSKELETON_NAME "yacc.c"
#define YYPURE 0
#define YYLSP_NEEDED 0
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype {
tINT = 258,
tDOUBLE = 259,
tDIMENSION = 260,
tBOOLEAN = 261,
tSTRING = 262,
tWORD = 263,
tGSWORD = 264,
CURRENT_PRINTER = 265,
SHOW_ALL_PAPER_SIZES = 266,
PRINTER = 267,
DESTINATION = 268,
SCALING = 269,
ORIENTATION = 270,
AUTOSIZE_ROLL_PAPER = 271,
UNIT = 272,
DRIVER = 273,
LEFT = 274,
TOP = 275,
CUSTOM_PAGE_WIDTH = 276,
CUSTOM_PAGE_HEIGHT = 277,
OUTPUT_TYPE = 278,
PRINTRC_HDR = 279,
PARAMETER = 280,
QUEUE_NAME = 281,
OUTPUT_FILENAME = 282,
EXTRA_PRINTER_OPTIONS = 283,
CUSTOM_COMMAND = 284,
COMMAND_TYPE = 285,
GLOBAL_SETTINGS = 286,
GLOBAL = 287,
END_GLOBAL_SETTINGS = 288,
pINT = 289,
pSTRING_LIST = 290,
pFILE = 291,
pDOUBLE = 292,
pDIMENSION = 293,
pBOOLEAN = 294,
pCURVE = 295
};
#endif
#define tINT 258
#define tDOUBLE 259
#define tDIMENSION 260
#define tBOOLEAN 261
#define tSTRING 262
#define tWORD 263
#define tGSWORD 264
#define CURRENT_PRINTER 265
#define SHOW_ALL_PAPER_SIZES 266
#define PRINTER 267
#define DESTINATION 268
#define SCALING 269
#define ORIENTATION 270
#define AUTOSIZE_ROLL_PAPER 271
#define UNIT 272
#define DRIVER 273
#define LEFT 274
#define TOP 275
#define CUSTOM_PAGE_WIDTH 276
#define CUSTOM_PAGE_HEIGHT 277
#define OUTPUT_TYPE 278
#define PRINTRC_HDR 279
#define PARAMETER 280
#define QUEUE_NAME 281
#define OUTPUT_FILENAME 282
#define EXTRA_PRINTER_OPTIONS 283
#define CUSTOM_COMMAND 284
#define COMMAND_TYPE 285
#define GLOBAL_SETTINGS 286
#define GLOBAL 287
#define END_GLOBAL_SETTINGS 288
#define pINT 289
#define pSTRING_LIST 290
#define pFILE 291
#define pDOUBLE 292
#define pDIMENSION 293
#define pBOOLEAN 294
#define pCURVE 295
#line 23 "printrcy.y"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <gutenprint/gutenprint-intl-internal.h>
#include <gutenprintui2/gutenprintui.h>
#include "gutenprintui-internal.h"
#include "printrc.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
extern int mylineno;
extern int yylex(void);
char *quotestrip(const char *i);
char *endstrip(const char *i);
extern char* yytext;
static int yyerror( const char *s )
{
fprintf(stderr,"stdin:%d: %s before '%s'\n", mylineno, s, yytext);
return 0;
}
static stpui_plist_t *current_printer = NULL;
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define yystype YYSTYPE
# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif
#line 219 "printrcy.c"
#ifdef short
# undef short
#endif
#ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8;
#else
typedef unsigned char yytype_uint8;
#endif
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
#elif (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
typedef signed char yytype_int8;
#else
typedef short int yytype_int8;
#endif
#ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16;
#else
typedef unsigned short int yytype_uint16;
#endif
#ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16;
#else
typedef short int yytype_int16;
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
# include <stddef.h>
# define YYSIZE_T size_t
# else
# define YYSIZE_T unsigned int
# endif
#endif
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
#ifndef YY_
# if YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h>
# define YY_(msgid) dgettext ("bison-runtime", msgid)
# endif
# endif
# ifndef YY_
# define YY_(msgid) msgid
# endif
#endif
#if ! defined lint || defined __GNUC__
# define YYUSE(e) ((void) (e))
#else
# define YYUSE(e)
#endif
#ifndef lint
# define YYID(n) (n)
#else
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static int
YYID (int i)
#else
static int
YYID (i)
int i;
#endif
{
return i;
}
#endif
#if ! defined yyoverflow || YYERROR_VERBOSE
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h>
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h>
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
# include <stdlib.h>
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
# define YYSTACK_FREE(Ptr) do { ; } while (YYID (0))
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM 4032
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined _STDLIB_H \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h>
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *malloc (YYSIZE_T);
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void free (void *);
# endif
# endif
# endif
#endif
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
union yyalloc
{
yytype_int16 yyss;
YYSTYPE yyvs;
};
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
# define YYSTACK_BYTES(N) \
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
# define YYCOPY(To, From, Count) \
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
while (YYID (0))
# endif
# endif
# define YYSTACK_RELOCATE(Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (YYID (0))
#endif
#define YYFINAL 10
#define YYLAST 75
#define YYNTOKENS 41
#define YYNNTS 42
#define YYNRULES 70
#define YYNSTATES 114
#define YYUNDEFTOK 2
#define YYMAXUTOK 295
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40
};
#if YYDEBUG
static const yytype_uint8 yyprhs[] =
{
0, 0, 3, 7, 10, 13, 16, 19, 22, 25,
28, 31, 34, 37, 40, 43, 46, 49, 52, 53,
58, 63, 68, 73, 78, 83, 88, 90, 92, 94,
96, 98, 100, 102, 105, 108, 110, 112, 114, 116,
118, 120, 122, 124, 126, 128, 130, 132, 134, 136,
138, 140, 143, 145, 149, 152, 154, 157, 160, 162,
164, 167, 170, 172, 174, 177, 179, 183, 185, 187,
189
};
static const yytype_int8 yyrhs[] =
{
82, 0, -1, 12, 7, 7, -1, 13, 7, -1,
26, 7, -1, 27, 7, -1, 28, 7, -1, 29,
7, -1, 30, 3, -1, 14, 4, -1, 15, 3,
-1, 16, 3, -1, 17, 3, -1, 19, 3, -1,
20, 3, -1, 23, 3, -1, 21, 3, -1, 22,
3, -1, -1, 8, 34, 6, 3, -1, 8, 35,
6, 7, -1, 8, 36, 6, 7, -1, 8, 37,
6, 4, -1, 8, 38, 6, 3, -1, 8, 39,
6, 6, -1, 8, 40, 6, 7, -1, 59, -1,
60, -1, 61, -1, 62, -1, 64, -1, 65, -1,
63, -1, 25, 66, -1, 68, 67, -1, 58, -1,
43, -1, 49, -1, 50, -1, 51, -1, 52, -1,
53, -1, 54, -1, 56, -1, 57, -1, 55, -1,
44, -1, 45, -1, 46, -1, 47, -1, 48, -1,
70, 69, -1, 58, -1, 42, 70, 68, -1, 72,
71, -1, 58, -1, 10, 7, -1, 11, 6, -1,
73, -1, 74, -1, 73, 74, -1, 8, 7, -1,
75, -1, 77, -1, 79, 78, -1, 58, -1, 31,
79, 33, -1, 80, -1, 76, -1, 58, -1, 24,
81, 72, -1
};
static const yytype_uint16 yyrline[] =
{
0, 100, 100, 111, 118, 128, 138, 148, 158, 165,
172, 179, 186, 193, 200, 207, 228, 235, 242, 245,
262, 280, 298, 315, 332, 353, 376, 376, 376, 376,
377, 377, 377, 380, 383, 383, 386, 386, 386, 386,
387, 387, 387, 387, 387, 388, 388, 388, 388, 389,
389, 392, 392, 395, 398, 398, 401, 405, 415, 415,
418, 421, 432, 432, 435, 435, 438, 441, 441, 441,
444
};
#endif
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
static const char *const yytname[] =
{
"$end", "error", "$undefined", "tINT", "tDOUBLE", "tDIMENSION",
"tBOOLEAN", "tSTRING", "tWORD", "tGSWORD", "CURRENT_PRINTER",
"SHOW_ALL_PAPER_SIZES", "PRINTER", "DESTINATION", "SCALING",
"ORIENTATION", "AUTOSIZE_ROLL_PAPER", "UNIT", "DRIVER", "LEFT", "TOP",
"CUSTOM_PAGE_WIDTH", "CUSTOM_PAGE_HEIGHT", "OUTPUT_TYPE", "PRINTRC_HDR",
"PARAMETER", "QUEUE_NAME", "OUTPUT_FILENAME", "EXTRA_PRINTER_OPTIONS",
"CUSTOM_COMMAND", "COMMAND_TYPE", "GLOBAL_SETTINGS", "GLOBAL",
"END_GLOBAL_SETTINGS", "pINT", "pSTRING_LIST", "pFILE", "pDOUBLE",
"pDIMENSION", "pBOOLEAN", "pCURVE", "$accept", "Printer", "Destination",
"Queue_Name", "Output_Filename", "Extra_Printer_Options",
"Custom_Command", "Command_Type", "Scaling", "Orientation",
"Autosize_Roll_Paper", "Unit", "Left", "Top", "Output_Type",
"Custom_Page_Width", "Custom_Page_Height", "Empty", "Int_Param",
"String_List_Param", "File_Param", "Double_Param", "Dimension_Param",
"Boolean_Param", "Curve_Param", "Typed_Param", "Parameter", "Parameters",
"Standard_Value", "Standard_Values", "A_Printer", "Printers",
"Current_Printer", "Show_All_Paper_Sizes", "Global", "Old_Globals",
"New_Global_Setting", "Global_Setting", "Global_Settings",
"Global_Subblock", "Global_Block", "Thing", 0
};
#endif
# ifdef YYPRINT
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295
};
# endif
static const yytype_uint8 yyr1[] =
{
0, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 66, 66, 66,
66, 66, 66, 67, 68, 68, 69, 69, 69, 69,
69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
69, 70, 70, 71, 72, 72, 73, 74, 75, 75,
76, 77, 78, 78, 79, 79, 80, 81, 81, 81,
82
};
static const yytype_uint8 yyr2[] =
{
0, 2, 3, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 0, 4,
4, 4, 4, 4, 4, 4, 1, 1, 1, 1,
1, 1, 1, 2, 2, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 1, 3, 2, 1, 2, 2, 1, 1,
2, 2, 1, 1, 2, 1, 3, 1, 1, 1,
3
};
static const yytype_uint8 yydefact[] =
{
0, 18, 0, 0, 18, 69, 0, 68, 67, 18,
1, 56, 65, 0, 0, 60, 55, 70, 0, 66,
58, 59, 62, 63, 64, 57, 0, 18, 54, 61,
0, 52, 18, 2, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 36,
46, 47, 48, 49, 50, 37, 38, 39, 40, 41,
42, 45, 43, 44, 35, 53, 51, 3, 9, 10,
11, 12, 13, 14, 16, 17, 15, 4, 5, 6,
7, 8, 0, 34, 0, 26, 27, 28, 29, 32,
30, 31, 33, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 19, 20, 21,
22, 23, 24, 25
};
static const yytype_int8 yydefgoto[] =
{
-1, 27, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 5, 85, 86,
87, 88, 89, 90, 91, 92, 83, 65, 66, 32,
28, 17, 6, 15, 22, 7, 23, 24, 13, 8,
9, 2
};
#define YYPACT_NINF -26
static const yytype_int8 yypact[] =
{
-22, -2, 6, 0, -26, -26, 5, -26, -26, -26,
-26, -26, -26, -7, 11, -26, -26, 7, 13, -26,
-26, -26, -26, -26, -26, -26, 14, -26, -26, -26,
15, -26, 17, -26, 18, 20, 24, 32, 38, 39,
45, 46, 47, 48, 49, 50, 51, 52, 57, -26,
-26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
-26, -26, -26, -26, -26, 27, -26, -26, -26, -26,
-26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
-26, -26, 10, -26, -25, -26, -26, -26, -26, -26,
-26, -26, -26, 55, 56, 58, 59, 60, 61, 62,
66, 63, 64, 68, 70, 69, 67, -26, -26, -26,
-26, -26, -26, -26
};
static const yytype_int8 yypgoto[] =
{
-26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
-26, -26, -26, -26, -26, -26, -26, -4, -26, -26,
-26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
-26, -26, 40, 41, -26, -26, -26, -26, -26, -26,
-26, -26
};
#define YYTABLE_NINF -1
static const yytype_uint8 yytable[] =
{
12, 18, 1, 3, 14, 16, 10, 11, 3, 93,
94, 95, 96, 97, 98, 99, 14, 25, 84, 26,
29, 30, 33, 31, 68, 67, 19, 69, 64, 4,
34, 35, 36, 37, 38, 70, 39, 40, 41, 42,
43, 71, 72, 44, 45, 46, 47, 48, 73, 74,
75, 76, 82, 20, 21, 0, 77, 78, 79, 80,
81, 100, 101, 0, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 113, 112
};
static const yytype_int8 yycheck[] =
{
4, 8, 24, 10, 11, 9, 0, 7, 10, 34,
35, 36, 37, 38, 39, 40, 11, 6, 8, 12,
7, 7, 7, 27, 4, 7, 33, 3, 32, 31,
13, 14, 15, 16, 17, 3, 19, 20, 21, 22,
23, 3, 3, 26, 27, 28, 29, 30, 3, 3,
3, 3, 25, 13, 13, -1, 7, 7, 7, 7,
3, 6, 6, -1, 6, 6, 6, 6, 6, 3,
7, 7, 4, 3, 7, 6
};
static const yytype_uint8 yystos[] =
{
0, 24, 82, 10, 31, 58, 73, 76, 80, 81,
0, 7, 58, 79, 11, 74, 58, 72, 8, 33,
73, 74, 75, 77, 78, 6, 12, 42, 71, 7,
7, 58, 70, 7, 13, 14, 15, 16, 17, 19,
20, 21, 22, 23, 26, 27, 28, 29, 30, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 68, 69, 7, 4, 3,
3, 3, 3, 3, 3, 3, 3, 7, 7, 7,
7, 3, 25, 67, 8, 59, 60, 61, 62, 63,
64, 65, 66, 34, 35, 36, 37, 38, 39, 40,
6, 6, 6, 6, 6, 6, 6, 3, 7, 7,
4, 3, 6, 7
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
{ \
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (YYID (0))
#define YYTERROR 1
#define YYERRCODE 256
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do \
if (YYID (N)) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (YYID (0))
#endif
#ifndef YY_LOCATION_PRINT
# if YYLTYPE_IS_TRIVIAL
# define YY_LOCATION_PRINT(File, Loc) \
fprintf (File, "%d.%d-%d.%d", \
(Loc).first_line, (Loc).first_column, \
(Loc).last_line, (Loc).last_column)
# else
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
# endif
#endif
#ifdef YYLEX_PARAM
# define YYLEX yylex (YYLEX_PARAM)
#else
# define YYLEX yylex ()
#endif
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h>
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (YYID (0))
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (YYID (0))
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
YYUSE (yyoutput);
# endif
switch (yytype)
{
default:
break;
}
}
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{
if (yytype < YYNTOKENS)
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
YYFPRINTF (yyoutput, ")");
}
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
#else
static void
yy_stack_print (bottom, top)
yytype_int16 *bottom;
yytype_int16 *top;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (YYID (0))
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned long int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
yyrule - 1, yylno);
for (yyi = 0; yyi < yynrhs; yyi++)
{
fprintf (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
fprintf (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
int yydebug;
#else
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
#if YYERROR_VERBOSE
# ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
#endif
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
# endif
# ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
#endif
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
# endif
# ifndef yytnamerr
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
if (! yyres)
return yystrlen (yystr);
return yystpcpy (yyres, yystr) - yyres;
}
# endif
static YYSIZE_T
yysyntax_error (char *yyresult, int yystate, int yychar)
{
int yyn = yypact[yystate];
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
int yytype = YYTRANSLATE (yychar);
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
YYSIZE_T yysize = yysize0;
YYSIZE_T yysize1;
int yysize_overflow = 0;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
int yyx;
# if 0
YY_("syntax error, unexpected %s");
YY_("syntax error, unexpected %s, expecting %s");
YY_("syntax error, unexpected %s, expecting %s or %s");
YY_("syntax error, unexpected %s, expecting %s or %s or %s");
YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
# endif
char *yyfmt;
char const *yyf;
static char const yyunexpected[] = "syntax error, unexpected %s";
static char const yyexpecting[] = ", expecting %s";
static char const yyor[] = " or %s";
char yyformat[sizeof yyunexpected
+ sizeof yyexpecting - 1
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
* (sizeof yyor - 1))];
char const *yyprefix = yyexpecting;
int yyxbegin = yyn < 0 ? -yyn : 0;
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 1;
yyarg[0] = yytname[yytype];
yyfmt = yystpcpy (yyformat, yyunexpected);
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
yysize = yysize0;
yyformat[sizeof yyunexpected - 1] = '\0';
break;
}
yyarg[yycount++] = yytname[yyx];
yysize1 = yysize + yytnamerr (0, yytname[yyx]);
yysize_overflow |= (yysize1 < yysize);
yysize = yysize1;
yyfmt = yystpcpy (yyfmt, yyprefix);
yyprefix = yyor;
}
yyf = YY_(yyformat);
yysize1 = yysize + yystrlen (yyf);
yysize_overflow |= (yysize1 < yysize);
yysize = yysize1;
if (yysize_overflow)
return YYSIZE_MAXIMUM;
if (yyresult)
{
char *yyp = yyresult;
int yyi = 0;
while ((*yyp = *yyf) != '\0')
{
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
{
yyp += yytnamerr (yyp, yyarg[yyi++]);
yyf += 2;
}
else
{
yyp++;
yyf++;
}
}
}
return yysize;
}
}
#endif
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
switch (yytype)
{
default:
break;
}
}
#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
#else
int yyparse ();
#endif
#else
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
#endif
#endif
int yychar;
YYSTYPE yylval;
int yynerrs;
#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void *YYPARSE_PARAM)
#else
int
yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
#endif
#else
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
int
yyparse ()
#endif
#endif
{
int yystate;
int yyn;
int yyresult;
int yyerrstatus;
int yytoken = 0;
#if YYERROR_VERBOSE
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss = yyssa;
yytype_int16 *yyssp;
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
YYSTYPE *yyvsp;
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
YYSIZE_T yystacksize = YYINITDEPTH;
YYSTYPE yyval;
int yylen = 0;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY;
yyssp = yyss;
yyvsp = yyvs;
goto yysetstate;
yynewstate:
yyssp++;
yysetstate:
*yyssp = yystate;
if (yyss + yystacksize - 1 <= yyssp)
{
YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
{
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
&yystacksize);
yyss = yyss1;
yyvs = yyvs1;
}
#else
# ifndef YYSTACK_RELOCATE
goto yyexhaustedlab;
# else
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
goto yybackup;
yybackup:
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yyn == 0 || yyn == YYTABLE_NINF)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
if (yyn == YYFINAL)
YYACCEPT;
if (yyerrstatus)
yyerrstatus--;
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
if (yychar != YYEOF)
yychar = YYEMPTY;
yystate = yyn;
*++yyvsp = yylval;
goto yynewstate;
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
yyreduce:
yylen = yyr2[yyn];
yyval = yyvsp[1-yylen];
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
case 2:
#line 101 "printrcy.y"
{
current_printer = stpui_plist_create((yyvsp[(2) - (3)].sval), (yyvsp[(3) - (3)].sval));
g_free((yyvsp[(2) - (3)].sval));
g_free((yyvsp[(3) - (3)].sval));
}
break;
case 3:
#line 112 "printrcy.y"
{
if ((yyvsp[(2) - (2)].sval))
g_free((yyvsp[(2) - (2)].sval));
}
break;
case 4:
#line 119 "printrcy.y"
{
if (current_printer && (yyvsp[(2) - (2)].sval))
{
stpui_plist_set_queue_name(current_printer, (yyvsp[(2) - (2)].sval));
g_free((yyvsp[(2) - (2)].sval));
}
}
break;
case 5:
#line 129 "printrcy.y"
{
if (current_printer && (yyvsp[(2) - (2)].sval))
{
stpui_plist_set_output_filename(current_printer, (yyvsp[(2) - (2)].sval));
g_free((yyvsp[(2) - (2)].sval));
}
}
break;
case 6:
#line 139 "printrcy.y"
{
if (current_printer && (yyvsp[(2) - (2)].sval))
{
stpui_plist_set_extra_printer_options(current_printer, (yyvsp[(2) - (2)].sval));
g_free((yyvsp[(2) - (2)].sval));
}
}
break;
case 7:
#line 149 "printrcy.y"
{
if (current_printer && (yyvsp[(2) - (2)].sval))
{
stpui_plist_set_custom_command(current_printer, (yyvsp[(2) - (2)].sval));
g_free((yyvsp[(2) - (2)].sval));
}
}
break;
case 8:
#line 159 "printrcy.y"
{
if (current_printer)
stpui_plist_set_command_type(current_printer, (yyvsp[(2) - (2)].ival));
}
break;
case 9:
#line 166 "printrcy.y"
{
if (current_printer)
current_printer->scaling = (yyvsp[(2) - (2)].dval);
}
break;
case 10:
#line 173 "printrcy.y"
{
if (current_printer)
current_printer->orientation = (yyvsp[(2) - (2)].ival);
}
break;
case 11:
#line 180 "printrcy.y"
{
if (current_printer)
current_printer->auto_size_roll_feed_paper = (yyvsp[(2) - (2)].ival);
}
break;
case 12:
#line 187 "printrcy.y"
{
if (current_printer)
current_printer->unit = (yyvsp[(2) - (2)].ival);
}
break;
case 13:
#line 194 "printrcy.y"
{
if (current_printer)
stp_set_left(current_printer->v, (yyvsp[(2) - (2)].ival));
}
break;
case 14:
#line 201 "printrcy.y"
{
if (current_printer)
stp_set_top(current_printer->v, (yyvsp[(2) - (2)].ival));
}
break;
case 15:
#line 208 "printrcy.y"
{
if (current_printer)
{
switch ((yyvsp[(2) - (2)].ival))
{
case 0:
stp_set_string_parameter
(current_printer->v, "PrintingMode", "BW");
break;
case 1:
case 2:
default:
stp_set_string_parameter
(current_printer->v, "PrintingMode", "Color");
break;
}
}
}
break;
case 16:
#line 229 "printrcy.y"
{
if (current_printer)
stp_set_page_width(current_printer->v, (yyvsp[(2) - (2)].ival));
}
break;
case 17:
#line 236 "printrcy.y"
{
if (current_printer)
stp_set_page_height(current_printer->v, (yyvsp[(2) - (2)].ival));
}
break;
case 19:
#line 246 "printrcy.y"
{
if (current_printer)
{
stp_set_int_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), (yyvsp[(4) - (4)].ival));
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_int_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_int_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
}
break;
case 20:
#line 263 "printrcy.y"
{
if (current_printer)
{
stp_set_string_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), (yyvsp[(4) - (4)].sval));
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_string_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_string_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
g_free((yyvsp[(4) - (4)].sval));
}
break;
case 21:
#line 281 "printrcy.y"
{
if (current_printer)
{
stp_set_file_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), (yyvsp[(4) - (4)].sval));
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_file_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_file_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
g_free((yyvsp[(4) - (4)].sval));
}
break;
case 22:
#line 299 "printrcy.y"
{
if (current_printer)
{
stp_set_float_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), (yyvsp[(4) - (4)].dval));
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_float_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_float_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
}
break;
case 23:
#line 316 "printrcy.y"
{
if (current_printer)
{
stp_set_dimension_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), (yyvsp[(4) - (4)].ival));
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_dimension_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_dimension_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
}
break;
case 24:
#line 333 "printrcy.y"
{
if (current_printer)
{
if (strcmp((yyvsp[(4) - (4)].sval), "False") == 0)
stp_set_boolean_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), 0);
else
stp_set_boolean_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), 1);
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_boolean_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_boolean_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
g_free((yyvsp[(4) - (4)].sval));
}
break;
case 25:
#line 354 "printrcy.y"
{
if (current_printer)
{
stp_curve_t *curve = stp_curve_create_from_string((yyvsp[(4) - (4)].sval));
if (curve)
{
stp_set_curve_parameter(current_printer->v, (yyvsp[(1) - (4)].sval), curve);
if (strcmp((yyvsp[(3) - (4)].sval), "False") == 0)
stp_set_curve_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_INACTIVE);
else
stp_set_curve_parameter_active(current_printer->v, (yyvsp[(1) - (4)].sval),
STP_PARAMETER_ACTIVE);
stp_curve_destroy(curve);
}
}
g_free((yyvsp[(1) - (4)].sval));
g_free((yyvsp[(3) - (4)].sval));
g_free((yyvsp[(4) - (4)].sval));
}
break;
case 56:
#line 402 "printrcy.y"
{ stpui_printrc_current_printer = (yyvsp[(2) - (2)].sval); }
break;
case 57:
#line 406 "printrcy.y"
{
if (strcmp((yyvsp[(2) - (2)].sval), "True") == 0)
stpui_show_all_paper_sizes = 1;
else
stpui_show_all_paper_sizes = 0;
g_free((yyvsp[(2) - (2)].sval));
}
break;
case 61:
#line 422 "printrcy.y"
{
if ((yyvsp[(2) - (2)].sval))
{
stpui_set_global_parameter((yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].sval));
g_free((yyvsp[(2) - (2)].sval));
}
g_free((yyvsp[(1) - (2)].sval));
}
break;
#line 1846 "printrcy.c"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
goto yynewstate;
yyerrlab:
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
{
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
{
YYSIZE_T yyalloc = 2 * yysize;
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
yyalloc = YYSTACK_ALLOC_MAXIMUM;
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yyalloc);
if (yymsg)
yymsg_alloc = yyalloc;
else
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
}
if (0 < yysize && yysize <= yymsg_alloc)
{
(void) yysyntax_error (yymsg, yystate, yychar);
yyerror (yymsg);
}
else
{
yyerror (YY_("syntax error"));
if (yysize != 0)
goto yyexhaustedlab;
}
}
#endif
}
if (yyerrstatus == 3)
{
if (yychar <= YYEOF)
{
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
}
}
goto yyerrlab1;
yyerrorlab:
if ( 0)
goto yyerrorlab;
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
yyerrlab1:
yyerrstatus = 3;
for (;;)
{
yyn = yypact[yystate];
if (yyn != YYPACT_NINF)
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
if (yyssp == yyss)
YYABORT;
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
yyacceptlab:
yyresult = 0;
goto yyreturn;
yyabortlab:
yyresult = 1;
goto yyreturn;
#ifndef yyoverflow
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
#endif
yyreturn:
if (yychar != YYEOF && yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
return YYID (yyresult);
}
#line 447 "printrcy.y"