graphics/psdrv/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
   8 #include <string.h>
   9 #include <ctype.h>
  10 #include "winnt.h" /* HEAP_ZERO_MEMORY */
  11 #include "heap.h"
  12 #include "debugtools.h"
  13 #include "psdrv.h"
  14 #include "winspool.h"
  15
  16 DEFAULT_DEBUG_CHANNEL(psdrv)
  17
  18 typedef struct {
  19 char    *key;
  20 char    *option;
  21 char    *opttrans;
  22 char    *value;
  23 char    *valtrans;
  24 } PPDTuple;
  25
  26
  27 /* map of page names in ppd file to Windows paper constants */
  28
  29 static struct {
  30   char *PSName;
  31   WORD WinPage;
  32 } PageTrans[] = {
  33   {"10x11",                   DMPAPER_10X11},
  34   {"10x14",                   DMPAPER_10X14},
  35   {"12x11",                   DMPAPER_12X11},
  36   {"15x11",                   DMPAPER_15X11},
  37   {"9x11",                    DMPAPER_9X11},
  38   {"A2",                      DMPAPER_A2},
  39   {"A3",                      DMPAPER_A3},
  40   {"A3.Transverse",           DMPAPER_A3_TRANSVERSE},
  41   {"A3Extra",                 DMPAPER_A3_EXTRA},
  42   {"A3Extra.Transverse",      DMPAPER_A3_EXTRA_TRANSVERSE},
  43   {"A3Rotated",               DMPAPER_A3_ROTATED},
  44   {"A4",                      DMPAPER_A4},
  45   {"A4.Transverse",           DMPAPER_A4_TRANSVERSE},
  46   {"A4Extra",                 DMPAPER_A4_EXTRA},
  47   {"A4Plus",                  DMPAPER_A4_PLUS},
  48   {"A4Rotated",               DMPAPER_A4_ROTATED},
  49   {"A4Small",                 DMPAPER_A4SMALL},
  50   {"A5",                      DMPAPER_A5},
  51   {"A5.Transverse",           DMPAPER_A5_TRANSVERSE},
  52   {"A5Extra",                 DMPAPER_A5_EXTRA},
  53   {"A5Rotated",               DMPAPER_A5_ROTATED},
  54   {"A6",                      DMPAPER_A6},
  55   {"A6Rotated",               DMPAPER_A6_ROTATED},
  56   {"ARCHC",                   DMPAPER_CSHEET},
  57   {"ARCHD",                   DMPAPER_DSHEET},
  58   {"ARCHE",                   DMPAPER_ESHEET},
  59   {"B4",                      DMPAPER_B4},
  60   {"B4Rotated",               DMPAPER_B4_JIS_ROTATED},
  61   {"B5",                      DMPAPER_B5},
  62   {"B5.Transverse",           DMPAPER_B5_TRANSVERSE},
  63   {"B5Rotated",               DMPAPER_B5_JIS_ROTATED},
  64   {"B6",                      DMPAPER_B6_JIS},
  65   {"B6Rotated",               DMPAPER_B6_JIS_ROTATED},
  66   {"C4",                      DMPAPER_ENV_C4},
  67   {"C5",                      DMPAPER_ENV_C5},
  68   {"C6",                      DMPAPER_ENV_C6},
  69   {"Comm10",                  DMPAPER_ENV_10},
  70   {"DL",                      DMPAPER_ENV_DL},
  71   {"DoublePostcard",          DMPAPER_DBL_JAPANESE_POSTCARD},
  72   {"DoublePostcardRotated",   DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED},
  73   {"Env9",                    DMPAPER_ENV_9},
  74   {"Env10",                   DMPAPER_ENV_10},
  75   {"Env11",                   DMPAPER_ENV_11},
  76   {"Env12",                   DMPAPER_ENV_12},
  77   {"Env14",                   DMPAPER_ENV_14},
  78   {"EnvC3",                   DMPAPER_ENV_C3},
  79   {"EnvC4",                   DMPAPER_ENV_C4},
  80   {"EnvC5",                   DMPAPER_ENV_C5},
  81   {"EnvC6",                   DMPAPER_ENV_C6},
  82   {"EnvC65",                  DMPAPER_ENV_C65},
  83   {"EnvChou3",                DMPAPER_JENV_CHOU3},
  84   {"EnvChou3Rotated",         DMPAPER_JENV_CHOU3_ROTATED},
  85   {"EnvChou4",                DMPAPER_JENV_CHOU4},
  86   {"EnvChou4Rotated",         DMPAPER_JENV_CHOU4_ROTATED},
  87   {"EnvDL",                   DMPAPER_ENV_DL},
  88   {"EnvInvite",               DMPAPER_ENV_INVITE},
  89   {"EnvISOB4",                DMPAPER_ENV_B4},
  90   {"EnvISOB5",                DMPAPER_ENV_B5},
  91   {"EnvISOB6",                DMPAPER_ENV_B6},
  92   {"EnvItalian",              DMPAPER_ENV_ITALY},
  93   {"EnvKaku2",                DMPAPER_JENV_KAKU2},
  94   {"EnvKaku2Rotated",         DMPAPER_JENV_KAKU2_ROTATED},
  95   {"EnvKaku3",                DMPAPER_JENV_KAKU3},
  96   {"EnvKaku3Rotated",         DMPAPER_JENV_KAKU3_ROTATED},
  97   {"EnvMonarch",              DMPAPER_ENV_MONARCH},
  98   {"EnvPersonal",             DMPAPER_ENV_PERSONAL},
  99   {"EnvPRC1",                 DMPAPER_PENV_1},
 100   {"EnvPRC1Rotated",          DMPAPER_PENV_1_ROTATED},
 101   {"EnvPRC2",                 DMPAPER_PENV_2},
 102   {"EnvPRC2Rotated",          DMPAPER_PENV_2_ROTATED},
 103   {"EnvPRC3",                 DMPAPER_PENV_3},
 104   {"EnvPRC3Rotated",          DMPAPER_PENV_3_ROTATED},
 105   {"EnvPRC4",                 DMPAPER_PENV_4},
 106   {"EnvPRC4Rotated",          DMPAPER_PENV_4_ROTATED},
 107   {"EnvPRC5",                 DMPAPER_PENV_5},
 108   {"EnvPRC5Rotated",          DMPAPER_PENV_5_ROTATED},
 109   {"EnvPRC6",                 DMPAPER_PENV_6},
 110   {"EnvPRC6Rotated",          DMPAPER_PENV_6_ROTATED},
 111   {"EnvPRC7",                 DMPAPER_PENV_7},
 112   {"EnvPRC7Rotated",          DMPAPER_PENV_7_ROTATED},
 113   {"EnvPRC8",                 DMPAPER_PENV_8},
 114   {"EnvPRC8Rotated",          DMPAPER_PENV_8_ROTATED},
 115   {"EnvPRC9",                 DMPAPER_PENV_9},
 116   {"EnvPRC9Rotated",          DMPAPER_PENV_9_ROTATED},
 117   {"EnvPRC10",                DMPAPER_PENV_10},
 118   {"EnvPRC10Rotated",         DMPAPER_PENV_10_ROTATED},
 119   {"EnvYou4",                 DMPAPER_JENV_YOU4},
 120   {"EnvYou4Rotated",          DMPAPER_JENV_YOU4_ROTATED},
 121   {"Executive",               DMPAPER_EXECUTIVE},
 122   {"FanFoldUS",               DMPAPER_FANFOLD_US},
 123   {"FanFoldGerman",           DMPAPER_FANFOLD_STD_GERMAN},
 124   {"FanFoldGermanLegal",      DMPAPER_FANFOLD_LGL_GERMAN},
 125   {"Folio",                   DMPAPER_FOLIO},
 126   {"ISOB4",                   DMPAPER_ISO_B4},
 127   {"ISOB5Extra",              DMPAPER_B5_EXTRA},
 128   {"Ledger",                  DMPAPER_LEDGER},
 129   {"Legal",                   DMPAPER_LEGAL},
 130   {"LegalExtra",              DMPAPER_LEGAL_EXTRA},
 131   {"Letter",                  DMPAPER_LETTER},
 132   {"Letter.Transverse",       DMPAPER_LETTER_TRANSVERSE},
 133   {"LetterExtra",             DMPAPER_LETTER_EXTRA},
 134   {"LetterExtra.Transverse",  DMPAPER_LETTER_EXTRA_TRANSVERSE},
 135   {"LetterPlus",              DMPAPER_LETTER_PLUS},
 136   {"LetterRotated",           DMPAPER_LETTER_ROTATED},
 137   {"LetterSmall",             DMPAPER_LETTERSMALL},
 138   {"Monarch",                 DMPAPER_ENV_MONARCH},
 139   {"Note",                    DMPAPER_NOTE},
 140   {"Postcard",                DMPAPER_JAPANESE_POSTCARD},
 141   {"PostcardRotated",         DMPAPER_JAPANESE_POSTCARD_ROTATED},
 142   {"PRC16K",                  DMPAPER_P16K},
 143   {"PRC16KRotated",           DMPAPER_P16K_ROTATED},
 144   {"PRC32K",                  DMPAPER_P32K},
 145   {"PRC32KBig",               DMPAPER_P32KBIG},
 146   {"PRC32KBigRotated",        DMPAPER_P32KBIG_ROTATED},
 147   {"PRC32KRotated",           DMPAPER_P32K_ROTATED},
 148   {"Quarto",                  DMPAPER_QUARTO},
 149   {"Statement",               DMPAPER_STATEMENT},
 150   {"SuperA",                  DMPAPER_A_PLUS},
 151   {"SuperB",                  DMPAPER_B_PLUS},
 152   {"Tabloid",                 DMPAPER_TABLOID},
 153   {"TabloidExtra",            DMPAPER_TABLOID_EXTRA},
 154   {NULL,                      0}
 155 };
 156
 157 /* the same for bin names */
 158
 159 static struct {
 160   char *PSName;
 161   WORD WinBin;
 162 } BinTrans[] = {
 163   {"Envelope",          DMBIN_ENVELOPE},
 164   {"LargeCapacity",     DMBIN_LARGECAPACITY},
 165   {"Lower",             DMBIN_LOWER},
 166   {"ManualFeed",        DMBIN_MANUAL},
 167   {"Middle",            DMBIN_MIDDLE},
 168   {"Upper",             DMBIN_UPPER},
 169   {NULL,                0}
 170 };
 171
 172 /***********************************************************************
 173  *
 174  *              PSDRV_PPDDecodeHex
 175  *
 176  * Copies str into a newly allocated string from the process heap subsituting
 177  * hex strings enclosed in '<' and '>' for their byte codes.
 178  *
 179  */
 180 static char *PSDRV_PPDDecodeHex(char *str)
 181 {
 182     char *buf, *in, *out;
 183     BOOL inhex = FALSE;
 184
 185     buf = HeapAlloc(PSDRV_Heap, 0, strlen(str) + 1);
 186     if(!buf)
 187         return NULL;
 188
 189     for(in = str, out = buf; *in; in++) {
 190         if(!inhex) {
 191             if(*in != '<')
 192                 *out++ = *in;
 193             else
 194                 inhex = TRUE;
 195         } else {
 196             if(*in == '>') {
 197                 inhex = FALSE;
 198                 continue;
 199             }
 200             else if(isspace(*in))
 201                 continue;
 202             else {
 203                 int i;
 204                 if(!isxdigit(*in) || !isxdigit(*(in + 1))) {
 205                     ERR("Invalid hex char in hex string\n");
 206                     HeapFree(PSDRV_Heap, 0, buf);
 207                     return NULL;
 208                 }
 209                 *out = 0;
 210                 for(i = 0; i < 2; i++) {
 211                     if(isdigit(*(in + i)))
 212                         *out |= (*(in + i) - '0') << ((1-i) * 4);
 213                     else
 214                         *out |= (toupper(*(in + i)) - 'A' + 10) << ((1-i) * 4);
 215                 }
 216                 out++;
 217                 in++;
 218             }
 219         }
 220     }
 221     *out = '\0';
 222     return buf;
 223 }
 224
 225
 226 /***********************************************************************
 227  *
 228  *              PSDRV_PPDGetTransValue
 229  *
 230  */
 231 static BOOL PSDRV_PPDGetTransValue(char *start, PPDTuple *tuple)
 232 {
 233     char *buf, *end;
 234
 235     end = strpbrk(start, "\r\n");
 236     if(end == start) return FALSE;
 237     if(!end) end = start + strlen(start);
 238     buf = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
 239     memcpy(buf, start, end - start);
 240     *(buf + (end - start)) = '\0';
 241     tuple->valtrans = PSDRV_PPDDecodeHex(buf);
 242     HeapFree( PSDRV_Heap, 0, buf );
 243     return TRUE;
 244 }
 245
 246
 247 /***********************************************************************
 248  *
 249  *              PSDRV_PPDGetInvocationValue
 250  *
 251  * Passed string that should be surrounded by `"'s, return string alloced
 252  * from process heap.
 253  */
 254 static BOOL PSDRV_PPDGetInvocationValue(FILE *fp, char *pos, PPDTuple *tuple)
 255 {
 256     char *start, *end, *buf;
 257     char line[257];
 258     int len;
 259
 260     start = pos + 1;
 261     buf = HeapAlloc( PSDRV_Heap, 0, strlen(start) + 1 );
 262     len = 0;
 263     do {
 264         end = strchr(start, '"');
 265         if(end) {
 266             buf = HeapReAlloc( PSDRV_Heap, 0, buf,
 267                                len + (end - start) + 1 );
 268             memcpy(buf + len, start, end - start);
 269             *(buf + len + (end - start)) = '\0';
 270             tuple->value = buf;
 271             start = strchr(end, '/');
 272             if(start)
 273                 return PSDRV_PPDGetTransValue(start + 1, tuple);
 274             return TRUE;
 275         } else {
 276             int sl = strlen(start);
 277             buf = HeapReAlloc( PSDRV_Heap, 0, buf, len + sl + 1 );
 278             strcpy(buf + len, start);
 279             len += sl;
 280         }
 281     } while( fgets((start = line), sizeof(line), fp) );
 282
 283     tuple->value = NULL;
 284     HeapFree( PSDRV_Heap, 0, buf );
 285     return FALSE;
 286 }
 287
 288
 289 /***********************************************************************
 290  *
 291  *              PSDRV_PPDGetQuotedValue
 292  *
 293  * Passed string that should be surrounded by `"'s. Expand <xx> as hex
 294  * return string alloced from process heap.
 295  */
 296 static BOOL PSDRV_PPDGetQuotedValue(FILE *fp, char *pos, PPDTuple *tuple)
 297 {
 298     char *buf;
 299
 300     if(!PSDRV_PPDGetInvocationValue(fp, pos, tuple))
 301         return FALSE;
 302     buf = PSDRV_PPDDecodeHex(tuple->value);
 303     HeapFree(PSDRV_Heap, 0, tuple->value);
 304     tuple->value = buf;
 305     return TRUE;
 306 }
 307
 308
 309 /***********************************************************************
 310  *
 311  *              PSDRV_PPDGetStringValue
 312  *
 313  * Just strip leading white space.
 314  */
 315 static BOOL PSDRV_PPDGetStringValue(char *str, PPDTuple *tuple)
 316 {
 317     char *start = str, *end;
 318
 319     while(*start != '\0' && isspace(*start))
 320         start++;
 321
 322     end = strpbrk(start, "/\r\n");
 323     if(!end) end = start + strlen(start);
 324     tuple->value = HeapAlloc( PSDRV_Heap, 0, (end - start) + 1 );
 325     memcpy(tuple->value, start, end - start);
 326     *(tuple->value + (end - start)) = '\0';
 327     if(*end == '/')
 328         PSDRV_PPDGetTransValue(end + 1, tuple);
 329     return TRUE;
 330 }
 331
 332
 333 /***********************************************************************
 334  *
 335  *              PSDRV_PPDSymbolValue
 336  *
 337  * Not implemented yet.
 338  */
 339 static BOOL PSDRV_PPDGetSymbolValue(char *pos, PPDTuple *tuple)
 340 {
 341     FIXME("Stub\n");
 342     return FALSE;
 343 }
 344
 345
 346 /*********************************************************************
 347  *
 348  *              PSDRV_PPDGetNextTuple
 349  *
 350  * Gets the next Keyword Option Value tuple from the file. Allocs space off
 351  * the process heap which should be free()ed by the caller if not needed.
 352  */
 353 static BOOL PSDRV_PPDGetNextTuple(FILE *fp, PPDTuple *tuple)
 354 {
 355     char line[257], *opt = NULL, *cp, *trans;
 356     BOOL gotoption = TRUE;
 357
 358     memset(tuple, 0, sizeof(*tuple));
 359
 360     do {
 361         if(!fgets(line, sizeof(line), fp))
 362             return FALSE;
 363         if(line[0] == '*' && line[1] != '%' && strncmp(line, "*End", 4))
 364             break;
 365     } while(1);
 366
 367     if(line[strlen(line)-1] != '\n') {
 368         ERR("Line too long.\n");
 369         return FALSE;
 370     }
 371
 372     for(cp = line; !isspace(*cp); cp++)
 373         ;
 374
 375     if(*(cp-1) == ':') {
 376         cp--;
 377         gotoption = FALSE;
 378     } else {
 379         opt = cp;
 380     }
 381
 382     tuple->key = HeapAlloc( PSDRV_Heap, 0, cp - line + 1 );
 383     if(!tuple->key) return FALSE;
 384
 385     memcpy(tuple->key, line, cp - line);
 386     tuple->key[cp - line] = '\0';
 387
 388     if(gotoption) {
 389         while(isspace(*opt))
 390             opt++;
 391         cp = strpbrk(opt, ":/");
 392         if(!cp) {
 393             ERR("Error in line '%s'?\n", line);
 394             return FALSE;
 395         }
 396         tuple->option = HeapAlloc( PSDRV_Heap, 0, cp - opt + 1 );
 397         if(!tuple->option) return FALSE;
 398         memcpy(tuple->option, opt, cp - opt);
 399         tuple->option[cp - opt] = '\0';
 400         if(*cp == '/') {
 401             char *buf;
 402             trans = cp + 1;
 403             cp = strchr(trans, ':');
 404             if(!cp) {
 405                 ERR("Error in line '%s'?\n", line);
 406                 return FALSE;
 407             }
 408             buf = HeapAlloc( PSDRV_Heap, 0, cp - trans + 1 );
 409             if(!buf) return FALSE;
 410             memcpy(buf, trans, cp - trans);
 411             buf[cp - trans] = '\0';
 412             tuple->opttrans = PSDRV_PPDDecodeHex(buf);
 413             HeapFree( PSDRV_Heap, 0, buf );
 414         }
 415     }
 416     while(!isspace(*cp))
 417         cp++;
 418
 419     while(isspace(*cp))
 420         cp++;
 421
 422     switch(*cp) {
 423     case '"':
 424         if( (!gotoption && strncmp(tuple->key, "*?", 2) ) ||
 425              !strncmp(tuple->key, "*JCL", 4))
 426             PSDRV_PPDGetQuotedValue(fp, cp, tuple);
 427         else
 428             PSDRV_PPDGetInvocationValue(fp, cp, tuple);
 429         break;
 430
 431     case '^':
 432         PSDRV_PPDGetSymbolValue(cp, tuple);
 433         break;
 434
 435     default:
 436         PSDRV_PPDGetStringValue(cp, tuple);
 437     }
 438     return TRUE;
 439 }
 440
 441 /*********************************************************************
 442  *
 443  *              PSDRV_PPDGetPageSizeInfo
 444  *
 445  * Searches ppd PageSize list to return entry matching name or creates new
 446  * entry which is appended to the list if name is not found.
 447  *
 448  */
 449 PAGESIZE *PSDRV_PPDGetPageSizeInfo(PPD *ppd, char *name)
 450 {
 451     PAGESIZE *page = ppd->PageSizes, *lastpage;
 452
 453     if(!page) {
 454        page = ppd->PageSizes = HeapAlloc( PSDRV_Heap,
 455                                             HEAP_ZERO_MEMORY, sizeof(*page) );
 456        return page;
 457     } else {
 458         for( ; page; page = page->next) {
 459             if(!strcmp(page->Name, name))
 460                  return page;
 461             lastpage = page;
 462         }
 463
 464         lastpage->next = HeapAlloc( PSDRV_Heap,
 465                                            HEAP_ZERO_MEMORY, sizeof(*page) );
 466         return lastpage->next;
 467     }
 468 }
 469
 470 /**********************************************************************
 471  *
 472  *              PSDRV_PPDGetWord
 473  *
 474  * Returns ptr alloced from heap to first word in str. Strips leading spaces.
 475  * Puts ptr to next word in next
 476  */
 477 static char *PSDRV_PPDGetWord(char *str, char **next)
 478 {
 479     char *start, *end, *ret;
 480
 481     start = str;
 482     while(start && *start && isspace(*start))
 483         start++;
 484     if(!start || !*start) return FALSE;
 485
 486     end = start;
 487     while(*end && !isspace(*end))
 488         end++;
 489
 490     ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
 491     memcpy(ret, start, end - start );
 492     *(ret + (end - start)) = '\0';
 493
 494     while(*end && isspace(*end))
 495         end++;
 496     if(*end)
 497         *next = end;
 498     else
 499         *next = NULL;
 500
 501     return ret;
 502 }
 503
 504 /***********************************************************************
 505  *
 506  *              PSDRV_ParsePPD
 507  *
 508  *
 509  */
 510 PPD *PSDRV_ParsePPD(char *fname)
 511 {
 512     FILE *fp;
 513     PPD *ppd;
 514     PPDTuple tuple;
 515
 516     TRACE("%s\n", fname);
 517
 518     if((fp = fopen(fname, "r")) == NULL) {
 519         WARN("Couldn't open ppd file '%s'\n", fname);
 520         return NULL;
 521     }
 522
 523     ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
 524     if(!ppd) {
 525         ERR("Unable to allocate memory for ppd\n");
 526         fclose(fp);
 527         return NULL;
 528     }
 529
 530
 531     while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
 532
 533         if(!strcmp("*NickName", tuple.key)) {
 534             ppd->NickName = tuple.value;
 535             tuple.value = NULL;
 536             TRACE("NickName = '%s'\n", ppd->NickName);
 537         }
 538
 539         else if(!strcmp("*LanguageLevel", tuple.key)) {
 540             sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
 541             TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
 542         }
 543
 544         else if(!strcmp("*ColorDevice", tuple.key)) {
 545             if(!strcasecmp(tuple.value, "true"))
 546                 ppd->ColorDevice = TRUE;
 547             TRACE("ColorDevice = %d\n", (int)ppd->ColorDevice);
 548         }
 549
 550         else if((!strcmp("*DefaultResolution", tuple.key)) ||
 551                 (!strcmp("*DefaultJCLResolution", tuple.key))) {
 552             sscanf(tuple.value, "%d", &(ppd->DefaultResolution));
 553             TRACE("DefaultResolution = %d\n", ppd->DefaultResolution);
 554         }
 555
 556         else if(!strcmp("*Font", tuple.key)) {
 557             FONTNAME *fn;
 558
 559             for(fn = ppd->InstalledFonts; fn && fn->next; fn = fn->next)
 560                 ;
 561             if(!fn) {
 562                 ppd->InstalledFonts = HeapAlloc(PSDRV_Heap,
 563                                                HEAP_ZERO_MEMORY, sizeof(*fn));
 564                 fn = ppd->InstalledFonts;
 565             } else {
 566                fn->next = HeapAlloc(PSDRV_Heap,
 567                                                HEAP_ZERO_MEMORY, sizeof(*fn));
 568                fn = fn->next;
 569             }
 570             fn->Name = tuple.option;
 571             tuple.option = NULL;
 572         }
 573
 574         else if(!strcmp("*DefaultFont", tuple.key)) {
 575             ppd->DefaultFont = tuple.value;
 576             tuple.value = NULL;
 577         }
 578
 579         else if(!strcmp("*JCLBegin", tuple.key)) {
 580             ppd->JCLBegin = tuple.value;
 581             tuple.value = NULL;
 582         }
 583
 584         else if(!strcmp("*JCLToPSInterpreter", tuple.key)) {
 585             ppd->JCLToPSInterpreter = tuple.value;
 586             tuple.value = NULL;
 587         }
 588
 589         else if(!strcmp("*JCLEnd", tuple.key)) {
 590             ppd->JCLEnd = tuple.value;
 591             tuple.value = NULL;
 592         }
 593
 594         else if(!strcmp("*PageSize", tuple.key)) {
 595             PAGESIZE *page;
 596             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
 597
 598             if(!page->Name) {
 599                 int i;
 600
 601                 page->Name = tuple.option;
 602                 tuple.option = NULL;
 603
 604                 for(i = 0; PageTrans[i].PSName; i++) {
 605                     if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
 606                         page->WinPage = PageTrans[i].WinPage;
 607                         break;
 608                     }
 609                 }
 610                 if(!page->WinPage)
 611                     FIXME("Can't find Windows page type for '%s'\n",
 612                           page->Name);
 613             }
 614             if(!page->FullName) {
 615                 page->FullName = tuple.opttrans;
 616                 tuple.opttrans = NULL;
 617             }
 618             if(!page->InvocationString) {
 619                 page->InvocationString = tuple.value;
 620                 tuple.value = NULL;
 621             }
 622         }
 623
 624         else if(!strcmp("*ImageableArea", tuple.key)) {
 625             PAGESIZE *page;
 626             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
 627
 628             if(!page->Name) {
 629                 page->Name = tuple.option;
 630                 tuple.option = NULL;
 631             }
 632             if(!page->FullName) {
 633                 page->FullName = tuple.opttrans;
 634                 tuple.opttrans = NULL;
 635             }
 636
 637 #define PIA page->ImageableArea
 638             if(!PIA) {
 639                 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
 640                 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
 641                                                 &PIA->urx, &PIA->ury);
 642             }
 643 #undef PIA
 644         }
 645
 646
 647         else if(!strcmp("*PaperDimension", tuple.key)) {
 648             PAGESIZE *page;
 649             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
 650
 651             if(!page->Name) {
 652                 page->Name = tuple.option;
 653                 tuple.option = NULL;
 654             }
 655             if(!page->FullName) {
 656                 page->FullName = tuple.opttrans;
 657                 tuple.opttrans = NULL;
 658             }
 659
 660 #define PD page->PaperDimension
 661             if(!PD) {
 662                 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
 663                 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
 664             }
 665 #undef PD
 666         }
 667
 668         else if(!strcmp("*LandscapeOrientation", tuple.key)) {
 669             if(!strcmp(tuple.value, "Plus90"))
 670                 ppd->LandscapeOrientation = 90;
 671             else if(!strcmp(tuple.value, "Minus90"))
 672                 ppd->LandscapeOrientation = -90;
 673
 674             /* anything else, namely 'any', leaves value at 0 */
 675
 676             TRACE("LandscapeOrientation = %d\n",
 677                   ppd->LandscapeOrientation);
 678         }
 679
 680         else if(!strcmp("*UIConstraints", tuple.key)) {
 681             char *start;
 682             CONSTRAINT *con, **insert = &ppd->Constraints;
 683
 684             while(*insert)
 685                 insert = &((*insert)->next);
 686
 687             con = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
 688                                        sizeof(*con) );
 689
 690             start = tuple.value;
 691
 692             con->Feature1 = PSDRV_PPDGetWord(start, &start);
 693             con->Value1 = PSDRV_PPDGetWord(start, &start);
 694             con->Feature2 = PSDRV_PPDGetWord(start, &start);
 695             con->Value2 = PSDRV_PPDGetWord(start, &start);
 696         }
 697
 698         else if(!strcmp("*InputSlot", tuple.key)) {
 699             INPUTSLOT *slot, **insert = &ppd->InputSlots;
 700             int i;
 701
 702             while(*insert)
 703                 insert = &((*insert)->next);
 704
 705             slot = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
 706                                     sizeof(*slot) );
 707
 708             slot->Name = tuple.option;
 709             tuple.option = NULL;
 710             if(tuple.opttrans) {
 711                 slot->FullName = tuple.opttrans;
 712                 tuple.opttrans = NULL;
 713             }
 714             if(tuple.value) {
 715                 slot->InvocationString = tuple.value;
 716                 tuple.value = NULL;
 717             }
 718
 719
 720             for(i = 0; BinTrans[i].PSName; i++) {
 721                 if(!strcmp(BinTrans[i].PSName, slot->Name)) { /* case ? */
 722                     slot->WinBin = BinTrans[i].WinBin;
 723                     break;
 724                 }
 725             }
 726             if(!slot->WinBin)
 727                 FIXME("Can't find Windows bin type for '%s'\n",
 728                           slot->Name);
 729
 730         }
 731
 732         if(tuple.key) HeapFree(PSDRV_Heap, 0, tuple.key);
 733         if(tuple.option) HeapFree(PSDRV_Heap, 0, tuple.option);
 734         if(tuple.value) HeapFree(PSDRV_Heap, 0, tuple.value);
 735         if(tuple.opttrans) HeapFree(PSDRV_Heap, 0, tuple.opttrans);
 736         if(tuple.valtrans) HeapFree(PSDRV_Heap, 0, tuple.valtrans);
 737
 738     }
 739
 740
 741     {
 742         FONTNAME *fn;
 743         PAGESIZE *page;
 744         CONSTRAINT *con;
 745         INPUTSLOT *slot;
 746         OPTION *option;
 747         OPTIONENTRY *optionEntry;
 748
 749         for(fn = ppd->InstalledFonts; fn; fn = fn->next)
 750             TRACE("'%s'\n", fn->Name);
 751
 752         for(page = ppd->PageSizes; page; page = page->next) {
 753             TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
 754               page->FullName, page->WinPage, page->InvocationString);
 755             if(page->ImageableArea)
 756                 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
 757                       page->ImageableArea->llx, page->ImageableArea->lly,
 758                       page->ImageableArea->urx, page->ImageableArea->ury);
 759             if(page->PaperDimension)
 760                 TRACE("Dimension = %.2f x %.2f\n",
 761                       page->PaperDimension->x, page->PaperDimension->y);
 762         }
 763
 764         for(con = ppd->Constraints; con; con = con->next)
 765             TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
 766                   con->Value1, con->Feature2, con->Value2);
 767
 768         for(option = ppd->InstalledOptions; option; option = option->next) {
 769             TRACE("OPTION: %s %s %s\n", option->OptionName,
 770                   option->FullName, option->DefaultOption);
 771             for(optionEntry = option->Options; optionEntry;
 772                 optionEntry = optionEntry->next)
 773                 TRACE("\tOPTIONENTRY: %s %s %s\n", optionEntry->Name,
 774                       optionEntry->FullName, optionEntry->InvocationString);
 775         }
 776
 777         for(slot = ppd->InputSlots; slot; slot = slot->next)
 778             TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
 779                   slot->Name, slot->FullName, slot->WinBin,
 780                   slot->InvocationString);
 781     }
 782
 783     return ppd;
 784 }
 785