Imported Upstream version 4.3.99+cvs20051122.dfsg.1

1 files changed, 513 insertions, 333 deletions

diff --git a/src/testpattern/testpatterny.c b/src/testpattern/testpatterny.c
index ede6285..cd1c6d3 100644
--- a/src/testpattern/testpatterny.c
+++ b/src/testpattern/testpatterny.c
@@ -1,7 +1,7 @@
-/* A Bison parser, made by GNU Bison 1.875.  */
+/* A Bison parser, made by GNU Bison 2.1.  */
 
 /* Skeleton parser for Yacc-like parsing with Bison,
-   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,8 +15,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
@@ -36,6 +36,9 @@
 /* Identify Bison output.  */
 #define YYBISON 1
 
+/* Bison version.  */
+#define YYBISON_VERSION "2.1"
+
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
 
@@ -99,6 +102,7 @@
      END = 301
    };
 #endif
+/* Tokens.  */
 #define tINT 258
 #define tDOUBLE 259
 #define tSTRING 260
@@ -228,6 +232,11 @@ find_color(const char *name)
 # define YYERROR_VERBOSE 0
 #endif
 
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 typedef int YYSTYPE;
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -240,22 +249,48 @@ typedef int YYSTYPE;
 /* Copy the second part of user declarations.  */
 
 
-/* Line 214 of yacc.c.  */
-#line 244 "testpatterny.c"
+/* Line 219 of yacc.c.  */
+#line 254 "testpatterny.c"
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
-# else
-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
 #   else
-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
+#    define YYSTACK_ALLOC alloca
+#    if defined (__STDC__) || defined (__cplusplus)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     define YYINCLUDED_STDLIB_H
 #    endif
 #   endif
 #  endif
@@ -264,25 +299,51 @@ typedef int YYSTYPE;
 # ifdef YYSTACK_ALLOC
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
+#  endif
 # else
-#  if defined (__STDC__) || defined (__cplusplus)
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
+#  endif
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
+	&& (defined (__STDC__) || defined (__cplusplus)))
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifdef __cplusplus
+}
 #  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
 # endif
 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
-	 || (YYSTYPE_IS_TRIVIAL)))
+	 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  short yyss;
+  short int yyss;
   YYSTYPE yyvs;
   };
 
@@ -292,20 +353,20 @@ union yyalloc
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 # define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))				\
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))			\
       + YYSTACK_GAP_MAXIMUM)
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
-#  if 1 < __GNUC__
+#  if defined (__GNUC__) && 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count)		\
       do					\
 	{					\
-	  register YYSIZE_T yyi;		\
+	  YYSIZE_T yyi;				\
 	  for (yyi = 0; yyi < (Count); yyi++)	\
 	    (To)[yyi] = (From)[yyi];		\
 	}					\
@@ -334,7 +395,7 @@ union yyalloc
 #if defined (__STDC__) || defined (__cplusplus)
    typedef signed char yysigned_char;
 #else
-   typedef short yysigned_char;
+   typedef short int yysigned_char;
 #endif
 
 /* YYFINAL -- State number of the termination state. */
@@ -355,7 +416,7 @@ union yyalloc
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   301
 
-#define YYTRANSLATE(YYX) 						\
+#define YYTRANSLATE(YYX)						\
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
@@ -397,7 +458,7 @@ static const unsigned char yytranslate[] =
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
-static const unsigned short yyprhs[] =
+static const unsigned short int yyprhs[] =
 {
        0,     0,     3,     5,     7,     9,    11,    13,    15,    17,
       19,    22,    25,    28,    31,    34,    37,    41,    43,    45,
@@ -450,7 +511,7 @@ static const yysigned_char yyrhs[] =
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const unsigned short yyrline[] =
+static const unsigned short int yyrline[] =
 {
        0,   139,   139,   139,   139,   139,   140,   140,   140,   140,
      143,   155,   167,   179,   191,   203,   215,   227,   227,   227,
@@ -467,38 +528,38 @@ static const unsigned short yyrline[] =
 };
 #endif
 
-#if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[] =
 {
-  "$end", "error", "$undefined", "tINT", "tDOUBLE", "tSTRING", "CYAN", 
-  "L_CYAN", "MAGENTA", "L_MAGENTA", "YELLOW", "D_YELLOW", "BLACK", 
-  "L_BLACK", "GAMMA", "LEVEL", "STEPS", "INK_LIMIT", "PRINTER", 
-  "PARAMETER", "PARAMETER_INT", "PARAMETER_FLOAT", "PARAMETER_CURVE", 
-  "DENSITY", "TOP", "LEFT", "HSIZE", "VSIZE", "BLACKLINE", "PATTERN", 
-  "XPATTERN", "EXTENDED", "IMAGE", "GRID", "SEMI", "CHANNEL", "CMYK", 
-  "KCMY", "RGB", "CMY", "GRAY", "WHITE", "RAW", "MODE", "PAGESIZE", 
-  "MESSAGE", "END", "$accept", "COLOR", "cmykspec", "kcmyspec", "rgbspec", 
-  "cmyspec", "grayspec", "whitespec", "extendedspec", "modespec", 
-  "inputspec", "level", "channel_level", "gamma", "channel_gamma", 
-  "global_gamma", "steps", "ink_limit", "printer", "page_size_name", 
-  "page_size_custom", "page_size", "parameter_string", "parameter_int", 
-  "parameter_float", "parameter", "density", "top", "left", "hsize", 
-  "vsize", "blackline", "color_block1", "color_blocks1a", 
-  "color_blocks1b", "color_blocks1", "color_block2a", "color_block2b", 
-  "color_block2", "color_blocks2a", "color_blocks2", "color_blocks", 
-  "patvars", "pattern", "xpattern", "grid", "image", "Message0", 
-  "Message1", "Message2", "Message3", "Message4", "A_Message", "message", 
-  "A_Rule", "Rule", "A_Pattern", "Pattern", "Patterns", "Image", "Rules", 
-  "Output", "EOF", "Thing", "@1", 0
+  "$end", "error", "$undefined", "tINT", "tDOUBLE", "tSTRING", "CYAN",
+  "L_CYAN", "MAGENTA", "L_MAGENTA", "YELLOW", "D_YELLOW", "BLACK",
+  "L_BLACK", "GAMMA", "LEVEL", "STEPS", "INK_LIMIT", "PRINTER",
+  "PARAMETER", "PARAMETER_INT", "PARAMETER_FLOAT", "PARAMETER_CURVE",
+  "DENSITY", "TOP", "LEFT", "HSIZE", "VSIZE", "BLACKLINE", "PATTERN",
+  "XPATTERN", "EXTENDED", "IMAGE", "GRID", "SEMI", "CHANNEL", "CMYK",
+  "KCMY", "RGB", "CMY", "GRAY", "WHITE", "RAW", "MODE", "PAGESIZE",
+  "MESSAGE", "END", "$accept", "COLOR", "cmykspec", "kcmyspec", "rgbspec",
+  "cmyspec", "grayspec", "whitespec", "extendedspec", "modespec",
+  "inputspec", "level", "channel_level", "gamma", "channel_gamma",
+  "global_gamma", "steps", "ink_limit", "printer", "page_size_name",
+  "page_size_custom", "page_size", "parameter_string", "parameter_int",
+  "parameter_float", "parameter", "density", "top", "left", "hsize",
+  "vsize", "blackline", "color_block1", "color_blocks1a", "color_blocks1b",
+  "color_blocks1", "color_block2a", "color_block2b", "color_block2",
+  "color_blocks2a", "color_blocks2", "color_blocks", "patvars", "pattern",
+  "xpattern", "grid", "image", "Message0", "Message1", "Message2",
+  "Message3", "Message4", "A_Message", "message", "A_Rule", "Rule",
+  "A_Pattern", "Pattern", "Patterns", "Image", "Rules", "Output", "EOF",
+  "Thing", "@1", 0
 };
 #endif
 
 # ifdef YYPRINT
 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    token YYLEX-NUM.  */
-static const unsigned short yytoknum[] =
+static const unsigned short int yytoknum[] =
 {
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
@@ -567,7 +628,7 @@ static const unsigned char yydefact[] =
 };
 
 /* YYDEFGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+static const short int yydefgoto[] =
 {
       -1,   137,    85,    86,    87,    88,    89,    90,    91,    92,
       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
@@ -581,7 +642,7 @@ static const short yydefgoto[] =
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 #define YYPACT_NINF -131
-static const short yypact[] =
+static const short int yypact[] =
 {
     -131,   -14,    16,    56,    41,    25,    36,    38,    53,    66,
       67,    69,    70,    77,    78,    79,    81,    39,    22,    80,
@@ -603,7 +664,7 @@ static const short yypact[] =
 };
 
 /* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
+static const short int yypgoto[] =
 {
     -131,    52,  -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,
     -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,
@@ -678,22 +739,6 @@ static const unsigned char yystos[] =
        4,     4,     4,     4,    79,     4,     4,     4,     4,     4
 };
 
-#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
-# define YYSIZE_T __SIZE_TYPE__
-#endif
-#if ! defined (YYSIZE_T) && defined (size_t)
-# define YYSIZE_T size_t
-#endif
-#if ! defined (YYSIZE_T)
-# if defined (__STDC__) || defined (__cplusplus)
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# endif
-#endif
-#if ! defined (YYSIZE_T)
-# define YYSIZE_T unsigned int
-#endif
-
 #define yyerrok		(yyerrstatus = 0)
 #define yyclearin	(yychar = YYEMPTY)
 #define YYEMPTY		(-2)
@@ -701,7 +746,8 @@ static const unsigned char yystos[] =
 
 #define YYACCEPT	goto yyacceptlab
 #define YYABORT		goto yyabortlab
-#define YYERROR		goto yyerrlab1
+#define YYERROR		goto yyerrorlab
+
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
@@ -722,26 +768,59 @@ do								\
       goto yybackup;						\
     }								\
   else								\
-    { 								\
-      yyerror ("syntax error: cannot back up");\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
       YYERROR;							\
     }								\
 while (0)
 
+
 #define YYTERROR	1
 #define YYERRCODE	256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
 
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
 #ifndef YYLLOC_DEFAULT
-# define YYLLOC_DEFAULT(Current, Rhs, N)         \
-  Current.first_line   = Rhs[1].first_line;      \
-  Current.first_column = Rhs[1].first_column;    \
-  Current.last_line    = Rhs[N].last_line;       \
-  Current.last_column  = Rhs[N].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (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 (0)
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#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
 
+
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
@@ -764,36 +843,30 @@ do {						\
     YYFPRINTF Args;				\
 } while (0)
 
-# define YYDSYMPRINT(Args)			\
-do {						\
-  if (yydebug)					\
-    yysymprint Args;				\
-} while (0)
-
-# define YYDSYMPRINTF(Title, Token, Value, Location)		\
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)		\
 do {								\
   if (yydebug)							\
     {								\
       YYFPRINTF (stderr, "%s ", Title);				\
-      yysymprint (stderr, 					\
-                  Token, Value);	\
+      yysymprint (stderr,					\
+                  Type, Value);	\
       YYFPRINTF (stderr, "\n");					\
     }								\
 } while (0)
 
 /*------------------------------------------------------------------.
 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (cinluded).                                                   |
+| TOP (included).                                                   |
 `------------------------------------------------------------------*/
 
 #if defined (__STDC__) || defined (__cplusplus)
 static void
-yy_stack_print (short *bottom, short *top)
+yy_stack_print (short int *bottom, short int *top)
 #else
 static void
 yy_stack_print (bottom, top)
-    short *bottom;
-    short *top;
+    short int *bottom;
+    short int *top;
 #endif
 {
   YYFPRINTF (stderr, "Stack now");
@@ -823,13 +896,13 @@ yy_reduce_print (yyrule)
 #endif
 {
   int yyi;
-  unsigned int yylineno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
-             yyrule - 1, yylineno);
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
+             yyrule - 1, yylno);
   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
-    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
-  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
 }
 
 # define YY_REDUCE_PRINT(Rule)		\
@@ -843,8 +916,7 @@ do {					\
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 # define YY_STACK_PRINT(Bottom, Top)
 # define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
@@ -859,13 +931,9 @@ int yydebug;
    if the built-in stack extension method is used).
 
    Do not make this value too large; the results are undefined if
-   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
-#if YYMAXDEPTH == 0
-# undef YYMAXDEPTH
-#endif
-
 #ifndef YYMAXDEPTH
 # define YYMAXDEPTH 10000
 #endif
@@ -887,7 +955,7 @@ yystrlen (yystr)
      const char *yystr;
 #   endif
 {
-  register const char *yys = yystr;
+  const char *yys = yystr;
 
   while (*yys++ != '\0')
     continue;
@@ -912,8 +980,8 @@ yystpcpy (yydest, yysrc)
      const char *yysrc;
 #   endif
 {
-  register char *yyd = yydest;
-  register const char *yys = yysrc;
+  char *yyd = yydest;
+  const char *yys = yysrc;
 
   while ((*yyd++ = *yys++) != '\0')
     continue;
@@ -923,7 +991,55 @@ yystpcpy (yydest, yysrc)
 #  endif
 # endif
 
-#endif /* !YYERROR_VERBOSE */
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      size_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;
+	    /* Fall through.  */
+	  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
+
+#endif /* YYERROR_VERBOSE */
 
 
 
@@ -947,15 +1063,15 @@ yysymprint (yyoutput, yytype, yyvaluep)
   (void) yyvaluep;
 
   if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
-# ifdef YYPRINT
-      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
-# endif
-    }
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
   else
     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 
+
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
   switch (yytype)
     {
       default:
@@ -971,10 +1087,11 @@ yysymprint (yyoutput, yytype, yyvaluep)
 
 #if defined (__STDC__) || defined (__cplusplus)
 static void
-yydestruct (int yytype, YYSTYPE *yyvaluep)
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 #else
 static void
-yydestruct (yytype, yyvaluep)
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
     int yytype;
     YYSTYPE *yyvaluep;
 #endif
@@ -982,6 +1099,10 @@ yydestruct (yytype, yyvaluep)
   /* Pacify ``unused variable'' warnings.  */
   (void) yyvaluep;
 
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
   switch (yytype)
     {
 
@@ -1009,10 +1130,10 @@ int yyparse ();
 
 
 
-/* The lookahead symbol.  */
+/* The look-ahead symbol.  */
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
 /* Number of syntax errors so far.  */
@@ -1038,17 +1159,17 @@ yyparse (void)
 #else
 int
 yyparse ()
-
+    ;
 #endif
 #endif
 {
   
-  register int yystate;
-  register int yyn;
+  int yystate;
+  int yyn;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
+  /* Look-ahead token as an internal (translated) token number.  */
   int yytoken = 0;
 
   /* Three stacks and their tools:
@@ -1060,14 +1181,14 @@ yyparse ()
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
-  short	yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  short int *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
   YYSTYPE *yyvs = yyvsa;
-  register YYSTYPE *yyvsp;
+  YYSTYPE *yyvsp;
 
 
 
@@ -1124,14 +1245,14 @@ yyparse ()
 	   these so that the &'s don't force the real ones into
 	   memory.  */
 	YYSTYPE *yyvs1 = yyvs;
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 
 
 	/* Each stack pointer address is followed by the size of the
 	   data in use in that stack, in bytes.  This used to be a
 	   conditional around just the two extra args, but that might
 	   be undefined if yyoverflow is a macro.  */
-	yyoverflow ("parser stack overflow",
+	yyoverflow (YY_("memory exhausted"),
 		    &yyss1, yysize * sizeof (*yyssp),
 		    &yyvs1, yysize * sizeof (*yyvsp),
 
@@ -1142,21 +1263,21 @@ yyparse ()
       }
 #else /* no yyoverflow */
 # ifndef YYSTACK_RELOCATE
-      goto yyoverflowlab;
+      goto yyexhaustedlab;
 # else
       /* Extend the stack our own way.  */
       if (YYMAXDEPTH <= yystacksize)
-	goto yyoverflowlab;
+	goto yyexhaustedlab;
       yystacksize *= 2;
       if (YYMAXDEPTH < yystacksize)
 	yystacksize = YYMAXDEPTH;
 
       {
-	short *yyss1 = yyss;
+	short int *yyss1 = yyss;
 	union yyalloc *yyptr =
 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 	if (! yyptr)
-	  goto yyoverflowlab;
+	  goto yyexhaustedlab;
 	YYSTACK_RELOCATE (yyss);
 	YYSTACK_RELOCATE (yyvs);
 
@@ -1188,18 +1309,18 @@ yyparse ()
 yybackup:
 
 /* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
+/* Read a look-ahead token if we need one and don't already have one.  */
 /* yyresume: */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
 
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
   if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
@@ -1214,7 +1335,7 @@ yybackup:
   else
     {
       yytoken = YYTRANSLATE (yychar);
-      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
   /* If the proper action on seeing token YYTOKEN is to reduce or to
@@ -1234,8 +1355,8 @@ yybackup:
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
@@ -1288,12 +1409,12 @@ yyreduce:
 #line 144 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>cmykspec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>cmykspec %d\n", (yyvsp[0].ival));
 	  global_image_type = "CMYK";
 	  global_channel_depth = 4;
 	  global_invert_data = 0;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1301,12 +1422,12 @@ yyreduce:
 #line 156 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>kcmyspec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>kcmyspec %d\n", (yyvsp[0].ival));
 	  global_image_type = "KCMY";
 	  global_channel_depth = 4;
 	  global_invert_data = 0;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1314,12 +1435,12 @@ yyreduce:
 #line 168 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>rgbspec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>rgbspec %d\n", (yyvsp[0].ival));
 	  global_image_type = "RGB";
 	  global_channel_depth = 3;
 	  global_invert_data = 1;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1327,12 +1448,12 @@ yyreduce:
 #line 180 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>cmyspec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>cmyspec %d\n", (yyvsp[0].ival));
 	  global_image_type = "CMY";
 	  global_channel_depth = 3;
 	  global_invert_data = 0;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1340,12 +1461,12 @@ yyreduce:
 #line 192 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>grayspec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>grayspec %d\n", (yyvsp[0].ival));
 	  global_image_type = "Grayscale";
 	  global_channel_depth = 1;
 	  global_invert_data = 0;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1353,12 +1474,12 @@ yyreduce:
 #line 204 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>whitespec %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>whitespec %d\n", (yyvsp[0].ival));
 	  global_image_type = "Whitescale";
 	  global_channel_depth = 1;
 	  global_invert_data = 1;
-	  if (yyvsp[0].ival == 8 || yyvsp[0].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  if ((yyvsp[0].ival) == 8 || (yyvsp[0].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
@@ -1366,23 +1487,23 @@ yyreduce:
 #line 216 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>extendedspec %d\n", yyvsp[-1].ival);
+	    fprintf(stderr, ">>>extendedspec %d\n", (yyvsp[-1].ival));
 	  global_image_type = "Raw";
 	  global_invert_data = 0;
-	  global_channel_depth = yyvsp[-1].ival;
-	  if (yyvsp[-1].ival == 8 || yyvsp[-1].ival == 16)
-	    global_bit_depth = yyvsp[0].ival;
+	  global_channel_depth = (yyvsp[-1].ival);
+	  if ((yyvsp[-1].ival) == 8 || (yyvsp[-1].ival) == 16)
+	    global_bit_depth = (yyvsp[0].ival);
 	}
     break;
 
   case 25:
 #line 234 "testpatterny.y"
     {
-	  int channel = find_color(yyvsp[-1].sval);
+	  int channel = find_color((yyvsp[-1]).sval);
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>level %s %f\n", yyvsp[-1].sval, yyvsp[0].dval);
+	    fprintf(stderr, ">>>level %s %f\n", (yyvsp[-1]).sval, (yyvsp[0].dval));
 	  if (channel >= 0)
-	    global_levels[channel] = yyvsp[0].dval;
+	    global_levels[channel] = (yyvsp[0].dval);
 	}
     break;
 
@@ -1390,20 +1511,20 @@ yyreduce:
 #line 244 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>channel_level %d %f\n", yyvsp[-1].ival, yyvsp[0].dval);
-	  if (yyvsp[-1].ival >= 0 && yyvsp[-1].ival <= STP_CHANNEL_LIMIT)
-	    global_levels[yyvsp[-1].ival] = yyvsp[0].dval;
+	    fprintf(stderr, ">>>channel_level %d %f\n", (yyvsp[-1].ival), (yyvsp[0].dval));
+	  if ((yyvsp[-1].ival) >= 0 && (yyvsp[-1].ival) <= STP_CHANNEL_LIMIT)
+	    global_levels[(yyvsp[-1].ival)] = (yyvsp[0].dval);
 	}
     break;
 
   case 27:
 #line 253 "testpatterny.y"
     {
-	  int channel = find_color(yyvsp[-1].sval);
+	  int channel = find_color((yyvsp[-1]).sval);
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>gamma %s %f\n", yyvsp[-1].sval, yyvsp[0].dval);
+	    fprintf(stderr, ">>>gamma %s %f\n", (yyvsp[-1]).sval, (yyvsp[0].dval));
 	  if (channel >= 0)
-	    global_gammas[channel] = yyvsp[0].dval;
+	    global_gammas[channel] = (yyvsp[0].dval);
 	}
     break;
 
@@ -1411,9 +1532,9 @@ yyreduce:
 #line 263 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>channel_gamma %d %f\n", yyvsp[-1].ival, yyvsp[0].dval);
-	  if (yyvsp[-1].ival >= 0 && yyvsp[-1].ival <= STP_CHANNEL_LIMIT)
-	    global_gammas[yyvsp[-1].ival] = yyvsp[0].dval;
+	    fprintf(stderr, ">>>channel_gamma %d %f\n", (yyvsp[-1].ival), (yyvsp[0].dval));
+	  if ((yyvsp[-1].ival) >= 0 && (yyvsp[-1].ival) <= STP_CHANNEL_LIMIT)
+	    global_gammas[(yyvsp[-1].ival)] = (yyvsp[0].dval);
 	}
     break;
 
@@ -1421,8 +1542,8 @@ yyreduce:
 #line 272 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>global_gamma %f\n", yyvsp[0].dval);
-	  global_gamma = yyvsp[0].dval;
+	    fprintf(stderr, ">>>global_gamma %f\n", (yyvsp[0].dval));
+	  global_gamma = (yyvsp[0].dval);
 	}
     break;
 
@@ -1430,8 +1551,8 @@ yyreduce:
 #line 279 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>steps %d\n", yyvsp[0].ival);
-	  global_steps = yyvsp[0].ival;
+	    fprintf(stderr, ">>>steps %d\n", (yyvsp[0].ival));
+	  global_steps = (yyvsp[0].ival);
 	}
     break;
 
@@ -1439,8 +1560,8 @@ yyreduce:
 #line 286 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>ink_limit %f\n", yyvsp[0].dval);
-	  global_ink_limit = yyvsp[0].dval;
+	    fprintf(stderr, ">>>ink_limit %f\n", (yyvsp[0].dval));
+	  global_ink_limit = (yyvsp[0].dval);
 	}
     break;
 
@@ -1448,9 +1569,9 @@ yyreduce:
 #line 293 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>printer %s\n", yyvsp[0].sval);
-	  global_printer = strdup(yyvsp[0].sval);
-	  free(yyvsp[0].sval);
+	    fprintf(stderr, ">>>printer %s\n", (yyvsp[0].sval));
+	  global_printer = strdup((yyvsp[0].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
@@ -1458,9 +1579,9 @@ yyreduce:
 #line 302 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>page_size_name %s\n", yyvsp[0].sval);
-	  stp_set_string_parameter(global_vars, "PageSize", yyvsp[0].sval);
-	  free(yyvsp[0].sval);
+	    fprintf(stderr, ">>>page_size_name %s\n", (yyvsp[0].sval));
+	  stp_set_string_parameter(global_vars, "PageSize", (yyvsp[0].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
@@ -1468,9 +1589,9 @@ yyreduce:
 #line 311 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>page_size_custom %d %d\n", yyvsp[-1].ival, yyvsp[0].ival);
-	  stp_set_page_width(global_vars, yyvsp[-1].ival);
-	  stp_set_page_height(global_vars, yyvsp[0].ival);
+	    fprintf(stderr, ">>>page_size_custom %d %d\n", (yyvsp[-1].ival), (yyvsp[0].ival));
+	  stp_set_page_width(global_vars, (yyvsp[-1].ival));
+	  stp_set_page_height(global_vars, (yyvsp[0].ival));
 	}
     break;
 
@@ -1478,10 +1599,10 @@ yyreduce:
 #line 323 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>parameter_string %s %s\n", yyvsp[-1].sval, yyvsp[0].sval);
-	  stp_set_string_parameter(global_vars, yyvsp[-1].sval, yyvsp[0].sval);
-	  free(yyvsp[-1].sval);
-	  free(yyvsp[0].sval);
+	    fprintf(stderr, ">>>parameter_string %s %s\n", (yyvsp[-1].sval), (yyvsp[0].sval));
+	  stp_set_string_parameter(global_vars, (yyvsp[-1].sval), (yyvsp[0].sval));
+	  free((yyvsp[-1].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
@@ -1489,9 +1610,9 @@ yyreduce:
 #line 333 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>parameter_int %s %d\n", yyvsp[-1].sval, yyvsp[0].ival);
-	  stp_set_int_parameter(global_vars, yyvsp[-1].sval, yyvsp[0].ival);
-	  free(yyvsp[-1].sval);
+	    fprintf(stderr, ">>>parameter_int %s %d\n", (yyvsp[-1].sval), (yyvsp[0].ival));
+	  stp_set_int_parameter(global_vars, (yyvsp[-1].sval), (yyvsp[0].ival));
+	  free((yyvsp[-1].sval));
 	}
     break;
 
@@ -1499,9 +1620,9 @@ yyreduce:
 #line 342 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>parameter_float %s %f\n", yyvsp[-1].sval, yyvsp[0].dval);
-	  stp_set_float_parameter(global_vars, yyvsp[-1].sval, yyvsp[0].dval);
-	  free(yyvsp[-1].sval);
+	    fprintf(stderr, ">>>parameter_float %s %f\n", (yyvsp[-1].sval), (yyvsp[0].dval));
+	  stp_set_float_parameter(global_vars, (yyvsp[-1].sval), (yyvsp[0].dval));
+	  free((yyvsp[-1].sval));
 	}
     break;
 
@@ -1509,8 +1630,8 @@ yyreduce:
 #line 367 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>density %f\n", yyvsp[0].dval);
-	  global_density = yyvsp[0].dval;
+	    fprintf(stderr, ">>>density %f\n", (yyvsp[0].dval));
+	  global_density = (yyvsp[0].dval);
 	}
     break;
 
@@ -1518,8 +1639,8 @@ yyreduce:
 #line 374 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>top %f\n", yyvsp[0].dval);
-	  global_xtop = yyvsp[0].dval;
+	    fprintf(stderr, ">>>top %f\n", (yyvsp[0].dval));
+	  global_xtop = (yyvsp[0].dval);
 	}
     break;
 
@@ -1527,8 +1648,8 @@ yyreduce:
 #line 381 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>left %f\n", yyvsp[0].dval);
-	  global_xleft = yyvsp[0].dval;
+	    fprintf(stderr, ">>>left %f\n", (yyvsp[0].dval));
+	  global_xleft = (yyvsp[0].dval);
 	}
     break;
 
@@ -1536,8 +1657,8 @@ yyreduce:
 #line 388 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>hsize %f\n", yyvsp[0].dval);
-	  global_hsize = yyvsp[0].dval;
+	    fprintf(stderr, ">>>hsize %f\n", (yyvsp[0].dval));
+	  global_hsize = (yyvsp[0].dval);
 	}
     break;
 
@@ -1545,8 +1666,8 @@ yyreduce:
 #line 395 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>vsize %f\n", yyvsp[0].dval);
-	  global_vsize = yyvsp[0].dval;
+	    fprintf(stderr, ">>>vsize %f\n", (yyvsp[0].dval));
+	  global_vsize = (yyvsp[0].dval);
 	}
     break;
 
@@ -1554,8 +1675,8 @@ yyreduce:
 #line 402 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>blackline %d\n", yyvsp[0].ival);
-	  global_noblackline = !(yyvsp[0].ival);
+	    fprintf(stderr, ">>>blackline %d\n", (yyvsp[0].ival));
+	  global_noblackline = !((yyvsp[0].ival));
 	}
     break;
 
@@ -1563,13 +1684,13 @@ yyreduce:
 #line 410 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>color_block1 %f %f %f (%d)\n", yyvsp[-2].dval, yyvsp[-1].dval, yyvsp[0].dval,
+	    fprintf(stderr, ">>>color_block1 %f %f %f (%d)\n", (yyvsp[-2].dval), (yyvsp[-1].dval), (yyvsp[0].dval),
 		    current_index);
 	  if (current_index < STP_CHANNEL_LIMIT)
 	    {
-	      current_testpattern->d.p.mins[current_index] = yyvsp[-2].dval;
-	      current_testpattern->d.p.vals[current_index] = yyvsp[-1].dval;
-	      current_testpattern->d.p.gammas[current_index] = yyvsp[0].dval;
+	      current_testpattern->d.p.mins[current_index] = (yyvsp[-2].dval);
+	      current_testpattern->d.p.vals[current_index] = (yyvsp[-1].dval);
+	      current_testpattern->d.p.gammas[current_index] = (yyvsp[0].dval);
 	      current_index++;
 	    }
 	}
@@ -1578,14 +1699,14 @@ yyreduce:
   case 55:
 #line 434 "testpatterny.y"
     {
-	  int channel = find_color(yyvsp[-3].sval);
+	  int channel = find_color((yyvsp[-3]).sval);
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>color_block2a %s %f %f %f\n", yyvsp[-3].sval, yyvsp[-2].dval, yyvsp[-1].dval, yyvsp[0].dval);
+	    fprintf(stderr, ">>>color_block2a %s %f %f %f\n", (yyvsp[-3]).sval, (yyvsp[-2].dval), (yyvsp[-1].dval), (yyvsp[0].dval));
 	  if (channel >= 0 && channel < STP_CHANNEL_LIMIT)
 	    {
-	      current_testpattern->d.p.mins[channel] = yyvsp[-2].dval;
-	      current_testpattern->d.p.vals[channel] = yyvsp[-1].dval;
-	      current_testpattern->d.p.gammas[channel] = yyvsp[0].dval;
+	      current_testpattern->d.p.mins[channel] = (yyvsp[-2].dval);
+	      current_testpattern->d.p.vals[channel] = (yyvsp[-1].dval);
+	      current_testpattern->d.p.gammas[channel] = (yyvsp[0].dval);
 	    }
 	}
     break;
@@ -1594,12 +1715,12 @@ yyreduce:
 #line 448 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>color_block2b %d %f %f %f\n", yyvsp[-3].ival, yyvsp[-2].dval, yyvsp[-1].dval, yyvsp[0].dval);
-	  if (yyvsp[-3].ival >= 0 && yyvsp[-3].ival < STP_CHANNEL_LIMIT)
+	    fprintf(stderr, ">>>color_block2b %d %f %f %f\n", (yyvsp[-3].ival), (yyvsp[-2].dval), (yyvsp[-1].dval), (yyvsp[0].dval));
+	  if ((yyvsp[-3].ival) >= 0 && (yyvsp[-3].ival) < STP_CHANNEL_LIMIT)
 	    {
-	      current_testpattern->d.p.mins[yyvsp[-3].ival] = yyvsp[-2].dval;
-	      current_testpattern->d.p.vals[yyvsp[-3].ival] = yyvsp[-1].dval;
-	      current_testpattern->d.p.gammas[yyvsp[-3].ival] = yyvsp[0].dval;
+	      current_testpattern->d.p.mins[(yyvsp[-3].ival)] = (yyvsp[-2].dval);
+	      current_testpattern->d.p.vals[(yyvsp[-3].ival)] = (yyvsp[-1].dval);
+	      current_testpattern->d.p.gammas[(yyvsp[-3].ival)] = (yyvsp[0].dval);
 	    }
 	}
     break;
@@ -1608,13 +1729,13 @@ yyreduce:
 #line 473 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>patvars %f %f %f %f %f\n", yyvsp[-4].dval, yyvsp[-3].dval, yyvsp[-2].dval, yyvsp[-1].dval, yyvsp[0].dval);
+	    fprintf(stderr, ">>>patvars %f %f %f %f %f\n", (yyvsp[-4].dval), (yyvsp[-3].dval), (yyvsp[-2].dval), (yyvsp[-1].dval), (yyvsp[0].dval));
 	  current_testpattern->t = E_PATTERN;
-	  current_testpattern->d.p.lower = yyvsp[-4].dval;
-	  current_testpattern->d.p.upper = yyvsp[-3].dval;
-	  current_testpattern->d.p.levels[1] = yyvsp[-2].dval;
-	  current_testpattern->d.p.levels[2] = yyvsp[-1].dval;
-	  current_testpattern->d.p.levels[3] = yyvsp[0].dval;
+	  current_testpattern->d.p.lower = (yyvsp[-4].dval);
+	  current_testpattern->d.p.upper = (yyvsp[-3].dval);
+	  current_testpattern->d.p.levels[1] = (yyvsp[-2].dval);
+	  current_testpattern->d.p.levels[2] = (yyvsp[-1].dval);
+	  current_testpattern->d.p.levels[3] = (yyvsp[0].dval);
 	  current_testpattern = get_next_testpattern();
 	  current_index = 0;
 	}
@@ -1640,9 +1761,9 @@ yyreduce:
 #line 506 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>grid %d\n", yyvsp[0].ival);
+	    fprintf(stderr, ">>>grid %d\n", (yyvsp[0].ival));
 	  current_testpattern->t = E_GRID;
-	  current_testpattern->d.g.ticks = yyvsp[0].ival;
+	  current_testpattern->d.g.ticks = (yyvsp[0].ival);
 	  current_testpattern = get_next_testpattern();
 	  current_index = 0;
 	}
@@ -1652,10 +1773,10 @@ yyreduce:
 #line 517 "testpatterny.y"
     {
 	  if (getenv("STP_TESTPATTERN_DEBUG"))
-	    fprintf(stderr, ">>>image %d %d\n", yyvsp[-1].ival, yyvsp[0].ival);
+	    fprintf(stderr, ">>>image %d %d\n", (yyvsp[-1].ival), (yyvsp[0].ival));
 	  current_testpattern->t = E_IMAGE;
-	  current_testpattern->d.i.x = yyvsp[-1].ival;
-	  current_testpattern->d.i.y = yyvsp[0].ival;
+	  current_testpattern->d.i.x = (yyvsp[-1].ival);
+	  current_testpattern->d.i.y = (yyvsp[0].ival);
 	  if (current_testpattern->d.i.x <= 0 ||
 	      current_testpattern->d.i.y <= 0)
 	    {
@@ -1669,50 +1790,50 @@ yyreduce:
   case 70:
 #line 534 "testpatterny.y"
     {
-	  fprintf(stderr, yyvsp[0].sval);
-	  free(yyvsp[0].sval);
+	  fprintf(stderr, (yyvsp[0].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
   case 71:
 #line 540 "testpatterny.y"
     {
-	  fprintf(stderr, yyvsp[-1].sval, yyvsp[0].sval);
-	  free(yyvsp[-1].sval);
-	  free(yyvsp[0].sval);
+	  fprintf(stderr, (yyvsp[-1].sval), (yyvsp[0].sval));
+	  free((yyvsp[-1].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
   case 72:
 #line 547 "testpatterny.y"
     {
-	  fprintf(stderr, yyvsp[-2].sval, yyvsp[-1].sval, yyvsp[0].sval);
-	  free(yyvsp[-2].sval);
-	  free(yyvsp[-1].sval);
-	  free(yyvsp[0].sval);
+	  fprintf(stderr, (yyvsp[-2].sval), (yyvsp[-1].sval), (yyvsp[0].sval));
+	  free((yyvsp[-2].sval));
+	  free((yyvsp[-1].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
   case 73:
 #line 555 "testpatterny.y"
     {
-	  fprintf(stderr, yyvsp[-3].sval, yyvsp[-2].sval, yyvsp[-1].sval, yyvsp[0].sval);
-	  free(yyvsp[-3].sval);
-	  free(yyvsp[-2].sval);
-	  free(yyvsp[-1].sval);
-	  free(yyvsp[0].sval);
+	  fprintf(stderr, (yyvsp[-3].sval), (yyvsp[-2].sval), (yyvsp[-1].sval), (yyvsp[0].sval));
+	  free((yyvsp[-3].sval));
+	  free((yyvsp[-2].sval));
+	  free((yyvsp[-1].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
   case 74:
 #line 564 "testpatterny.y"
     {
-	  fprintf(stderr, yyvsp[-4].sval, yyvsp[-3].sval, yyvsp[-2].sval, yyvsp[-1].sval, yyvsp[0].sval);
-	  free(yyvsp[-4].sval);
-	  free(yyvsp[-3].sval);
-	  free(yyvsp[-2].sval);
-	  free(yyvsp[-1].sval);
-	  free(yyvsp[0].sval);
+	  fprintf(stderr, (yyvsp[-4].sval), (yyvsp[-3].sval), (yyvsp[-2].sval), (yyvsp[-1].sval), (yyvsp[0].sval));
+	  free((yyvsp[-4].sval));
+	  free((yyvsp[-3].sval));
+	  free((yyvsp[-2].sval));
+	  free((yyvsp[-1].sval));
+	  free((yyvsp[0].sval));
 	}
     break;
 
@@ -1744,10 +1865,11 @@ yyreduce:
     break;
 
 
+      default: break;
     }
 
-/* Line 991 of yacc.c.  */
-#line 1750 "testpatterny.c"
+/* Line 1126 of yacc.c.  */
+#line 1873 "testpatterny.c"
 
   yyvsp -= yylen;
   yyssp -= yylen;
@@ -1786,104 +1908,153 @@ yyerrlab:
 
       if (YYPACT_NINF < yyn && yyn < YYLAST)
 	{
-	  YYSIZE_T yysize = 0;
 	  int yytype = YYTRANSLATE (yychar);
-	  char *yymsg;
-	  int yyx, yycount;
+	  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+	  YYSIZE_T yysize = yysize0;
+	  YYSIZE_T yysize1;
+	  int yysize_overflow = 0;
+	  char *yymsg = 0;
+#	  define YYERROR_VERBOSE_ARGS_MAXIMUM 5
+	  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+	  int yyx;
+
+#if 0
+	  /* This is so xgettext sees the translatable formats that are
+	     constructed on the fly.  */
+	  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;
 
-	  yycount = 0;
 	  /* Start YYX at -YYN if negative to avoid negative indexes in
 	     YYCHECK.  */
-	  for (yyx = yyn < 0 ? -yyn : 0;
-	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+	  int yyxbegin = yyn < 0 ? -yyn : 0;
+
+	  /* Stay within bounds of both yycheck and yytname.  */
+	  int yychecklim = YYLAST - yyn;
+	  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)
-	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-	  yysize += yystrlen ("syntax error, unexpected ") + 1;
-	  yysize += yystrlen (yytname[yytype]);
-	  yymsg = (char *) YYSTACK_ALLOC (yysize);
-	  if (yymsg != 0)
+	      {
+		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 && yysize <= YYSTACK_ALLOC_MAXIMUM)
+	    yymsg = (char *) YYSTACK_ALLOC (yysize);
+	  if (yymsg)
 	    {
-	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
-	      yyp = yystpcpy (yyp, yytname[yytype]);
-
-	      if (yycount < 5)
+	      /* Avoid sprintf, as that infringes on the user's name space.
+		 Don't have undefined behavior even if the translation
+		 produced a string with the wrong number of "%s"s.  */
+	      char *yyp = yymsg;
+	      int yyi = 0;
+	      while ((*yyp = *yyf))
 		{
-		  yycount = 0;
-		  for (yyx = yyn < 0 ? -yyn : 0;
-		       yyx < (int) (sizeof (yytname) / sizeof (char *));
-		       yyx++)
-		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-		      {
-			const char *yyq = ! yycount ? ", expecting " : " or ";
-			yyp = yystpcpy (yyp, yyq);
-			yyp = yystpcpy (yyp, yytname[yyx]);
-			yycount++;
-		      }
+		  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		    {
+		      yyp += yytnamerr (yyp, yyarg[yyi++]);
+		      yyf += 2;
+		    }
+		  else
+		    {
+		      yyp++;
+		      yyf++;
+		    }
 		}
 	      yyerror (yymsg);
 	      YYSTACK_FREE (yymsg);
 	    }
 	  else
-	    yyerror ("syntax error; also virtual memory exhausted");
+	    {
+	      yyerror (YY_("syntax error"));
+	      goto yyexhaustedlab;
+	    }
 	}
       else
 #endif /* YYERROR_VERBOSE */
-	yyerror ("syntax error");
+	yyerror (YY_("syntax error"));
     }
 
 
 
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
 	 error, discard it.  */
 
-      /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
+      if (yychar <= YYEOF)
         {
-	  /* Pop the error token.  */
-          YYPOPSTACK;
-	  /* Pop the rest of the stack.  */
-	  while (yyss < yyssp)
-	    {
-	      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-	      yydestruct (yystos[*yyssp], yyvsp);
-	      YYPOPSTACK;
-	    }
-	  YYABORT;
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
         }
-
-      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
-      yydestruct (yytoken, &yylval);
-      yychar = YYEMPTY;
-
+      else
+	{
+	  yydestruct ("Error: discarding", yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
-  goto yyerrlab2;
+  goto yyerrlab1;
 
 
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:
-
-  /* Suppress GCC warning that yyerrlab1 is unused when no action
-     invokes YYERROR.  */
-#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__) \
-    && !defined __cplusplus
-  __attribute__ ((__unused__))
-#endif
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
 
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (0)
+     goto yyerrorlab;
 
-  goto yyerrlab2;
+yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
 
 
-/*---------------------------------------------------------------.
-| yyerrlab2 -- pop states until the error token can be shifted.  |
-`---------------------------------------------------------------*/
-yyerrlab2:
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
   yyerrstatus = 3;	/* Each real token shifted decrements this.  */
 
   for (;;)
@@ -1904,22 +2075,22 @@ yyerrlab2:
       if (yyssp == yyss)
 	YYABORT;
 
-      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-      yydestruct (yystos[yystate], yyvsp);
-      yyvsp--;
-      yystate = *--yyssp;
 
+      yydestruct ("Error: popping", yystos[yystate], yyvsp);
+      YYPOPSTACK;
+      yystate = *yyssp;
       YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
-
   *++yyvsp = yylval;
 
 
+  /* Shift the error token. */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
   yystate = yyn;
   goto yynewstate;
 
@@ -1939,16 +2110,25 @@ yyabortlab:
   goto yyreturn;
 
 #ifndef yyoverflow
-/*----------------------------------------------.
-| yyoverflowlab -- parser overflow comes here.  |
-`----------------------------------------------*/
-yyoverflowlab:
-  yyerror ("parser stack overflow");
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
   yyresult = 2;
   /* Fall through.  */
 #endif
 
 yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK;
+    }
 #ifndef yyoverflow
   if (yyss != yyssa)
     YYSTACK_FREE (yyss);