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