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