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