git.oblomov.eu Git - wine/blob - dlls/wineps.drv/ppd.c

   1 /*      PostScript Printer Description (PPD) file parser
   2  *
   3  *      See  http://www.adobe.com/supportservice/devrelations/PDFS/TN/5003.PPD_Spec_v4.3.pdf
   4  *
   5  *      Copyright 1998  Huw D M Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <ctype.h>
  29 #include <locale.h>
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wine/debug.h"
  33 #include "psdrv.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(psdrv);
  36
  37 typedef struct {
  38 char    *key;
  39 char    *option;
  40 char    *opttrans;
  41 char    *value;
  42 char    *valtrans;
  43 } PPDTuple;
  44
  45
  46 /* map of page names in ppd file to Windows paper constants */
  47
  48 static const struct {
  49   const char *PSName;
  50   WORD WinPage;
  51 } PageTrans[] = {
  52   {"10x11",                   DMPAPER_10X11},
  53   {"10x14",                   DMPAPER_10X14},
  54   {"11x17",                   DMPAPER_11X17},   /* not in Adobe PPD file spec */
  55   {"12x11",                   DMPAPER_12X11},
  56   {"15x11",                   DMPAPER_15X11},
  57   {"9x11",                    DMPAPER_9X11},
  58   {"A2",                      DMPAPER_A2},
  59   {"A3",                      DMPAPER_A3},
  60   {"A3.Transverse",           DMPAPER_A3_TRANSVERSE},
  61   {"A3Extra",                 DMPAPER_A3_EXTRA},
  62   {"A3Extra.Transverse",      DMPAPER_A3_EXTRA_TRANSVERSE},
  63   {"A3Rotated",               DMPAPER_A3_ROTATED},
  64   {"A4",                      DMPAPER_A4},
  65   {"A4.Transverse",           DMPAPER_A4_TRANSVERSE},
  66   {"A4Extra",                 DMPAPER_A4_EXTRA},
  67   {"A4Plus",                  DMPAPER_A4_PLUS},
  68   {"A4Rotated",               DMPAPER_A4_ROTATED},
  69   {"A4Small",                 DMPAPER_A4SMALL},
  70   {"A5",                      DMPAPER_A5},
  71   {"A5.Transverse",           DMPAPER_A5_TRANSVERSE},
  72   {"A5Extra",                 DMPAPER_A5_EXTRA},
  73   {"A5Rotated",               DMPAPER_A5_ROTATED},
  74   {"A6",                      DMPAPER_A6},
  75   {"A6Rotated",               DMPAPER_A6_ROTATED},
  76   {"ARCHC",                   DMPAPER_CSHEET},
  77   {"ARCHD",                   DMPAPER_DSHEET},
  78   {"ARCHE",                   DMPAPER_ESHEET},
  79   {"B4",                      DMPAPER_B4},
  80   {"B4Rotated",               DMPAPER_B4_JIS_ROTATED},
  81   {"B5",                      DMPAPER_B5},
  82   {"B5.Transverse",           DMPAPER_B5_TRANSVERSE},
  83   {"B5Rotated",               DMPAPER_B5_JIS_ROTATED},
  84   {"B6",                      DMPAPER_B6_JIS},
  85   {"B6Rotated",               DMPAPER_B6_JIS_ROTATED},
  86   {"C4",                      DMPAPER_ENV_C4},          /*  use EnvC4 */
  87   {"C5",                      DMPAPER_ENV_C5},          /*  use EnvC5 */
  88   {"C6",                      DMPAPER_ENV_C6},          /*  use EnvC6 */
  89   {"Comm10",                  DMPAPER_ENV_10},          /*  use Env10 */
  90   {"DL",                      DMPAPER_ENV_DL},          /*  use EnvDL */
  91   {"DoublePostcard",          DMPAPER_DBL_JAPANESE_POSTCARD},
  92   {"DoublePostcardRotated",   DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
  93   {"Env10",                   DMPAPER_ENV_10},
  94   {"Env11",                   DMPAPER_ENV_11},
  95   {"Env12",                   DMPAPER_ENV_12},
  96   {"Env14",                   DMPAPER_ENV_14},
  97   {"Env9",                    DMPAPER_ENV_9},
  98   {"EnvC3",                   DMPAPER_ENV_C3},
  99   {"EnvC4",                   DMPAPER_ENV_C4},
 100   {"EnvC5",                   DMPAPER_ENV_C5},
 101   {"EnvC6",                   DMPAPER_ENV_C6},
 102   {"EnvC65",                  DMPAPER_ENV_C65},
 103   {"EnvChou3",                DMPAPER_JENV_CHOU3},
 104   {"EnvChou3Rotated",         DMPAPER_JENV_CHOU3_ROTATED},
 105   {"EnvChou4",                DMPAPER_JENV_CHOU4},
 106   {"EnvChou4Rotated",         DMPAPER_JENV_CHOU4_ROTATED},
 107   {"EnvDL",                   DMPAPER_ENV_DL},
 108   {"EnvISOB4",                DMPAPER_ENV_B4},
 109   {"EnvISOB5",                DMPAPER_ENV_B5},
 110   {"EnvISOB6",                DMPAPER_ENV_B6},
 111   {"EnvInvite",               DMPAPER_ENV_INVITE},
 112   {"EnvItalian",              DMPAPER_ENV_ITALY},
 113   {"EnvKaku2",                DMPAPER_JENV_KAKU2},
 114   {"EnvKaku2Rotated",         DMPAPER_JENV_KAKU2_ROTATED},
 115   {"EnvKaku3",                DMPAPER_JENV_KAKU3},
 116   {"EnvKaku3Rotated",         DMPAPER_JENV_KAKU3_ROTATED},
 117   {"EnvMonarch",              DMPAPER_ENV_MONARCH},
 118   {"EnvPRC1",                 DMPAPER_PENV_1},
 119   {"EnvPRC10",                DMPAPER_PENV_10},
 120   {"EnvPRC10Rotated",         DMPAPER_PENV_10_ROTATED},
 121   {"EnvPRC1Rotated",          DMPAPER_PENV_1_ROTATED},
 122   {"EnvPRC2",                 DMPAPER_PENV_2},
 123   {"EnvPRC2Rotated",          DMPAPER_PENV_2_ROTATED},
 124   {"EnvPRC3",                 DMPAPER_PENV_3},
 125   {"EnvPRC3Rotated",          DMPAPER_PENV_3_ROTATED},
 126   {"EnvPRC4",                 DMPAPER_PENV_4},
 127   {"EnvPRC4Rotated",          DMPAPER_PENV_4_ROTATED},
 128   {"EnvPRC5",                 DMPAPER_PENV_5},
 129   {"EnvPRC5Rotated",          DMPAPER_PENV_5_ROTATED},
 130   {"EnvPRC6",                 DMPAPER_PENV_6},
 131   {"EnvPRC6Rotated",          DMPAPER_PENV_6_ROTATED},
 132   {"EnvPRC7",                 DMPAPER_PENV_7},
 133   {"EnvPRC7Rotated",          DMPAPER_PENV_7_ROTATED},
 134   {"EnvPRC8",                 DMPAPER_PENV_8},
 135   {"EnvPRC8Rotated",          DMPAPER_PENV_8_ROTATED},
 136   {"EnvPRC9",                 DMPAPER_PENV_9},
 137   {"EnvPRC9Rotated",          DMPAPER_PENV_9_ROTATED},
 138   {"EnvPersonal",             DMPAPER_ENV_PERSONAL},
 139   {"EnvYou4",                 DMPAPER_JENV_YOU4},
 140   {"EnvYou4Rotated",          DMPAPER_JENV_YOU4_ROTATED},
 141   {"Executive",               DMPAPER_EXECUTIVE},
 142   {"FanFoldGerman",           DMPAPER_FANFOLD_STD_GERMAN},
 143   {"FanFoldGermanLegal",      DMPAPER_FANFOLD_LGL_GERMAN},
 144   {"FanFoldUS",               DMPAPER_FANFOLD_US},
 145   {"Folio",                   DMPAPER_FOLIO},
 146   {"ISOB4",                   DMPAPER_ISO_B4},
 147   {"ISOB5Extra",              DMPAPER_B5_EXTRA},
 148   {"Ledger",                  DMPAPER_LEDGER},
 149   {"Legal",                   DMPAPER_LEGAL},
 150   {"LegalExtra",              DMPAPER_LEGAL_EXTRA},
 151   {"Letter",                  DMPAPER_LETTER},
 152   {"Letter.Transverse",       DMPAPER_LETTER_TRANSVERSE},
 153   {"LetterExtra",             DMPAPER_LETTER_EXTRA},
 154   {"LetterExtra.Transverse",  DMPAPER_LETTER_EXTRA_TRANSVERSE},
 155   {"LetterPlus",              DMPAPER_LETTER_PLUS},
 156   {"LetterRotated",           DMPAPER_LETTER_ROTATED},
 157   {"LetterSmall",             DMPAPER_LETTERSMALL},
 158   {"Monarch",                 DMPAPER_ENV_MONARCH},     /* use EnvMonarch */
 159   {"Note",                    DMPAPER_NOTE},
 160   {"PRC16K",                  DMPAPER_P16K},
 161   {"PRC16KRotated",           DMPAPER_P16K_ROTATED},
 162   {"PRC32K",                  DMPAPER_P32K},
 163   {"PRC32KBig",               DMPAPER_P32KBIG},
 164   {"PRC32KBigRotated",        DMPAPER_P32KBIG_ROTATED},
 165   {"PRC32KRotated",           DMPAPER_P32K_ROTATED},
 166   {"Postcard",                DMPAPER_JAPANESE_POSTCARD},
 167   {"PostcardRotated",         DMPAPER_JAPANESE_POSTCARD_ROTATED},
 168   {"Quarto",                  DMPAPER_QUARTO},
 169   {"Statement",               DMPAPER_STATEMENT},
 170   {"SuperA",                  DMPAPER_A_PLUS},
 171   {"SuperB",                  DMPAPER_B_PLUS},
 172   {"Tabloid",                 DMPAPER_TABLOID},
 173   {"TabloidExtra",            DMPAPER_TABLOID_EXTRA},
 174   {NULL,                      0}
 175 };
 176
 177 static WORD UserPageType = DMPAPER_USER;
 178 static WORD UserBinType = DMBIN_USER;
 179
 180 /***********************************************************************
 181  *
 182  *              PSDRV_PPDDecodeHex
 183  *
 184  * Copies str into a newly allocated string from the process heap substituting
 185  * hex strings enclosed in '<' and '>' for their byte codes.
 186  *
 187  */
 188 static char *PSDRV_PPDDecodeHex(char *str)
 189 {
 190     char *buf, *in, *out;
 191     BOOL inhex = FALSE;
 192
 193     buf = HeapAlloc(PSDRV_Heap, 0, strlen(str) + 1);
 194     if(!buf)
 195         return NULL;
 196
 197     for(in = str, out = buf; *in; in++) {
 198         if(!inhex) {
 199             if(*in != '<')
 200                 *out++ = *in;
 201             else
 202                 inhex = TRUE;
 203         } else {
 204             if(*in == '>') {
 205                 inhex = FALSE;
 206                 continue;
 207             }
 208             else if(isspace(*in))
 209                 continue;
 210             else {
 211                 int i;
 212                 if(!isxdigit(*in) || !isxdigit(*(in + 1))) {
 213                     ERR("Invalid hex char in hex string\n");
 214                     HeapFree(PSDRV_Heap, 0, buf);
 215                     return NULL;
 216                 }
 217                 *out = 0;
 218                 for(i = 0; i < 2; i++) {
 219                     if(isdigit(*(in + i)))
 220                         *out |= (*(in + i) - '0') << ((1-i) * 4);
 221                     else
 222                         *out |= (toupper(*(in + i)) - 'A' + 10) << ((1-i) * 4);
 223                 }
 224                 out++;
 225                 in++;
 226             }
 227         }
 228     }
 229     *out = '\0';
 230     return buf;
 231 }
 232
 233
 234 /***********************************************************************
 235  *
 236  *              PSDRV_PPDGetTransValue
 237  *
 238  */
 239 static BOOL PSDRV_PPDGetTransValue(char *start, PPDTuple *tuple)
 240 {
 241     char *buf, *end;
 242
 243     end = strpbrk(start, "\r\n");
 244     if(end == start) return FALSE;
 245     if(!end) end = start + strlen(start);
 246     buf = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
 247     memcpy(buf, start, end - start);
 248     *(buf + (end - start)) = '\0';
 249     tuple->valtrans = PSDRV_PPDDecodeHex(buf);
 250     HeapFree( PSDRV_Heap, 0, buf );
 251     return TRUE;
 252 }
 253
 254
 255 /***********************************************************************
 256  *
 257  *              PSDRV_PPDGetInvocationValue
 258  *
 259  * Passed string that should be surrounded by `"'s, return string alloced
 260  * from process heap.
 261  */
 262 static BOOL PSDRV_PPDGetInvocationValue(FILE *fp, char *pos, PPDTuple *tuple)
 263 {
 264     char *start, *end, *buf;
 265     char line[257];
 266     int len;
 267
 268     start = pos + 1;
 269     buf = HeapAlloc( PSDRV_Heap, 0, strlen(start) + 1 );
 270     len = 0;
 271     do {
 272         end = strchr(start, '"');
 273         if(end) {
 274             buf = HeapReAlloc( PSDRV_Heap, 0, buf,
 275                                len + (end - start) + 1 );
 276             memcpy(buf + len, start, end - start);
 277             *(buf + len + (end - start)) = '\0';
 278             tuple->value = buf;
 279             start = strchr(end, '/');
 280             if(start)
 281                 return PSDRV_PPDGetTransValue(start + 1, tuple);
 282             return TRUE;
 283         } else {
 284             int sl = strlen(start);
 285             buf = HeapReAlloc( PSDRV_Heap, 0, buf, len + sl + 1 );
 286             strcpy(buf + len, start);
 287             len += sl;
 288         }
 289     } while( fgets((start = line), sizeof(line), fp) );
 290
 291     tuple->value = NULL;
 292     HeapFree( PSDRV_Heap, 0, buf );
 293     return FALSE;
 294 }
 295
 296
 297 /***********************************************************************
 298  *
 299  *              PSDRV_PPDGetQuotedValue
 300  *
 301  * Passed string that should be surrounded by `"'s. Expand <xx> as hex
 302  * return string alloced from process heap.
 303  */
 304 static BOOL PSDRV_PPDGetQuotedValue(FILE *fp, char *pos, PPDTuple *tuple)
 305 {
 306     char *buf;
 307
 308     if(!PSDRV_PPDGetInvocationValue(fp, pos, tuple))
 309         return FALSE;
 310     buf = PSDRV_PPDDecodeHex(tuple->value);
 311     HeapFree(PSDRV_Heap, 0, tuple->value);
 312     tuple->value = buf;
 313     return TRUE;
 314 }
 315
 316
 317 /***********************************************************************
 318  *
 319  *              PSDRV_PPDGetStringValue
 320  *
 321  * Just strip leading white space.
 322  */
 323 static BOOL PSDRV_PPDGetStringValue(char *str, PPDTuple *tuple)
 324 {
 325     char *start = str, *end;
 326
 327     while(*start != '\0' && isspace(*start))
 328         start++;
 329
 330     end = strpbrk(start, "/\r\n");
 331     if(!end) end = start + strlen(start);
 332     tuple->value = HeapAlloc( PSDRV_Heap, 0, (end - start) + 1 );
 333     memcpy(tuple->value, start, end - start);
 334     *(tuple->value + (end - start)) = '\0';
 335     if(*end == '/')
 336         PSDRV_PPDGetTransValue(end + 1, tuple);
 337     return TRUE;
 338 }
 339
 340
 341 /***********************************************************************
 342  *
 343  *              PSDRV_PPDSymbolValue
 344  *
 345  * Not implemented yet.
 346  */
 347 static BOOL PSDRV_PPDGetSymbolValue(char *pos, PPDTuple *tuple)
 348 {
 349     FIXME("Stub\n");
 350     return FALSE;
 351 }
 352
 353
 354 /*********************************************************************
 355  *
 356  *              PSDRV_PPDGetNextTuple
 357  *
 358  * Gets the next Keyword Option Value tuple from the file. Allocs space off
 359  * the process heap which should be free()ed by the caller if not needed.
 360  */
 361 static BOOL PSDRV_PPDGetNextTuple(FILE *fp, PPDTuple *tuple)
 362 {
 363     char line[257], *opt, *cp, *trans, *endkey;
 364     BOOL gotoption;
 365
 366  start:
 367
 368     gotoption = TRUE;
 369     opt = NULL;
 370     memset(tuple, 0, sizeof(*tuple));
 371
 372     do {
 373         if(!fgets(line, sizeof(line), fp))
 374             return FALSE;
 375         if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
 376             break;
 377     } while(1);
 378
 379     if(line[strlen(line)-1] != '\n') {
 380         ERR("Line too long.\n");
 381         goto start;
 382     }
 383
 384     for(cp = line; !isspace(*cp) && *cp != ':'; cp++)
 385         ;
 386
 387     endkey = cp;
 388     while (isspace(*cp)) cp++;
 389     if (*cp == ':') /* <key>: */
 390         gotoption = FALSE;
 391     else /* <key> <option> */
 392         opt = cp;
 393
 394     tuple->key = HeapAlloc( PSDRV_Heap, 0, endkey - line + 1 );
 395     if(!tuple->key) return FALSE;
 396
 397     memcpy(tuple->key, line, endkey - line);
 398     tuple->key[endkey - line] = '\0';
 399
 400     if(gotoption) { /* opt points to 1st non-space character of the option */
 401         cp = strpbrk(opt, ":/");
 402         if(!cp) {
 403             ERR("Error in line '%s'?\n", line);
 404             HeapFree(GetProcessHeap(), 0, tuple->key);
 405             goto start;
 406         }
 407         tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
 408         if(!tuple->option) return FALSE;
 409         memcpy(tuple->option, opt, cp - opt);
 410         tuple->option[cp - opt] = '\0';
 411         if(*cp == '/') {
 412             char *buf;
 413             trans = cp + 1;
 414             cp = strchr(trans, ':');
 415             if(!cp) {
 416                 ERR("Error in line '%s'?\n", line);
 417                 HeapFree(GetProcessHeap(), 0, tuple->option);
 418                 HeapFree(GetProcessHeap(), 0, tuple->key);
 419                 goto start;
 420             }
 421             buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
 422             if(!buf) return FALSE;
 423             memcpy(buf, trans, cp - trans);
 424             buf[cp - trans] = '\0';
 425             tuple->opttrans = PSDRV_PPDDecodeHex(buf);
 426             HeapFree( PSDRV_Heap, 0, buf );
 427         }
 428     }
 429
 430     /* cp should point to a ':', so we increment past it */
 431     cp++;
 432
 433     while(isspace(*cp))
 434         cp++;
 435
 436     switch(*cp) {
 437     case '"':
 438         if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
 439              !strncmp(tuple->key, "*JCL", 4))
 440             PSDRV_PPDGetQuotedValue(fp, cp, tuple);
 441         else
 442             PSDRV_PPDGetInvocationValue(fp, cp, tuple);
 443         break;
 444
 445     case '^':
 446         PSDRV_PPDGetSymbolValue(cp, tuple);
 447         break;
 448
 449     default:
 450         PSDRV_PPDGetStringValue(cp, tuple);
 451     }
 452     return TRUE;
 453 }
 454
 455 /*********************************************************************
 456  *                       get_pagesize
 457  *
 458  * Searches ppd PageSize list to return entry matching name or optionally creates new
 459  * entry which is appended to the list if name is not found.
 460  */
 461 static PAGESIZE *get_pagesize( PPD *ppd, char *name, BOOL create )
 462 {
 463     PAGESIZE *page;
 464
 465     LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry)
 466     {
 467         if(!strcmp(page->Name, name))
 468             return page;
 469     }
 470
 471     if (!create) return NULL;
 472
 473     page = HeapAlloc( PSDRV_Heap,  HEAP_ZERO_MEMORY, sizeof(*page) );
 474     list_add_tail(&ppd->PageSizes, &page->entry);
 475     return page;
 476 }
 477
 478 static DUPLEX *get_duplex( PPD *ppd, const char *name )
 479 {
 480     DUPLEX *duplex;
 481
 482     LIST_FOR_EACH_ENTRY( duplex, &ppd->Duplexes, DUPLEX, entry )
 483     {
 484         if (!strcmp( duplex->Name, name ))
 485             return duplex;
 486     }
 487
 488     return NULL;
 489 }
 490
 491 /**********************************************************************
 492  *
 493  *              PSDRV_PPDGetWord
 494  *
 495  * Returns ptr alloced from heap to first word in str. Strips leading spaces.
 496  * Puts ptr to next word in next
 497  */
 498 static char *PSDRV_PPDGetWord(char *str, char **next)
 499 {
 500     char *start, *end, *ret;
 501
 502     start = str;
 503     while(start && *start && isspace(*start))
 504         start++;
 505     if(!start || !*start) return FALSE;
 506
 507     end = start;
 508     while(*end && !isspace(*end))
 509         end++;
 510
 511     ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
 512     memcpy(ret, start, end - start );
 513     *(ret + (end - start)) = '\0';
 514
 515     while(*end && isspace(*end))
 516         end++;
 517     if(*end)
 518         *next = end;
 519     else
 520         *next = NULL;
 521
 522     return ret;
 523 }
 524
 525 /************************************************************
 526  *           parse_resolution
 527  *
 528  * Helper to extract x and y resolutions from a resolution entry.
 529  * Returns TRUE on successful parsing, otherwise FALSE.
 530  *
 531  * The ppd spec says that entries can either be:
 532  *    "nnndpi"
 533  * or
 534  *    "nnnxmmmdpi"
 535  * in the former case return sz.cx == cx.cy == nnn.
 536  *
 537  * There are broken ppd files out there (notably from Samsung) that
 538  * use the form "nnnmmmdpi", so we have to work harder to spot these.
 539  * We use a transition from a zero to a non-zero digit as separator
 540  * (and fail if we find more than one of these).  We also don't bother
 541  * trying to parse "dpi" in case that's missing.
 542  */
 543 static BOOL parse_resolution(const char *str, SIZE *sz)
 544 {
 545     int tmp[2];
 546     int *cur;
 547     BOOL had_zero;
 548     const char *c;
 549
 550     if(sscanf(str, "%dx%d", tmp, tmp + 1) == 2)
 551     {
 552         sz->cx = tmp[0];
 553         sz->cy = tmp[1];
 554         return TRUE;
 555     }
 556
 557     tmp[0] = 0;
 558     tmp[1] = -1;
 559     cur = tmp;
 560     had_zero = FALSE;
 561     for(c = str; isdigit(*c); c++)
 562     {
 563         if(!had_zero || *c == '0')
 564         {
 565             *cur *= 10;
 566             *cur += *c - '0';
 567             if(*c == '0')
 568                 had_zero = TRUE;
 569         }
 570         else if(cur != tmp)
 571             return FALSE;
 572         else
 573         {
 574             cur++;
 575             *cur = *c - '0';
 576             had_zero = FALSE;
 577         }
 578     }
 579     if(tmp[0] == 0) return FALSE;
 580
 581     sz->cx = tmp[0];
 582     if(tmp[1] != -1)
 583         sz->cy = tmp[1];
 584     else
 585         sz->cy = sz->cx;
 586     return TRUE;
 587 }
 588
 589 /*******************************************************************************
 590  *      PSDRV_AddSlot
 591  *
 592  */
 593 static BOOL PSDRV_AddSlot(PPD *ppd, LPCSTR szName, LPCSTR szFullName,
 594         LPSTR szInvocationString, WORD wWinBin)
 595 {
 596     INPUTSLOT *slot = HeapAlloc( PSDRV_Heap, 0, sizeof(INPUTSLOT) );
 597     if (!slot) return FALSE;
 598
 599     slot->Name = szName;
 600     slot->FullName = szFullName;
 601     slot->InvocationString = szInvocationString;
 602     slot->WinBin = wWinBin;
 603
 604     list_add_tail( &ppd->InputSlots, &slot->entry );
 605     return TRUE;
 606 }
 607
 608 static char *get_ppd_override( HANDLE printer, const char *value )
 609 {
 610     DWORD err, type, needed;
 611     char *data;
 612
 613     err = GetPrinterDataExA( printer, "PPD Overrides", value, &type, NULL, 0, &needed );
 614     if (err != ERROR_MORE_DATA || type != REG_SZ || needed == 0) return NULL;
 615
 616     data = HeapAlloc( PSDRV_Heap, 0, needed );
 617     if (data)
 618     {
 619         GetPrinterDataExA( printer, "PPD Overrides", value, &type, (BYTE*)data, needed, &needed );
 620         TRACE( "got override %s: %s\n", value, data );
 621     }
 622     return data;
 623 }
 624
 625 /***********************************************************************
 626  *
 627  *              PSDRV_ParsePPD
 628  *
 629  *
 630  */
 631 PPD *PSDRV_ParsePPD( char *fname, HANDLE printer )
 632 {
 633     FILE *fp;
 634     PPD *ppd;
 635     PPDTuple tuple;
 636     char *default_pagesize = NULL, *default_duplex = NULL;
 637     char *def_pagesize_override = NULL, *def_duplex_override = NULL;
 638     PAGESIZE *page, *page_cursor2;
 639
 640     TRACE("file '%s'\n", fname);
 641
 642     if((fp = fopen(fname, "r")) == NULL) {
 643         WARN("Couldn't open ppd file '%s'\n", fname);
 644         return NULL;
 645     }
 646
 647     ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
 648     if(!ppd) {
 649         ERR("Unable to allocate memory for ppd\n");
 650         fclose(fp);
 651         return NULL;
 652     }
 653
 654     ppd->ColorDevice = CD_NotSpecified;
 655
 656     list_init( &ppd->Resolutions );
 657     list_init( &ppd->InstalledFonts );
 658     list_init( &ppd->PageSizes );
 659     list_init( &ppd->Constraints );
 660     list_init( &ppd->InputSlots );
 661     list_init( &ppd->Duplexes );
 662
 663     /* Some gimp-print ppd files don't contain a DefaultResolution line
 664        so default to 300 */
 665     ppd->DefaultResolution = 300;
 666
 667     /*
 668      *  The Windows PostScript drivers create the following "virtual bin" for
 669      *  every PostScript printer
 670      */
 671     if (!PSDRV_AddSlot( ppd, NULL, "Automatically Select", NULL, DMBIN_FORMSOURCE ))
 672     {
 673         HeapFree (PSDRV_Heap, 0, ppd);
 674         fclose(fp);
 675         return NULL;
 676     }
 677
 678     while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
 679
 680         if(!strcmp("*NickName", tuple.key)) {
 681             ppd->NickName = tuple.value;
 682             tuple.value = NULL;
 683             TRACE("NickName = '%s'\n", ppd->NickName);
 684         }
 685
 686         else if(!strcmp("*LanguageLevel", tuple.key)) {
 687             sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
 688             TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
 689         }
 690
 691         else if(!strcmp("*ColorDevice", tuple.key)) {
 692             if(!strcasecmp(tuple.value, "true"))
 693                 ppd->ColorDevice = CD_True;
 694             else
 695                 ppd->ColorDevice = CD_False;
 696             TRACE("ColorDevice = %s\n", ppd->ColorDevice == CD_True ? "True" : "False");
 697         }
 698
 699         else if((!strcmp("*DefaultResolution", tuple.key)) ||
 700                 (!strcmp("*DefaultJCLResolution", tuple.key))) {
 701             SIZE sz;
 702             if(parse_resolution(tuple.value, &sz))
 703             {
 704                 TRACE("DefaultResolution %dx%d\n", sz.cx, sz.cy);
 705                 ppd->DefaultResolution = sz.cx;
 706             }
 707             else
 708                 WARN("failed to parse DefaultResolution %s\n", debugstr_a(tuple.value));
 709         }
 710
 711         else if(!strcmp("*Resolution", tuple.key))
 712         {
 713             SIZE sz;
 714             if (parse_resolution(tuple.option, &sz))
 715             {
 716                 RESOLUTION *res;
 717
 718                 TRACE("Resolution %dx%d, invocation %s\n", sz.cx, sz.cy, tuple.value);
 719
 720                 res = HeapAlloc( GetProcessHeap(), 0, sizeof(*res) );
 721                 res->resx = sz.cx;
 722                 res->resy = sz.cy;
 723                 res->InvocationString = tuple.value;
 724                 tuple.value = NULL;
 725                 list_add_tail( &ppd->Resolutions, &res->entry );
 726             }
 727             else
 728                 WARN("failed to parse Resolution %s\n", debugstr_a(tuple.option));
 729         }
 730
 731         else if(!strcmp("*Font", tuple.key))
 732         {
 733             FONTNAME *fn = HeapAlloc( PSDRV_Heap, 0, sizeof(*fn) );
 734             fn->Name = tuple.option;
 735             tuple.option = NULL;
 736             list_add_tail( &ppd->InstalledFonts, &fn->entry );
 737         }
 738
 739         else if(!strcmp("*DefaultFont", tuple.key)) {
 740             ppd->DefaultFont = tuple.value;
 741             tuple.value = NULL;
 742         }
 743
 744         else if(!strcmp("*JCLBegin", tuple.key)) {
 745             ppd->JCLBegin = tuple.value;
 746             tuple.value = NULL;
 747         }
 748
 749         else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
 750             ppd->JCLToPSInterpreter = tuple.value;
 751             tuple.value = NULL;
 752         }
 753
 754         else if(!strcmp("*JCLEnd", tuple.key)) {
 755             ppd->JCLEnd = tuple.value;
 756             tuple.value = NULL;
 757         }
 758
 759         else if(!strcmp("*PageSize", tuple.key)) {
 760             page = get_pagesize( ppd, tuple.option, TRUE );
 761
 762             if(!page->Name) {
 763                 int i;
 764
 765                 page->Name = tuple.option;
 766                 tuple.option = NULL;
 767
 768                 for(i = 0; PageTrans[i].PSName; i++) {
 769                     if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
 770                         page->WinPage = PageTrans[i].WinPage;
 771                         break;
 772                     }
 773                 }
 774                 if(!page->WinPage) {
 775                     TRACE("Can't find Windows page type for '%s' - using %u\n",
 776                           page->Name, UserPageType);
 777                     page->WinPage = UserPageType++;
 778                 }
 779             }
 780             if(!page->FullName) {
 781                 if(tuple.opttrans) {
 782                     page->FullName = tuple.opttrans;
 783                     tuple.opttrans = NULL;
 784                 } else
 785                 {
 786                     page->FullName = HeapAlloc( PSDRV_Heap, 0, strlen(page->Name)+1 );
 787                     strcpy( page->FullName, page->Name );
 788                 }
 789             }
 790             if(!page->InvocationString) {
 791                 page->InvocationString = tuple.value;
 792                 tuple.value = NULL;
 793             }
 794         }
 795
 796         else if(!strcmp("*DefaultPageSize", tuple.key))
 797         {
 798             if (!default_pagesize)
 799             {
 800                 default_pagesize = tuple.value;
 801                 tuple.value = NULL;
 802             }
 803         }
 804
 805         else if(!strcmp("*ImageableArea", tuple.key)) {
 806             page = get_pagesize( ppd, tuple.option, TRUE );
 807
 808             if(!page->Name) {
 809                 page->Name = tuple.option;
 810                 tuple.option = NULL;
 811             }
 812             if(!page->FullName) {
 813                 page->FullName = tuple.opttrans;
 814                 tuple.opttrans = NULL;
 815             }
 816
 817 #define PIA page->ImageableArea
 818             if(!PIA) {
 819                 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
 820                 push_lc_numeric("C");
 821                 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
 822                                                 &PIA->urx, &PIA->ury);
 823                 pop_lc_numeric();
 824             }
 825 #undef PIA
 826         }
 827
 828         else if(!strcmp("*PaperDimension", tuple.key)) {
 829             page = get_pagesize( ppd, tuple.option, TRUE );
 830
 831             if(!page->Name) {
 832                 page->Name = tuple.option;
 833                 tuple.option = NULL;
 834             }
 835             if(!page->FullName) {
 836                 page->FullName = tuple.opttrans;
 837                 tuple.opttrans = NULL;
 838             }
 839
 840 #define PD page->PaperDimension
 841             if(!PD) {
 842                 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
 843                 push_lc_numeric("C");
 844                 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
 845                 pop_lc_numeric();
 846             }
 847 #undef PD
 848         }
 849
 850         else if(!strcmp("*LandscapeOrientation", tuple.key)) {
 851             if(!strcmp(tuple.value, "Plus90"))
 852                 ppd->LandscapeOrientation = 90;
 853             else if(!strcmp(tuple.value, "Minus90"))
 854                 ppd->LandscapeOrientation = -90;
 855
 856             /* anything else, namely 'any', leaves value at 0 */
 857
 858             TRACE("LandscapeOrientation = %d\n",
 859                   ppd->LandscapeOrientation);
 860         }
 861
 862         else if(!strcmp("*UIConstraints", tuple.key))
 863         {
 864             char *start;
 865             CONSTRAINT *con = HeapAlloc( PSDRV_Heap, 0, sizeof(*con) );
 866
 867             start = tuple.value;
 868             con->Feature1 = PSDRV_PPDGetWord(start, &start);
 869             con->Value1 = PSDRV_PPDGetWord(start, &start);
 870             con->Feature2 = PSDRV_PPDGetWord(start, &start);
 871             con->Value2 = PSDRV_PPDGetWord(start, &start);
 872
 873             list_add_tail( &ppd->Constraints, &con->entry );
 874         }
 875
 876         else if (!strcmp("*InputSlot", tuple.key))
 877         {
 878
 879             if (!tuple.opttrans)
 880                 tuple.opttrans = tuple.option;
 881
 882             TRACE("Using Windows bin type %u for '%s'\n", UserBinType,
 883                     tuple.option);
 884
 885             /* FIXME - should check for failure */
 886             PSDRV_AddSlot(ppd, tuple.option, tuple.opttrans, tuple.value,
 887                     UserBinType++);
 888
 889             tuple.option = tuple.opttrans = tuple.value = NULL;
 890         }
 891
 892         /*
 893          *  Windows treats "manual feed" as another paper source.  Most PPD
 894          *  files, however, treat it as a separate option which is either on or
 895          *  off.
 896          */
 897         else if (!strcmp("*ManualFeed", tuple.key) && tuple.option &&
 898                 !strcmp ("True", tuple.option))
 899         {
 900             /* FIXME - should check for failure */
 901             PSDRV_AddSlot(ppd, "Manual Feed", "Manual Feed", tuple.value, DMBIN_MANUAL);
 902             tuple.value = NULL;
 903         }
 904
 905         else if(!strcmp("*TTRasterizer", tuple.key)) {
 906             if(!strcasecmp("None", tuple.value))
 907                 ppd->TTRasterizer = RO_None;
 908             else if(!strcasecmp("Accept68K", tuple.value))
 909                 ppd->TTRasterizer = RO_Accept68K;
 910             else if(!strcasecmp("Type42", tuple.value))
 911                 ppd->TTRasterizer = RO_Type42;
 912             else if(!strcasecmp("TrueImage", tuple.value))
 913                 ppd->TTRasterizer = RO_TrueImage;
 914             else {
 915                 FIXME("Unknown option %s for *TTRasterizer\n",
 916                       tuple.value);
 917                 ppd->TTRasterizer = RO_None;
 918             }
 919             TRACE("*TTRasterizer = %d\n", ppd->TTRasterizer);
 920         }
 921
 922         else if(!strcmp("*Duplex", tuple.key))
 923         {
 924             DUPLEX *duplex = HeapAlloc( GetProcessHeap(), 0, sizeof(*duplex) );
 925             duplex->Name = tuple.option;
 926             duplex->FullName = tuple.opttrans;
 927             duplex->InvocationString = tuple.value;
 928             if(!strcasecmp("None", tuple.option) || !strcasecmp("False", tuple.option)
 929                || !strcasecmp("Simplex", tuple.option))
 930                 duplex->WinDuplex = DMDUP_SIMPLEX;
 931             else if(!strcasecmp("DuplexNoTumble", tuple.option))
 932                 duplex->WinDuplex = DMDUP_VERTICAL;
 933             else if(!strcasecmp("DuplexTumble", tuple.option))
 934                 duplex->WinDuplex = DMDUP_HORIZONTAL;
 935             else if(!strcasecmp("Notcapable", tuple.option))
 936                 duplex->WinDuplex = 0;
 937             else {
 938                 FIXME("Unknown option %s for *Duplex defaulting to simplex\n", tuple.option);
 939                 duplex->WinDuplex = DMDUP_SIMPLEX;
 940             }
 941             tuple.option = tuple.opttrans = tuple.value = NULL;
 942             list_add_tail( &ppd->Duplexes, &duplex->entry );
 943         }
 944
 945         else if (!strcmp("*DefaultDuplex", tuple.key))
 946         {
 947             if (!default_duplex)
 948             {
 949                 default_duplex = tuple.value;
 950                 tuple.value = NULL;
 951             }
 952         }
 953
 954         HeapFree(PSDRV_Heap, 0, tuple.key);
 955         HeapFree(PSDRV_Heap, 0, tuple.option);
 956         HeapFree(PSDRV_Heap, 0, tuple.value);
 957         HeapFree(PSDRV_Heap, 0, tuple.opttrans);
 958         HeapFree(PSDRV_Heap, 0, tuple.valtrans);
 959
 960     }
 961
 962     /* Remove any partial page size entries, that is any without a PageSize or a PaperDimension (we can
 963        cope with a missing ImageableArea). */
 964     LIST_FOR_EACH_ENTRY_SAFE(page, page_cursor2, &ppd->PageSizes, PAGESIZE, entry)
 965     {
 966         if(!page->InvocationString || !page->PaperDimension)
 967         {
 968             WARN("Removing page %s since it has a missing %s entry\n", debugstr_a(page->FullName),
 969                  page->InvocationString ? "PaperDimension" : "InvocationString");
 970             HeapFree(PSDRV_Heap, 0, page->Name);
 971             HeapFree(PSDRV_Heap, 0, page->FullName);
 972             HeapFree(PSDRV_Heap, 0, page->InvocationString);
 973             HeapFree(PSDRV_Heap, 0, page->ImageableArea);
 974             HeapFree(PSDRV_Heap, 0, page->PaperDimension);
 975             list_remove(&page->entry);
 976         }
 977     }
 978
 979     ppd->DefaultPageSize = NULL;
 980     def_pagesize_override = get_ppd_override( printer, "DefaultPageSize" );
 981     if (def_pagesize_override)
 982         ppd->DefaultPageSize = get_pagesize( ppd, def_pagesize_override, FALSE );
 983     if (!ppd->DefaultPageSize && default_pagesize)
 984         ppd->DefaultPageSize = get_pagesize( ppd, default_pagesize, FALSE );
 985
 986     if (!ppd->DefaultPageSize)
 987     {
 988         struct list *head = list_head( &ppd->PageSizes );
 989         if (head) ppd->DefaultPageSize = LIST_ENTRY( head, PAGESIZE, entry );
 990         TRACE("Setting DefaultPageSize to first in list\n");
 991     }
 992     TRACE( "DefaultPageSize: %s\n", ppd->DefaultPageSize ? ppd->DefaultPageSize->Name : "<not set>" );
 993
 994     HeapFree( PSDRV_Heap, 0, def_pagesize_override );
 995     HeapFree( PSDRV_Heap, 0, default_pagesize );
 996
 997     ppd->DefaultDuplex = NULL;
 998     def_duplex_override = get_ppd_override( printer, "DefaultDuplex" );
 999     if (def_duplex_override)
1000         ppd->DefaultDuplex = get_duplex( ppd, def_duplex_override );
1001     if (!ppd->DefaultDuplex && default_duplex)
1002         ppd->DefaultDuplex = get_duplex( ppd, default_duplex );
1003
1004     if (!ppd->DefaultDuplex)
1005     {
1006         struct list *head = list_head( &ppd->Duplexes );
1007         if (head) ppd->DefaultDuplex = LIST_ENTRY( head, DUPLEX, entry );
1008         TRACE("Setting DefaultDuplex to first in list\n");
1009     }
1010     TRACE( "DefaultDuplex: %s\n", ppd->DefaultDuplex ? ppd->DefaultDuplex->Name : "<not set>" );
1011
1012     HeapFree( PSDRV_Heap, 0, def_duplex_override );
1013     HeapFree( PSDRV_Heap, 0, default_duplex );
1014
1015
1016     {
1017         FONTNAME *fn;
1018         PAGESIZE *page;
1019         CONSTRAINT *con;
1020         INPUTSLOT *slot;
1021
1022         LIST_FOR_EACH_ENTRY( fn, &ppd->InstalledFonts, FONTNAME, entry )
1023             TRACE("'%s'\n", fn->Name);
1024
1025         LIST_FOR_EACH_ENTRY(page, &ppd->PageSizes, PAGESIZE, entry) {
1026             TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
1027               page->FullName, page->WinPage, page->InvocationString);
1028             if(page->ImageableArea)
1029                 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
1030                       page->ImageableArea->llx, page->ImageableArea->lly,
1031                       page->ImageableArea->urx, page->ImageableArea->ury);
1032             if(page->PaperDimension)
1033                 TRACE("Dimension = %.2f x %.2f\n",
1034                       page->PaperDimension->x, page->PaperDimension->y);
1035         }
1036
1037         LIST_FOR_EACH_ENTRY( con, &ppd->Constraints, CONSTRAINT, entry )
1038             TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
1039                   con->Value1, con->Feature2, con->Value2);
1040
1041         LIST_FOR_EACH_ENTRY( slot, &ppd->InputSlots, INPUTSLOT, entry )
1042             TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
1043                   debugstr_a(slot->Name), slot->FullName, slot->WinBin,
1044                   debugstr_a(slot->InvocationString));
1045     }
1046
1047     fclose(fp);
1048     return ppd;
1049 }