filter/interpret.c

   1 /*
   2  * "$Id: interpret.c 11848 2014-05-07 00:26:44Z msweet $"
   3  *
   4  * PPD command interpreter for CUPS.
   5  *
   6  * Copyright 2007-2014 by Apple Inc.
   7  * Copyright 1993-2007 by Easy Software Products.
   8  *
   9  * These coded instructions, statements, and computer programs are the
  10  * property of Apple Inc. and are protected by Federal copyright
  11  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  * which should have been included with this file.  If this file is
  13  * file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  * This file is subject to the Apple OS-Developed Software exception.
  16  */
  17
  18 /*
  19  * Include necessary headers...
  20  */
  21
  22 #include <cups/raster-private.h>
  23
  24
  25 /*
  26  * Stack values for the PostScript mini-interpreter...
  27  */
  28
  29 typedef enum
  30 {
  31   CUPS_PS_NAME,
  32   CUPS_PS_NUMBER,
  33   CUPS_PS_STRING,
  34   CUPS_PS_BOOLEAN,
  35   CUPS_PS_NULL,
  36   CUPS_PS_START_ARRAY,
  37   CUPS_PS_END_ARRAY,
  38   CUPS_PS_START_DICT,
  39   CUPS_PS_END_DICT,
  40   CUPS_PS_START_PROC,
  41   CUPS_PS_END_PROC,
  42   CUPS_PS_CLEARTOMARK,
  43   CUPS_PS_COPY,
  44   CUPS_PS_DUP,
  45   CUPS_PS_INDEX,
  46   CUPS_PS_POP,
  47   CUPS_PS_ROLL,
  48   CUPS_PS_SETPAGEDEVICE,
  49   CUPS_PS_STOPPED,
  50   CUPS_PS_OTHER
  51 } _cups_ps_type_t;
  52
  53 typedef struct
  54 {
  55   _cups_ps_type_t       type;           /* Object type */
  56   union
  57   {
  58     int         boolean;                /* Boolean value */
  59     char        name[64];               /* Name value */
  60     double      number;                 /* Number value */
  61     char        other[64];              /* Other operator */
  62     char        string[64];             /* Sring value */
  63   }                     value;          /* Value */
  64 } _cups_ps_obj_t;
  65
  66 typedef struct
  67 {
  68   int                   num_objs,       /* Number of objects on stack */
  69                         alloc_objs;     /* Number of allocated objects */
  70   _cups_ps_obj_t        *objs;          /* Objects in stack */
  71 } _cups_ps_stack_t;
  72
  73
  74 /*
  75  * Local functions...
  76  */
  77
  78 static int              cleartomark_stack(_cups_ps_stack_t *st);
  79 static int              copy_stack(_cups_ps_stack_t *st, int count);
  80 static void             delete_stack(_cups_ps_stack_t *st);
  81 static void             error_object(_cups_ps_obj_t *obj);
  82 static void             error_stack(_cups_ps_stack_t *st, const char *title);
  83 static _cups_ps_obj_t   *index_stack(_cups_ps_stack_t *st, int n);
  84 static _cups_ps_stack_t *new_stack(void);
  85 static _cups_ps_obj_t   *pop_stack(_cups_ps_stack_t *st);
  86 static _cups_ps_obj_t   *push_stack(_cups_ps_stack_t *st,
  87                                     _cups_ps_obj_t *obj);
  88 static int              roll_stack(_cups_ps_stack_t *st, int c, int s);
  89 static _cups_ps_obj_t   *scan_ps(_cups_ps_stack_t *st, char **ptr);
  90 static int              setpagedevice(_cups_ps_stack_t *st,
  91                                         cups_page_header2_t *h,
  92                                         int *preferred_bits);
  93 #ifdef DEBUG
  94 static void             DEBUG_object(_cups_ps_obj_t *obj);
  95 static void             DEBUG_stack(_cups_ps_stack_t *st);
  96 #endif /* DEBUG */
  97
  98
  99 /*
 100  * 'cupsRasterInterpretPPD()' - Interpret PPD commands to create a page header.
 101  *
 102  * This function is used by raster image processing (RIP) filters like
 103  * cgpdftoraster and imagetoraster when writing CUPS raster data for a page.
 104  * It is not used by raster printer driver filters which only read CUPS
 105  * raster data.
 106  *
 107  *
 108  * @code cupsRasterInterpretPPD@ does not mark the options in the PPD using
 109  * the "num_options" and "options" arguments.  Instead, mark the options with
 110  * @code cupsMarkOptions@ and @code ppdMarkOption@ prior to calling it -
 111  * this allows for per-page options without manipulating the options array.
 112  *
 113  * The "func" argument specifies an optional callback function that is
 114  * called prior to the computation of the final raster data.  The function
 115  * can make changes to the @link cups_page_header2_t@ data as needed to use a
 116  * supported raster format and then returns 0 on success and -1 if the
 117  * requested attributes cannot be supported.
 118  *
 119  *
 120  * @code cupsRasterInterpretPPD@ supports a subset of the PostScript language.
 121  * Currently only the @code [@, @code ]@, @code <<@, @code >>@, @code {@,
 122  * @code }@, @code cleartomark@, @code copy@, @code dup@, @code index@,
 123  * @code pop@, @code roll@, @code setpagedevice@, and @code stopped@ operators
 124  * are supported.
 125  *
 126  * @since CUPS 1.2/OS X 10.5@
 127  */
 128
 129 int                                     /* O - 0 on success, -1 on failure */
 130 cupsRasterInterpretPPD(
 131     cups_page_header2_t *h,             /* O - Page header to create */
 132     ppd_file_t          *ppd,           /* I - PPD file */
 133     int                 num_options,    /* I - Number of options */
 134     cups_option_t       *options,       /* I - Options */
 135     cups_interpret_cb_t func)           /* I - Optional page header callback (@code NULL@ for none) */
 136 {
 137   int           status;                 /* Cummulative status */
 138   char          *code;                  /* Code to run */
 139   const char    *val;                   /* Option value */
 140   ppd_size_t    *size;                  /* Current size */
 141   float         left,                   /* Left position */
 142                 bottom,                 /* Bottom position */
 143                 right,                  /* Right position */
 144                 top,                    /* Top position */
 145                 temp1, temp2;           /* Temporary variables for swapping */
 146   int           preferred_bits;         /* Preferred bits per color */
 147
 148
 149  /*
 150   * Range check input...
 151   */
 152
 153   _cupsRasterClearError();
 154
 155   if (!h)
 156   {
 157     _cupsRasterAddError("Page header cannot be NULL!\n");
 158     return (-1);
 159   }
 160
 161  /*
 162   * Reset the page header to the defaults...
 163   */
 164
 165   memset(h, 0, sizeof(cups_page_header2_t));
 166
 167   h->NumCopies                   = 1;
 168   h->PageSize[0]                 = 612;
 169   h->PageSize[1]                 = 792;
 170   h->HWResolution[0]             = 100;
 171   h->HWResolution[1]             = 100;
 172   h->cupsBitsPerColor            = 1;
 173   h->cupsColorOrder              = CUPS_ORDER_CHUNKED;
 174   h->cupsColorSpace              = CUPS_CSPACE_K;
 175   h->cupsBorderlessScalingFactor = 1.0f;
 176   h->cupsPageSize[0]             = 612.0f;
 177   h->cupsPageSize[1]             = 792.0f;
 178   h->cupsImagingBBox[0]          = 0.0f;
 179   h->cupsImagingBBox[1]          = 0.0f;
 180   h->cupsImagingBBox[2]          = 612.0f;
 181   h->cupsImagingBBox[3]          = 792.0f;
 182
 183   strlcpy(h->cupsPageSizeName, "Letter", sizeof(h->cupsPageSizeName));
 184
 185 #ifdef __APPLE__
 186  /*
 187   * cupsInteger0 is also used for the total page count on OS X; set an
 188   * uncommon default value so we can tell if the driver is using cupsInteger0.
 189   */
 190
 191   h->cupsInteger[0] = 0x80000000;
 192 #endif /* __APPLE__ */
 193
 194  /*
 195   * Apply patches and options to the page header...
 196   */
 197
 198   status         = 0;
 199   preferred_bits = 0;
 200
 201   if (ppd)
 202   {
 203    /*
 204     * Apply any patch code (used to override the defaults...)
 205     */
 206
 207     if (ppd->patches)
 208       status |= _cupsRasterExecPS(h, &preferred_bits, ppd->patches);
 209
 210    /*
 211     * Then apply printer options in the proper order...
 212     */
 213
 214     if ((code = ppdEmitString(ppd, PPD_ORDER_DOCUMENT, 0.0)) != NULL)
 215     {
 216       status |= _cupsRasterExecPS(h, &preferred_bits, code);
 217       free(code);
 218     }
 219
 220     if ((code = ppdEmitString(ppd, PPD_ORDER_ANY, 0.0)) != NULL)
 221     {
 222       status |= _cupsRasterExecPS(h, &preferred_bits, code);
 223       free(code);
 224     }
 225
 226     if ((code = ppdEmitString(ppd, PPD_ORDER_PROLOG, 0.0)) != NULL)
 227     {
 228       status |= _cupsRasterExecPS(h, &preferred_bits, code);
 229       free(code);
 230     }
 231
 232     if ((code = ppdEmitString(ppd, PPD_ORDER_PAGE, 0.0)) != NULL)
 233     {
 234       status |= _cupsRasterExecPS(h, &preferred_bits, code);
 235       free(code);
 236     }
 237   }
 238
 239  /*
 240   * Allow option override for page scaling...
 241   */
 242
 243   if ((val = cupsGetOption("cupsBorderlessScalingFactor", num_options,
 244                            options)) != NULL)
 245   {
 246     double sc = atof(val);              /* Scale factor */
 247
 248     if (sc >= 0.1 && sc <= 2.0)
 249       h->cupsBorderlessScalingFactor = (float)sc;
 250   }
 251
 252  /*
 253   * Get the margins for the current size...
 254   */
 255
 256   if ((size = ppdPageSize(ppd, NULL)) != NULL)
 257   {
 258    /*
 259     * Use the margins from the PPD file...
 260     */
 261
 262     left   = size->left;
 263     bottom = size->bottom;
 264     right  = size->right;
 265     top    = size->top;
 266
 267     strlcpy(h->cupsPageSizeName, size->name, sizeof(h->cupsPageSizeName));
 268
 269     h->cupsPageSize[0] = size->width;
 270     h->cupsPageSize[1] = size->length;
 271   }
 272   else
 273   {
 274    /*
 275     * Use the default margins...
 276     */
 277
 278     left   = 0.0f;
 279     bottom = 0.0f;
 280     right  = 612.0f;
 281     top    = 792.0f;
 282   }
 283
 284  /*
 285   * Handle orientation...
 286   */
 287
 288   switch (h->Orientation)
 289   {
 290     case CUPS_ORIENT_0 :
 291     default :
 292         /* Do nothing */
 293         break;
 294
 295     case CUPS_ORIENT_90 :
 296         temp1              = h->cupsPageSize[0];
 297         h->cupsPageSize[0] = h->cupsPageSize[1];
 298         h->cupsPageSize[1] = temp1;
 299
 300         temp1  = left;
 301         temp2  = right;
 302         left   = h->cupsPageSize[0] - top;
 303         right  = h->cupsPageSize[0] - bottom;
 304         bottom = h->cupsPageSize[1] - temp1;
 305         top    = h->cupsPageSize[1] - temp2;
 306         break;
 307
 308     case CUPS_ORIENT_180 :
 309         temp1  = left;
 310         temp2  = bottom;
 311         left   = h->cupsPageSize[0] - right;
 312         right  = h->cupsPageSize[0] - temp1;
 313         bottom = h->cupsPageSize[1] - top;
 314         top    = h->cupsPageSize[1] - temp2;
 315         break;
 316
 317     case CUPS_ORIENT_270 :
 318         temp1              = h->cupsPageSize[0];
 319         h->cupsPageSize[0] = h->cupsPageSize[1];
 320         h->cupsPageSize[1] = temp1;
 321
 322         temp1  = left;
 323         temp2  = right;
 324         left   = bottom;
 325         right  = top;
 326         bottom = h->cupsPageSize[1] - temp2;
 327         top    = h->cupsPageSize[1] - temp1;
 328         break;
 329   }
 330
 331   if (left > right)
 332   {
 333     temp1 = left;
 334     left  = right;
 335     right = temp1;
 336   }
 337
 338   if (bottom > top)
 339   {
 340     temp1  = bottom;
 341     bottom = top;
 342     top    = temp1;
 343   }
 344
 345   h->PageSize[0]           = (unsigned)(h->cupsPageSize[0] *
 346                                         h->cupsBorderlessScalingFactor);
 347   h->PageSize[1]           = (unsigned)(h->cupsPageSize[1] *
 348                                         h->cupsBorderlessScalingFactor);
 349   h->Margins[0]            = (unsigned)(left *
 350                                         h->cupsBorderlessScalingFactor);
 351   h->Margins[1]            = (unsigned)(bottom *
 352                                         h->cupsBorderlessScalingFactor);
 353   h->ImagingBoundingBox[0] = (unsigned)(left *
 354                                         h->cupsBorderlessScalingFactor);
 355   h->ImagingBoundingBox[1] = (unsigned)(bottom *
 356                                         h->cupsBorderlessScalingFactor);
 357   h->ImagingBoundingBox[2] = (unsigned)(right *
 358                                         h->cupsBorderlessScalingFactor);
 359   h->ImagingBoundingBox[3] = (unsigned)(top *
 360                                         h->cupsBorderlessScalingFactor);
 361   h->cupsImagingBBox[0]    = (float)left;
 362   h->cupsImagingBBox[1]    = (float)bottom;
 363   h->cupsImagingBBox[2]    = (float)right;
 364   h->cupsImagingBBox[3]    = (float)top;
 365
 366  /*
 367   * Use the callback to validate the page header...
 368   */
 369
 370   if (func && (*func)(h, preferred_bits))
 371   {
 372     _cupsRasterAddError("Page header callback returned error.\n");
 373     return (-1);
 374   }
 375
 376  /*
 377   * Check parameters...
 378   */
 379
 380   if (!h->HWResolution[0] || !h->HWResolution[1] ||
 381       !h->PageSize[0] || !h->PageSize[1] ||
 382       (h->cupsBitsPerColor != 1 && h->cupsBitsPerColor != 2 &&
 383        h->cupsBitsPerColor != 4 && h->cupsBitsPerColor != 8 &&
 384        h->cupsBitsPerColor != 16) ||
 385       h->cupsBorderlessScalingFactor < 0.1 ||
 386       h->cupsBorderlessScalingFactor > 2.0)
 387   {
 388     _cupsRasterAddError("Page header uses unsupported values.\n");
 389     return (-1);
 390   }
 391
 392  /*
 393   * Compute the bitmap parameters...
 394   */
 395
 396   h->cupsWidth  = (unsigned)((right - left) * h->cupsBorderlessScalingFactor *
 397                         h->HWResolution[0] / 72.0f + 0.5f);
 398   h->cupsHeight = (unsigned)((top - bottom) * h->cupsBorderlessScalingFactor *
 399                         h->HWResolution[1] / 72.0f + 0.5f);
 400
 401   switch (h->cupsColorSpace)
 402   {
 403     case CUPS_CSPACE_W :
 404     case CUPS_CSPACE_K :
 405     case CUPS_CSPACE_WHITE :
 406     case CUPS_CSPACE_GOLD :
 407     case CUPS_CSPACE_SILVER :
 408     case CUPS_CSPACE_SW :
 409         h->cupsNumColors    = 1;
 410         h->cupsBitsPerPixel = h->cupsBitsPerColor;
 411         break;
 412
 413     default :
 414        /*
 415         * Ensure that colorimetric colorspaces use at least 8 bits per
 416         * component...
 417         */
 418
 419         if (h->cupsColorSpace >= CUPS_CSPACE_CIEXYZ &&
 420             h->cupsBitsPerColor < 8)
 421           h->cupsBitsPerColor = 8;
 422
 423        /*
 424         * Figure out the number of bits per pixel...
 425         */
 426
 427         if (h->cupsColorOrder == CUPS_ORDER_CHUNKED)
 428         {
 429           if (h->cupsBitsPerColor >= 8)
 430             h->cupsBitsPerPixel = h->cupsBitsPerColor * 3;
 431           else
 432             h->cupsBitsPerPixel = h->cupsBitsPerColor * 4;
 433         }
 434         else
 435           h->cupsBitsPerPixel = h->cupsBitsPerColor;
 436
 437         h->cupsNumColors = 3;
 438         break;
 439
 440     case CUPS_CSPACE_KCMYcm :
 441         if (h->cupsBitsPerColor == 1)
 442         {
 443           if (h->cupsColorOrder == CUPS_ORDER_CHUNKED)
 444             h->cupsBitsPerPixel = 8;
 445           else
 446             h->cupsBitsPerPixel = 1;
 447
 448           h->cupsNumColors = 6;
 449           break;
 450         }
 451
 452        /*
 453         * Fall through to CMYK code...
 454         */
 455
 456     case CUPS_CSPACE_RGBA :
 457     case CUPS_CSPACE_RGBW :
 458     case CUPS_CSPACE_CMYK :
 459     case CUPS_CSPACE_YMCK :
 460     case CUPS_CSPACE_KCMY :
 461     case CUPS_CSPACE_GMCK :
 462     case CUPS_CSPACE_GMCS :
 463         if (h->cupsColorOrder == CUPS_ORDER_CHUNKED)
 464           h->cupsBitsPerPixel = h->cupsBitsPerColor * 4;
 465         else
 466           h->cupsBitsPerPixel = h->cupsBitsPerColor;
 467
 468         h->cupsNumColors = 4;
 469         break;
 470
 471     case CUPS_CSPACE_DEVICE1 :
 472     case CUPS_CSPACE_DEVICE2 :
 473     case CUPS_CSPACE_DEVICE3 :
 474     case CUPS_CSPACE_DEVICE4 :
 475     case CUPS_CSPACE_DEVICE5 :
 476     case CUPS_CSPACE_DEVICE6 :
 477     case CUPS_CSPACE_DEVICE7 :
 478     case CUPS_CSPACE_DEVICE8 :
 479     case CUPS_CSPACE_DEVICE9 :
 480     case CUPS_CSPACE_DEVICEA :
 481     case CUPS_CSPACE_DEVICEB :
 482     case CUPS_CSPACE_DEVICEC :
 483     case CUPS_CSPACE_DEVICED :
 484     case CUPS_CSPACE_DEVICEE :
 485     case CUPS_CSPACE_DEVICEF :
 486         h->cupsNumColors = h->cupsColorSpace - CUPS_CSPACE_DEVICE1 + 1;
 487
 488         if (h->cupsColorOrder == CUPS_ORDER_CHUNKED)
 489           h->cupsBitsPerPixel = h->cupsBitsPerColor * h->cupsNumColors;
 490         else
 491           h->cupsBitsPerPixel = h->cupsBitsPerColor;
 492         break;
 493   }
 494
 495   h->cupsBytesPerLine = (h->cupsBitsPerPixel * h->cupsWidth + 7) / 8;
 496
 497   if (h->cupsColorOrder == CUPS_ORDER_BANDED)
 498     h->cupsBytesPerLine *= h->cupsNumColors;
 499
 500   return (status);
 501 }
 502
 503
 504 /*
 505  * '_cupsRasterExecPS()' - Execute PostScript code to initialize a page header.
 506  */
 507
 508 int                                     /* O - 0 on success, -1 on error */
 509 _cupsRasterExecPS(
 510     cups_page_header2_t *h,             /* O - Page header */
 511     int                 *preferred_bits,/* O - Preferred bits per color */
 512     const char          *code)          /* I - PS code to execute */
 513 {
 514   int                   error = 0;      /* Error condition? */
 515   _cups_ps_stack_t      *st;            /* PostScript value stack */
 516   _cups_ps_obj_t        *obj;           /* Object from top of stack */
 517   char                  *codecopy,      /* Copy of code */
 518                         *codeptr;       /* Pointer into copy of code */
 519
 520
 521   DEBUG_printf(("_cupsRasterExecPS(h=%p, preferred_bits=%p, code=\"%s\")\n",
 522                 h, preferred_bits, code));
 523
 524  /*
 525   * Copy the PostScript code and create a stack...
 526   */
 527
 528   if ((codecopy = strdup(code)) == NULL)
 529   {
 530     _cupsRasterAddError("Unable to duplicate code string.\n");
 531     return (-1);
 532   }
 533
 534   if ((st = new_stack()) == NULL)
 535   {
 536     _cupsRasterAddError("Unable to create stack.\n");
 537     free(codecopy);
 538     return (-1);
 539   }
 540
 541  /*
 542   * Parse the PS string until we run out of data...
 543   */
 544
 545   codeptr = codecopy;
 546
 547   while ((obj = scan_ps(st, &codeptr)) != NULL)
 548   {
 549 #ifdef DEBUG
 550     DEBUG_printf(("_cupsRasterExecPS: Stack (%d objects)\n", st->num_objs));
 551     DEBUG_object(obj);
 552 #endif /* DEBUG */
 553
 554     switch (obj->type)
 555     {
 556       default :
 557           /* Do nothing for regular values */
 558           break;
 559
 560       case CUPS_PS_CLEARTOMARK :
 561           pop_stack(st);
 562
 563           if (cleartomark_stack(st))
 564             _cupsRasterAddError("cleartomark: Stack underflow!\n");
 565
 566 #ifdef DEBUG
 567           DEBUG_puts("    dup: ");
 568           DEBUG_stack(st);
 569 #endif /* DEBUG */
 570           break;
 571
 572       case CUPS_PS_COPY :
 573           pop_stack(st);
 574           if ((obj = pop_stack(st)) != NULL)
 575           {
 576             copy_stack(st, (int)obj->value.number);
 577
 578 #ifdef DEBUG
 579             DEBUG_puts("_cupsRasterExecPS: copy");
 580             DEBUG_stack(st);
 581 #endif /* DEBUG */
 582           }
 583           break;
 584
 585       case CUPS_PS_DUP :
 586           pop_stack(st);
 587           copy_stack(st, 1);
 588
 589 #ifdef DEBUG
 590           DEBUG_puts("_cupsRasterExecPS: dup");
 591           DEBUG_stack(st);
 592 #endif /* DEBUG */
 593           break;
 594
 595       case CUPS_PS_INDEX :
 596           pop_stack(st);
 597           if ((obj = pop_stack(st)) != NULL)
 598           {
 599             index_stack(st, (int)obj->value.number);
 600
 601 #ifdef DEBUG
 602             DEBUG_puts("_cupsRasterExecPS: index");
 603             DEBUG_stack(st);
 604 #endif /* DEBUG */
 605           }
 606           break;
 607
 608       case CUPS_PS_POP :
 609           pop_stack(st);
 610           pop_stack(st);
 611
 612 #ifdef DEBUG
 613           DEBUG_puts("_cupsRasterExecPS: pop");
 614           DEBUG_stack(st);
 615 #endif /* DEBUG */
 616           break;
 617
 618       case CUPS_PS_ROLL :
 619           pop_stack(st);
 620           if ((obj = pop_stack(st)) != NULL)
 621           {
 622             int         c;              /* Count */
 623
 624
 625             c = (int)obj->value.number;
 626
 627             if ((obj = pop_stack(st)) != NULL)
 628             {
 629               roll_stack(st, (int)obj->value.number, c);
 630
 631 #ifdef DEBUG
 632               DEBUG_puts("_cupsRasterExecPS: roll");
 633               DEBUG_stack(st);
 634 #endif /* DEBUG */
 635             }
 636           }
 637           break;
 638
 639       case CUPS_PS_SETPAGEDEVICE :
 640           pop_stack(st);
 641           setpagedevice(st, h, preferred_bits);
 642
 643 #ifdef DEBUG
 644           DEBUG_puts("_cupsRasterExecPS: setpagedevice");
 645           DEBUG_stack(st);
 646 #endif /* DEBUG */
 647           break;
 648
 649       case CUPS_PS_START_PROC :
 650       case CUPS_PS_END_PROC :
 651       case CUPS_PS_STOPPED :
 652           pop_stack(st);
 653           break;
 654
 655       case CUPS_PS_OTHER :
 656           _cupsRasterAddError("Unknown operator \"%s\"!\n", obj->value.other);
 657           error = 1;
 658           DEBUG_printf(("_cupsRasterExecPS: Unknown operator \"%s\"!\n",
 659                         obj->value.other));
 660           break;
 661     }
 662
 663     if (error)
 664       break;
 665   }
 666
 667  /*
 668   * Cleanup...
 669   */
 670
 671   free(codecopy);
 672
 673   if (st->num_objs > 0)
 674   {
 675     error_stack(st, "Stack not empty:");
 676
 677 #ifdef DEBUG
 678     DEBUG_puts("_cupsRasterExecPS: Stack not empty:");
 679     DEBUG_stack(st);
 680 #endif /* DEBUG */
 681
 682     delete_stack(st);
 683
 684     return (-1);
 685   }
 686
 687   delete_stack(st);
 688
 689  /*
 690   * Return success...
 691   */
 692
 693   return (0);
 694 }
 695
 696
 697 /*
 698  * 'cleartomark_stack()' - Clear to the last mark ([) on the stack.
 699  */
 700
 701 static int                              /* O - 0 on success, -1 on error */
 702 cleartomark_stack(_cups_ps_stack_t *st) /* I - Stack */
 703 {
 704   _cups_ps_obj_t        *obj;           /* Current object on stack */
 705
 706
 707   while ((obj = pop_stack(st)) != NULL)
 708     if (obj->type == CUPS_PS_START_ARRAY)
 709       break;
 710
 711   return (obj ? 0 : -1);
 712 }
 713
 714
 715 /*
 716  * 'copy_stack()' - Copy the top N stack objects.
 717  */
 718
 719 static int                              /* O - 0 on success, -1 on error */
 720 copy_stack(_cups_ps_stack_t *st,        /* I - Stack */
 721            int              c)          /* I - Number of objects to copy */
 722 {
 723   int   n;                              /* Index */
 724
 725
 726   if (c < 0)
 727     return (-1);
 728   else if (c == 0)
 729     return (0);
 730
 731   if ((n = st->num_objs - c) < 0)
 732     return (-1);
 733
 734   while (c > 0)
 735   {
 736     if (!push_stack(st, st->objs + n))
 737       return (-1);
 738
 739     n ++;
 740     c --;
 741   }
 742
 743   return (0);
 744 }
 745
 746
 747 /*
 748  * 'delete_stack()' - Free memory used by a stack.
 749  */
 750
 751 static void
 752 delete_stack(_cups_ps_stack_t *st)      /* I - Stack */
 753 {
 754   free(st->objs);
 755   free(st);
 756 }
 757
 758
 759 /*
 760  * 'error_object()' - Add an object's value to the current error message.
 761  */
 762
 763 static void
 764 error_object(_cups_ps_obj_t *obj)       /* I - Object to add */
 765 {
 766   switch (obj->type)
 767   {
 768     case CUPS_PS_NAME :
 769         _cupsRasterAddError(" /%s", obj->value.name);
 770         break;
 771
 772     case CUPS_PS_NUMBER :
 773         _cupsRasterAddError(" %g", obj->value.number);
 774         break;
 775
 776     case CUPS_PS_STRING :
 777         _cupsRasterAddError(" (%s)", obj->value.string);
 778         break;
 779
 780     case CUPS_PS_BOOLEAN :
 781         if (obj->value.boolean)
 782           _cupsRasterAddError(" true");
 783         else
 784           _cupsRasterAddError(" false");
 785         break;
 786
 787     case CUPS_PS_NULL :
 788         _cupsRasterAddError(" null");
 789         break;
 790
 791     case CUPS_PS_START_ARRAY :
 792         _cupsRasterAddError(" [");
 793         break;
 794
 795     case CUPS_PS_END_ARRAY :
 796         _cupsRasterAddError(" ]");
 797         break;
 798
 799     case CUPS_PS_START_DICT :
 800         _cupsRasterAddError(" <<");
 801         break;
 802
 803     case CUPS_PS_END_DICT :
 804         _cupsRasterAddError(" >>");
 805         break;
 806
 807     case CUPS_PS_START_PROC :
 808         _cupsRasterAddError(" {");
 809         break;
 810
 811     case CUPS_PS_END_PROC :
 812         _cupsRasterAddError(" }");
 813         break;
 814
 815     case CUPS_PS_COPY :
 816         _cupsRasterAddError(" --copy--");
 817         break;
 818
 819     case CUPS_PS_CLEARTOMARK :
 820         _cupsRasterAddError(" --cleartomark--");
 821         break;
 822
 823     case CUPS_PS_DUP :
 824         _cupsRasterAddError(" --dup--");
 825         break;
 826
 827     case CUPS_PS_INDEX :
 828         _cupsRasterAddError(" --index--");
 829         break;
 830
 831     case CUPS_PS_POP :
 832         _cupsRasterAddError(" --pop--");
 833         break;
 834
 835     case CUPS_PS_ROLL :
 836         _cupsRasterAddError(" --roll--");
 837         break;
 838
 839     case CUPS_PS_SETPAGEDEVICE :
 840         _cupsRasterAddError(" --setpagedevice--");
 841         break;
 842
 843     case CUPS_PS_STOPPED :
 844         _cupsRasterAddError(" --stopped--");
 845         break;
 846
 847     case CUPS_PS_OTHER :
 848         _cupsRasterAddError(" --%s--", obj->value.other);
 849         break;
 850   }
 851 }
 852
 853
 854 /*
 855  * 'error_stack()' - Add a stack to the current error message...
 856  */
 857
 858 static void
 859 error_stack(_cups_ps_stack_t *st,       /* I - Stack */
 860             const char       *title)    /* I - Title string */
 861 {
 862   int                   c;              /* Looping var */
 863   _cups_ps_obj_t        *obj;           /* Current object on stack */
 864
 865
 866   _cupsRasterAddError("%s", title);
 867
 868   for (obj = st->objs, c = st->num_objs; c > 0; c --, obj ++)
 869     error_object(obj);
 870
 871   _cupsRasterAddError("\n");
 872 }
 873
 874
 875 /*
 876  * 'index_stack()' - Copy the Nth value on the stack.
 877  */
 878
 879 static _cups_ps_obj_t   *               /* O - New object */
 880 index_stack(_cups_ps_stack_t *st,       /* I - Stack */
 881             int              n)         /* I - Object index */
 882 {
 883   if (n < 0 || (n = st->num_objs - n - 1) < 0)
 884     return (NULL);
 885
 886   return (push_stack(st, st->objs + n));
 887 }
 888
 889
 890 /*
 891  * 'new_stack()' - Create a new stack.
 892  */
 893
 894 static _cups_ps_stack_t *               /* O - New stack */
 895 new_stack(void)
 896 {
 897   _cups_ps_stack_t      *st;            /* New stack */
 898
 899
 900   if ((st = calloc(1, sizeof(_cups_ps_stack_t))) == NULL)
 901     return (NULL);
 902
 903   st->alloc_objs = 32;
 904
 905   if ((st->objs = calloc(32, sizeof(_cups_ps_obj_t))) == NULL)
 906   {
 907     free(st);
 908     return (NULL);
 909   }
 910   else
 911     return (st);
 912 }
 913
 914
 915 /*
 916  * 'pop_stock()' - Pop the top object off the stack.
 917  */
 918
 919 static _cups_ps_obj_t   *               /* O - Object */
 920 pop_stack(_cups_ps_stack_t *st)         /* I - Stack */
 921 {
 922   if (st->num_objs > 0)
 923   {
 924     st->num_objs --;
 925
 926     return (st->objs + st->num_objs);
 927   }
 928   else
 929     return (NULL);
 930 }
 931
 932
 933 /*
 934  * 'push_stack()' - Push an object on the stack.
 935  */
 936
 937 static _cups_ps_obj_t   *               /* O - New object */
 938 push_stack(_cups_ps_stack_t *st,        /* I - Stack */
 939            _cups_ps_obj_t   *obj)       /* I - Object */
 940 {
 941   _cups_ps_obj_t        *temp;          /* New object */
 942
 943
 944   if (st->num_objs >= st->alloc_objs)
 945   {
 946
 947
 948     st->alloc_objs += 32;
 949
 950     if ((temp = realloc(st->objs, (size_t)st->alloc_objs *
 951                                   sizeof(_cups_ps_obj_t))) == NULL)
 952       return (NULL);
 953
 954     st->objs = temp;
 955     memset(temp + st->num_objs, 0, 32 * sizeof(_cups_ps_obj_t));
 956   }
 957
 958   temp = st->objs + st->num_objs;
 959   st->num_objs ++;
 960
 961   memcpy(temp, obj, sizeof(_cups_ps_obj_t));
 962
 963   return (temp);
 964 }
 965
 966
 967 /*
 968  * 'roll_stack()' - Rotate stack objects.
 969  */
 970
 971 static int                              /* O - 0 on success, -1 on error */
 972 roll_stack(_cups_ps_stack_t *st,        /* I - Stack */
 973            int              c,          /* I - Number of objects */
 974            int              s)          /* I - Amount to shift */
 975 {
 976   _cups_ps_obj_t        *temp;          /* Temporary array of objects */
 977   int                   n;              /* Index into array */
 978
 979
 980   DEBUG_printf(("    roll_stack(st=%p, s=%d, c=%d)\n", st, s, c));
 981
 982  /*
 983   * Range check input...
 984   */
 985
 986   if (c < 0)
 987     return (-1);
 988   else if (c == 0)
 989     return (0);
 990
 991   if ((n = st->num_objs - c) < 0)
 992     return (-1);
 993
 994   s %= c;
 995
 996   if (s == 0)
 997     return (0);
 998
 999  /*
1000   * Copy N objects and move things around...
1001   */
1002
1003   if (s < 0)
1004   {
1005    /*
1006     * Shift down...
1007     */
1008
1009     s = -s;
1010
1011     if ((temp = calloc((size_t)s, sizeof(_cups_ps_obj_t))) == NULL)
1012       return (-1);
1013
1014     memcpy(temp, st->objs + n, (size_t)s * sizeof(_cups_ps_obj_t));
1015     memmove(st->objs + n, st->objs + n + s, (size_t)(c - s) * sizeof(_cups_ps_obj_t));
1016     memcpy(st->objs + n + c - s, temp, (size_t)s * sizeof(_cups_ps_obj_t));
1017   }
1018   else
1019   {
1020    /*
1021     * Shift up...
1022     */
1023
1024     if ((temp = calloc((size_t)s, sizeof(_cups_ps_obj_t))) == NULL)
1025       return (-1);
1026
1027     memcpy(temp, st->objs + n + c - s, (size_t)s * sizeof(_cups_ps_obj_t));
1028     memmove(st->objs + n + s, st->objs + n, (size_t)(c - s) * sizeof(_cups_ps_obj_t));
1029     memcpy(st->objs + n, temp, (size_t)s * sizeof(_cups_ps_obj_t));
1030   }
1031
1032   free(temp);
1033
1034   return (0);
1035 }
1036
1037
1038 /*
1039  * 'scan_ps()' - Scan a string for the next PS object.
1040  */
1041
1042 static _cups_ps_obj_t   *               /* O  - New object or NULL on EOF */
1043 scan_ps(_cups_ps_stack_t *st,           /* I  - Stack */
1044         char             **ptr)         /* IO - String pointer */
1045 {
1046   _cups_ps_obj_t        obj;            /* Current object */
1047   char                  *start,         /* Start of object */
1048                         *cur,           /* Current position */
1049                         *valptr,        /* Pointer into value string */
1050                         *valend;        /* End of value string */
1051   int                   parens;         /* Parenthesis nesting level */
1052
1053
1054  /*
1055   * Skip leading whitespace...
1056   */
1057
1058   for (cur = *ptr; *cur; cur ++)
1059   {
1060     if (*cur == '%')
1061     {
1062      /*
1063       * Comment, skip to end of line...
1064       */
1065
1066       for (cur ++; *cur && *cur != '\n' && *cur != '\r'; cur ++);
1067
1068       if (!*cur)
1069         cur --;
1070     }
1071     else if (!isspace(*cur & 255))
1072       break;
1073   }
1074
1075   if (!*cur)
1076   {
1077     *ptr = NULL;
1078
1079     return (NULL);
1080   }
1081
1082  /*
1083   * See what we have...
1084   */
1085
1086   memset(&obj, 0, sizeof(obj));
1087
1088   switch (*cur)
1089   {
1090     case '(' :                          /* (string) */
1091         obj.type = CUPS_PS_STRING;
1092         start    = cur;
1093
1094         for (cur ++, parens = 1, valptr = obj.value.string,
1095                  valend = obj.value.string + sizeof(obj.value.string) - 1;
1096              *cur;
1097              cur ++)
1098         {
1099           if (*cur == ')' && parens == 1)
1100             break;
1101
1102           if (*cur == '(')
1103             parens ++;
1104           else if (*cur == ')')
1105             parens --;
1106
1107           if (valptr >= valend)
1108           {
1109             *ptr = start;
1110
1111             return (NULL);
1112           }
1113
1114           if (*cur == '\\')
1115           {
1116            /*
1117             * Decode escaped character...
1118             */
1119
1120             cur ++;
1121
1122             if (*cur == 'b')
1123               *valptr++ = '\b';
1124             else if (*cur == 'f')
1125               *valptr++ = '\f';
1126             else if (*cur == 'n')
1127               *valptr++ = '\n';
1128             else if (*cur == 'r')
1129               *valptr++ = '\r';
1130             else if (*cur == 't')
1131               *valptr++ = '\t';
1132             else if (*cur >= '0' && *cur <= '7')
1133             {
1134               int ch = *cur - '0';
1135
1136               if (cur[1] >= '0' && cur[1] <= '7')
1137               {
1138                 cur ++;
1139                 ch = (ch << 3) + *cur - '0';
1140               }
1141
1142               if (cur[1] >= '0' && cur[1] <= '7')
1143               {
1144                 cur ++;
1145                 ch = (ch << 3) + *cur - '0';
1146               }
1147
1148               *valptr++ = (char)ch;
1149             }
1150             else if (*cur == '\r')
1151             {
1152               if (cur[1] == '\n')
1153                 cur ++;
1154             }
1155             else if (*cur != '\n')
1156               *valptr++ = *cur;
1157           }
1158           else
1159             *valptr++ = *cur;
1160         }
1161
1162         if (*cur != ')')
1163         {
1164           *ptr = start;
1165
1166           return (NULL);
1167         }
1168
1169         cur ++;
1170         break;
1171
1172     case '[' :                          /* Start array */
1173         obj.type = CUPS_PS_START_ARRAY;
1174         cur ++;
1175         break;
1176
1177     case ']' :                          /* End array */
1178         obj.type = CUPS_PS_END_ARRAY;
1179         cur ++;
1180         break;
1181
1182     case '<' :                          /* Start dictionary or hex string */
1183         if (cur[1] == '<')
1184         {
1185           obj.type = CUPS_PS_START_DICT;
1186           cur += 2;
1187         }
1188         else
1189         {
1190           obj.type = CUPS_PS_STRING;
1191           start    = cur;
1192
1193           for (cur ++, valptr = obj.value.string,
1194                    valend = obj.value.string + sizeof(obj.value.string) - 1;
1195                *cur;
1196                cur ++)
1197           {
1198             int ch;                     /* Current character */
1199
1200
1201
1202             if (*cur == '>')
1203               break;
1204             else if (valptr >= valend || !isxdigit(*cur & 255))
1205             {
1206               *ptr = start;
1207               return (NULL);
1208             }
1209
1210             if (*cur >= '0' && *cur <= '9')
1211               ch = (*cur - '0') << 4;
1212             else
1213               ch = (tolower(*cur) - 'a' + 10) << 4;
1214
1215             if (isxdigit(cur[1] & 255))
1216             {
1217               cur ++;
1218
1219               if (*cur >= '0' && *cur <= '9')
1220                 ch |= *cur - '0';
1221               else
1222                 ch |= tolower(*cur) - 'a' + 10;
1223             }
1224
1225             *valptr++ = (char)ch;
1226           }
1227
1228           if (*cur != '>')
1229           {
1230             *ptr = start;
1231             return (NULL);
1232           }
1233
1234           cur ++;
1235         }
1236         break;
1237
1238     case '>' :                          /* End dictionary? */
1239         if (cur[1] == '>')
1240         {
1241           obj.type = CUPS_PS_END_DICT;
1242           cur += 2;
1243         }
1244         else
1245         {
1246           obj.type           = CUPS_PS_OTHER;
1247           obj.value.other[0] = *cur;
1248
1249           cur ++;
1250         }
1251         break;
1252
1253     case '{' :                          /* Start procedure */
1254         obj.type = CUPS_PS_START_PROC;
1255         cur ++;
1256         break;
1257
1258     case '}' :                          /* End procedure */
1259         obj.type = CUPS_PS_END_PROC;
1260         cur ++;
1261         break;
1262
1263     case '-' :                          /* Possible number */
1264     case '+' :
1265         if (!isdigit(cur[1] & 255) && cur[1] != '.')
1266         {
1267           obj.type           = CUPS_PS_OTHER;
1268           obj.value.other[0] = *cur;
1269
1270           cur ++;
1271           break;
1272         }
1273
1274     case '0' :                          /* Number */
1275     case '1' :
1276     case '2' :
1277     case '3' :
1278     case '4' :
1279     case '5' :
1280     case '6' :
1281     case '7' :
1282     case '8' :
1283     case '9' :
1284     case '.' :
1285         obj.type = CUPS_PS_NUMBER;
1286
1287         start = cur;
1288         for (cur ++; *cur; cur ++)
1289           if (!isdigit(*cur & 255))
1290             break;
1291
1292         if (*cur == '#')
1293         {
1294          /*
1295           * Integer with radix...
1296           */
1297
1298           obj.value.number = strtol(cur + 1, &cur, atoi(start));
1299           break;
1300         }
1301         else if (strchr(".Ee()<>[]{}/%", *cur) || isspace(*cur & 255))
1302         {
1303          /*
1304           * Integer or real number...
1305           */
1306
1307           obj.value.number = _cupsStrScand(start, &cur, localeconv());
1308           break;
1309         }
1310         else
1311           cur = start;
1312
1313     default :                           /* Operator/variable name */
1314         start = cur;
1315
1316         if (*cur == '/')
1317         {
1318           obj.type = CUPS_PS_NAME;
1319           valptr   = obj.value.name;
1320           valend   = obj.value.name + sizeof(obj.value.name) - 1;
1321           cur ++;
1322         }
1323         else
1324         {
1325           obj.type = CUPS_PS_OTHER;
1326           valptr   = obj.value.other;
1327           valend   = obj.value.other + sizeof(obj.value.other) - 1;
1328         }
1329
1330         while (*cur)
1331         {
1332           if (strchr("()<>[]{}/%", *cur) || isspace(*cur & 255))
1333             break;
1334           else if (valptr < valend)
1335             *valptr++ = *cur++;
1336           else
1337           {
1338             *ptr = start;
1339             return (NULL);
1340           }
1341         }
1342
1343         if (obj.type == CUPS_PS_OTHER)
1344         {
1345           if (!strcmp(obj.value.other, "true"))
1346           {
1347             obj.type          = CUPS_PS_BOOLEAN;
1348             obj.value.boolean = 1;
1349           }
1350           else if (!strcmp(obj.value.other, "false"))
1351           {
1352             obj.type          = CUPS_PS_BOOLEAN;
1353             obj.value.boolean = 0;
1354           }
1355           else if (!strcmp(obj.value.other, "null"))
1356             obj.type = CUPS_PS_NULL;
1357           else if (!strcmp(obj.value.other, "cleartomark"))
1358             obj.type = CUPS_PS_CLEARTOMARK;
1359           else if (!strcmp(obj.value.other, "copy"))
1360             obj.type = CUPS_PS_COPY;
1361           else if (!strcmp(obj.value.other, "dup"))
1362             obj.type = CUPS_PS_DUP;
1363           else if (!strcmp(obj.value.other, "index"))
1364             obj.type = CUPS_PS_INDEX;
1365           else if (!strcmp(obj.value.other, "pop"))
1366             obj.type = CUPS_PS_POP;
1367           else if (!strcmp(obj.value.other, "roll"))
1368             obj.type = CUPS_PS_ROLL;
1369           else if (!strcmp(obj.value.other, "setpagedevice"))
1370             obj.type = CUPS_PS_SETPAGEDEVICE;
1371           else if (!strcmp(obj.value.other, "stopped"))
1372             obj.type = CUPS_PS_STOPPED;
1373         }
1374         break;
1375   }
1376
1377  /*
1378   * Save the current position in the string and return the new object...
1379   */
1380
1381   *ptr = cur;
1382
1383   return (push_stack(st, &obj));
1384 }
1385
1386
1387 /*
1388  * 'setpagedevice()' - Simulate the PostScript setpagedevice operator.
1389  */
1390
1391 static int                              /* O - 0 on success, -1 on error */
1392 setpagedevice(
1393     _cups_ps_stack_t    *st,            /* I - Stack */
1394     cups_page_header2_t *h,             /* O - Page header */
1395     int                 *preferred_bits)/* O - Preferred bits per color */
1396 {
1397   int                   i;              /* Index into array */
1398   _cups_ps_obj_t        *obj,           /* Current object */
1399                         *end;           /* End of dictionary */
1400   const char            *name;          /* Attribute name */
1401
1402
1403  /*
1404   * Make sure we have a dictionary on the stack...
1405   */
1406
1407   if (st->num_objs == 0)
1408     return (-1);
1409
1410   obj = end = st->objs + st->num_objs - 1;
1411
1412   if (obj->type != CUPS_PS_END_DICT)
1413     return (-1);
1414
1415   obj --;
1416
1417   while (obj > st->objs)
1418   {
1419     if (obj->type == CUPS_PS_START_DICT)
1420       break;
1421
1422     obj --;
1423   }
1424
1425   if (obj < st->objs)
1426     return (-1);
1427
1428  /*
1429   * Found the start of the dictionary, empty the stack to this point...
1430   */
1431
1432   st->num_objs = (int)(obj - st->objs);
1433
1434  /*
1435   * Now pull /name and value pairs from the dictionary...
1436   */
1437
1438   DEBUG_puts("setpagedevice: Dictionary:");
1439
1440   for (obj ++; obj < end; obj ++)
1441   {
1442    /*
1443     * Grab the name...
1444     */
1445
1446     if (obj->type != CUPS_PS_NAME)
1447       return (-1);
1448
1449     name = obj->value.name;
1450     obj ++;
1451
1452 #ifdef DEBUG
1453     DEBUG_printf(("setpagedevice: /%s ", name));
1454     DEBUG_object(obj);
1455 #endif /* DEBUG */
1456
1457    /*
1458     * Then grab the value...
1459     */
1460
1461     if (!strcmp(name, "MediaClass") && obj->type == CUPS_PS_STRING)
1462       strlcpy(h->MediaClass, obj->value.string, sizeof(h->MediaClass));
1463     else if (!strcmp(name, "MediaColor") && obj->type == CUPS_PS_STRING)
1464       strlcpy(h->MediaColor, obj->value.string, sizeof(h->MediaColor));
1465     else if (!strcmp(name, "MediaType") && obj->type == CUPS_PS_STRING)
1466       strlcpy(h->MediaType, obj->value.string, sizeof(h->MediaType));
1467     else if (!strcmp(name, "OutputType") && obj->type == CUPS_PS_STRING)
1468       strlcpy(h->OutputType, obj->value.string, sizeof(h->OutputType));
1469     else if (!strcmp(name, "AdvanceDistance") && obj->type == CUPS_PS_NUMBER)
1470       h->AdvanceDistance = (unsigned)obj->value.number;
1471     else if (!strcmp(name, "AdvanceMedia") && obj->type == CUPS_PS_NUMBER)
1472       h->AdvanceMedia = (unsigned)obj->value.number;
1473     else if (!strcmp(name, "Collate") && obj->type == CUPS_PS_BOOLEAN)
1474       h->Collate = (unsigned)obj->value.boolean;
1475     else if (!strcmp(name, "CutMedia") && obj->type == CUPS_PS_NUMBER)
1476       h->CutMedia = (cups_cut_t)(unsigned)obj->value.number;
1477     else if (!strcmp(name, "Duplex") && obj->type == CUPS_PS_BOOLEAN)
1478       h->Duplex = (unsigned)obj->value.boolean;
1479     else if (!strcmp(name, "HWResolution") && obj->type == CUPS_PS_START_ARRAY)
1480     {
1481       if (obj[1].type == CUPS_PS_NUMBER && obj[2].type == CUPS_PS_NUMBER &&
1482           obj[3].type == CUPS_PS_END_ARRAY)
1483       {
1484         h->HWResolution[0] = (unsigned)obj[1].value.number;
1485         h->HWResolution[1] = (unsigned)obj[2].value.number;
1486         obj += 3;
1487       }
1488       else
1489         return (-1);
1490     }
1491     else if (!strcmp(name, "InsertSheet") && obj->type == CUPS_PS_BOOLEAN)
1492       h->InsertSheet = (unsigned)obj->value.boolean;
1493     else if (!strcmp(name, "Jog") && obj->type == CUPS_PS_NUMBER)
1494       h->Jog = (unsigned)obj->value.number;
1495     else if (!strcmp(name, "LeadingEdge") && obj->type == CUPS_PS_NUMBER)
1496       h->LeadingEdge = (unsigned)obj->value.number;
1497     else if (!strcmp(name, "ManualFeed") && obj->type == CUPS_PS_BOOLEAN)
1498       h->ManualFeed = (unsigned)obj->value.boolean;
1499     else if ((!strcmp(name, "cupsMediaPosition") ||
1500               !strcmp(name, "MediaPosition")) && obj->type == CUPS_PS_NUMBER)
1501     {
1502      /*
1503       * cupsMediaPosition is supported for backwards compatibility only.
1504       * We added it back in the Ghostscript 5.50 days to work around a
1505       * bug in Ghostscript WRT handling of MediaPosition and setpagedevice.
1506       *
1507       * All new development should set MediaPosition...
1508       */
1509
1510       h->MediaPosition = (unsigned)obj->value.number;
1511     }
1512     else if (!strcmp(name, "MediaWeight") && obj->type == CUPS_PS_NUMBER)
1513       h->MediaWeight = (unsigned)obj->value.number;
1514     else if (!strcmp(name, "MirrorPrint") && obj->type == CUPS_PS_BOOLEAN)
1515       h->MirrorPrint = (unsigned)obj->value.boolean;
1516     else if (!strcmp(name, "NegativePrint") && obj->type == CUPS_PS_BOOLEAN)
1517       h->NegativePrint = (unsigned)obj->value.boolean;
1518     else if (!strcmp(name, "NumCopies") && obj->type == CUPS_PS_NUMBER)
1519       h->NumCopies = (unsigned)obj->value.number;
1520     else if (!strcmp(name, "Orientation") && obj->type == CUPS_PS_NUMBER)
1521       h->Orientation = (unsigned)obj->value.number;
1522     else if (!strcmp(name, "OutputFaceUp") && obj->type == CUPS_PS_BOOLEAN)
1523       h->OutputFaceUp = (unsigned)obj->value.boolean;
1524     else if (!strcmp(name, "PageSize") && obj->type == CUPS_PS_START_ARRAY)
1525     {
1526       if (obj[1].type == CUPS_PS_NUMBER && obj[2].type == CUPS_PS_NUMBER &&
1527           obj[3].type == CUPS_PS_END_ARRAY)
1528       {
1529         h->cupsPageSize[0] = (float)obj[1].value.number;
1530         h->cupsPageSize[1] = (float)obj[2].value.number;
1531
1532         h->PageSize[0] = (unsigned)obj[1].value.number;
1533         h->PageSize[1] = (unsigned)obj[2].value.number;
1534
1535         obj += 3;
1536       }
1537       else
1538         return (-1);
1539     }
1540     else if (!strcmp(name, "Separations") && obj->type == CUPS_PS_BOOLEAN)
1541       h->Separations = (unsigned)obj->value.boolean;
1542     else if (!strcmp(name, "TraySwitch") && obj->type == CUPS_PS_BOOLEAN)
1543       h->TraySwitch = (unsigned)obj->value.boolean;
1544     else if (!strcmp(name, "Tumble") && obj->type == CUPS_PS_BOOLEAN)
1545       h->Tumble = (unsigned)obj->value.boolean;
1546     else if (!strcmp(name, "cupsMediaType") && obj->type == CUPS_PS_NUMBER)
1547       h->cupsMediaType = (unsigned)obj->value.number;
1548     else if (!strcmp(name, "cupsBitsPerColor") && obj->type == CUPS_PS_NUMBER)
1549       h->cupsBitsPerColor = (unsigned)obj->value.number;
1550     else if (!strcmp(name, "cupsPreferredBitsPerColor") &&
1551              obj->type == CUPS_PS_NUMBER)
1552       *preferred_bits = (int)obj->value.number;
1553     else if (!strcmp(name, "cupsColorOrder") && obj->type == CUPS_PS_NUMBER)
1554       h->cupsColorOrder = (cups_order_t)(unsigned)obj->value.number;
1555     else if (!strcmp(name, "cupsColorSpace") && obj->type == CUPS_PS_NUMBER)
1556       h->cupsColorSpace = (cups_cspace_t)(unsigned)obj->value.number;
1557     else if (!strcmp(name, "cupsCompression") && obj->type == CUPS_PS_NUMBER)
1558       h->cupsCompression = (unsigned)obj->value.number;
1559     else if (!strcmp(name, "cupsRowCount") && obj->type == CUPS_PS_NUMBER)
1560       h->cupsRowCount = (unsigned)obj->value.number;
1561     else if (!strcmp(name, "cupsRowFeed") && obj->type == CUPS_PS_NUMBER)
1562       h->cupsRowFeed = (unsigned)obj->value.number;
1563     else if (!strcmp(name, "cupsRowStep") && obj->type == CUPS_PS_NUMBER)
1564       h->cupsRowStep = (unsigned)obj->value.number;
1565     else if (!strcmp(name, "cupsBorderlessScalingFactor") &&
1566              obj->type == CUPS_PS_NUMBER)
1567       h->cupsBorderlessScalingFactor = (float)obj->value.number;
1568     else if (!strncmp(name, "cupsInteger", 11) && obj->type == CUPS_PS_NUMBER)
1569     {
1570       if ((i = atoi(name + 11)) < 0 || i > 15)
1571         return (-1);
1572
1573       h->cupsInteger[i] = (unsigned)obj->value.number;
1574     }
1575     else if (!strncmp(name, "cupsReal", 8) && obj->type == CUPS_PS_NUMBER)
1576     {
1577       if ((i = atoi(name + 8)) < 0 || i > 15)
1578         return (-1);
1579
1580       h->cupsReal[i] = (float)obj->value.number;
1581     }
1582     else if (!strncmp(name, "cupsString", 10) && obj->type == CUPS_PS_STRING)
1583     {
1584       if ((i = atoi(name + 10)) < 0 || i > 15)
1585         return (-1);
1586
1587       strlcpy(h->cupsString[i], obj->value.string, sizeof(h->cupsString[i]));
1588     }
1589     else if (!strcmp(name, "cupsMarkerType") && obj->type == CUPS_PS_STRING)
1590       strlcpy(h->cupsMarkerType, obj->value.string, sizeof(h->cupsMarkerType));
1591     else if (!strcmp(name, "cupsPageSizeName") && obj->type == CUPS_PS_STRING)
1592       strlcpy(h->cupsPageSizeName, obj->value.string,
1593               sizeof(h->cupsPageSizeName));
1594     else if (!strcmp(name, "cupsRenderingIntent") &&
1595              obj->type == CUPS_PS_STRING)
1596       strlcpy(h->cupsRenderingIntent, obj->value.string,
1597               sizeof(h->cupsRenderingIntent));
1598     else
1599     {
1600      /*
1601       * Ignore unknown name+value...
1602       */
1603
1604       DEBUG_printf(("    Unknown name (\"%s\") or value...\n", name));
1605
1606       while (obj[1].type != CUPS_PS_NAME && obj < end)
1607         obj ++;
1608     }
1609   }
1610
1611   return (0);
1612 }
1613
1614
1615 #ifdef DEBUG
1616 /*
1617  * 'DEBUG_object()' - Print an object's value...
1618  */
1619
1620 static void
1621 DEBUG_object(_cups_ps_obj_t *obj)       /* I - Object to print */
1622 {
1623   switch (obj->type)
1624   {
1625     case CUPS_PS_NAME :
1626         DEBUG_printf(("/%s\n", obj->value.name));
1627         break;
1628
1629     case CUPS_PS_NUMBER :
1630         DEBUG_printf(("%g\n", obj->value.number));
1631         break;
1632
1633     case CUPS_PS_STRING :
1634         DEBUG_printf(("(%s)\n", obj->value.string));
1635         break;
1636
1637     case CUPS_PS_BOOLEAN :
1638         if (obj->value.boolean)
1639           DEBUG_puts("true");
1640         else
1641           DEBUG_puts("false");
1642         break;
1643
1644     case CUPS_PS_NULL :
1645         DEBUG_puts("null");
1646         break;
1647
1648     case CUPS_PS_START_ARRAY :
1649         DEBUG_puts("[");
1650         break;
1651
1652     case CUPS_PS_END_ARRAY :
1653         DEBUG_puts("]");
1654         break;
1655
1656     case CUPS_PS_START_DICT :
1657         DEBUG_puts("<<");
1658         break;
1659
1660     case CUPS_PS_END_DICT :
1661         DEBUG_puts(">>");
1662         break;
1663
1664     case CUPS_PS_START_PROC :
1665         DEBUG_puts("{");
1666         break;
1667
1668     case CUPS_PS_END_PROC :
1669         DEBUG_puts("}");
1670         break;
1671
1672     case CUPS_PS_CLEARTOMARK :
1673         DEBUG_puts("--cleartomark--");
1674         break;
1675
1676     case CUPS_PS_COPY :
1677         DEBUG_puts("--copy--");
1678         break;
1679
1680     case CUPS_PS_DUP :
1681         DEBUG_puts("--dup--");
1682         break;
1683
1684     case CUPS_PS_INDEX :
1685         DEBUG_puts("--index--");
1686         break;
1687
1688     case CUPS_PS_POP :
1689         DEBUG_puts("--pop--");
1690         break;
1691
1692     case CUPS_PS_ROLL :
1693         DEBUG_puts("--roll--");
1694         break;
1695
1696     case CUPS_PS_SETPAGEDEVICE :
1697         DEBUG_puts("--setpagedevice--");
1698         break;
1699
1700     case CUPS_PS_STOPPED :
1701         DEBUG_puts("--stopped--");
1702         break;
1703
1704     case CUPS_PS_OTHER :
1705         DEBUG_printf(("--%s--\n", obj->value.other));
1706         break;
1707   }
1708 }
1709
1710
1711 /*
1712  * 'DEBUG_stack()' - Print a stack...
1713  */
1714
1715 static void
1716 DEBUG_stack(_cups_ps_stack_t *st)       /* I - Stack */
1717 {
1718   int                   c;              /* Looping var */
1719   _cups_ps_obj_t        *obj;           /* Current object on stack */
1720
1721
1722   for (obj = st->objs, c = st->num_objs; c > 0; c --, obj ++)
1723     DEBUG_object(obj);
1724 }
1725 #endif /* DEBUG */
1726
1727
1728 /*
1729  * End of "$Id: interpret.c 11848 2014-05-07 00:26:44Z msweet $".
1730  */