msi: Don't set the shortcut's working directory if it's NULL.
[wine] / 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 PAGESIZE *PSDRV_PPDGetPageSizeInfo(PPD *ppd, char *name)
471 {
472     PAGESIZE *page = ppd->PageSizes, *lastpage;
473
474     if(!page) {
475        page = ppd->PageSizes = HeapAlloc( PSDRV_Heap,
476                                             HEAP_ZERO_MEMORY, sizeof(*page) );
477        return page;
478     } else {
479         for( ; page; page = page->next) {
480             if(!strcmp(page->Name, name))
481                  return page;
482             lastpage = page;
483         }
484
485         lastpage->next = HeapAlloc( PSDRV_Heap,
486                                            HEAP_ZERO_MEMORY, sizeof(*page) );
487         return lastpage->next;
488     }
489 }
490
491 /**********************************************************************
492  *
493  *              PSDRV_PPDGetWord
494  *
495  * Returns ptr alloced from heap to first word in str. Strips leading spaces.
496  * Puts ptr to next word in next
497  */
498 static char *PSDRV_PPDGetWord(char *str, char **next)
499 {
500     char *start, *end, *ret;
501
502     start = str;
503     while(start && *start && isspace(*start))
504         start++;
505     if(!start || !*start) return FALSE;
506
507     end = start;
508     while(*end && !isspace(*end))
509         end++;
510
511     ret = HeapAlloc( PSDRV_Heap, 0, end - start + 1 );
512     memcpy(ret, start, end - start );
513     *(ret + (end - start)) = '\0';
514
515     while(*end && isspace(*end))
516         end++;
517     if(*end)
518         *next = end;
519     else
520         *next = NULL;
521
522     return ret;
523 }
524
525 /*******************************************************************************
526  *      PSDRV_AddSlot
527  *
528  */
529 static INT PSDRV_AddSlot(PPD *ppd, LPSTR szName, LPSTR szFullName,
530         LPSTR szInvocationString, WORD wWinBin)
531 {
532     INPUTSLOT   *slot, **insert = &ppd->InputSlots;
533
534     while (*insert)
535         insert = &((*insert)->next);
536
537     slot = *insert = HeapAlloc(PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(INPUTSLOT));
538     if (!slot) return 1;
539
540     slot->Name = szName;
541     slot->FullName = szFullName;
542     slot->InvocationString = szInvocationString;
543     slot->WinBin = wWinBin;
544
545     return 0;
546 }
547
548 /***********************************************************************
549  *
550  *              PSDRV_ParsePPD
551  *
552  *
553  */
554 PPD *PSDRV_ParsePPD(char *fname)
555 {
556     FILE *fp;
557     PPD *ppd;
558     PPDTuple tuple;
559     char *default_pagesize = NULL, *default_duplex = NULL;
560
561     TRACE("file '%s'\n", fname);
562
563     if((fp = fopen(fname, "r")) == NULL) {
564         WARN("Couldn't open ppd file '%s'\n", fname);
565         return NULL;
566     }
567
568     ppd = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY, sizeof(*ppd));
569     if(!ppd) {
570         ERR("Unable to allocate memory for ppd\n");
571         fclose(fp);
572         return NULL;
573     }
574
575     /*
576      *  The Windows PostScript drivers create the following "virtual bin" for
577      *  every PostScript printer
578      */
579     if (PSDRV_AddSlot(ppd, NULL, "Automatically Select", NULL,
580             DMBIN_FORMSOURCE))
581     {
582         HeapFree (PSDRV_Heap, 0, ppd);
583         fclose(fp);
584         return NULL;
585     }
586
587     while( PSDRV_PPDGetNextTuple(fp, &tuple)) {
588
589         if(!strcmp("*NickName", tuple.key)) {
590             ppd->NickName = tuple.value;
591             tuple.value = NULL;
592             TRACE("NickName = '%s'\n", ppd->NickName);
593         }
594
595         else if(!strcmp("*LanguageLevel", tuple.key)) {
596             sscanf(tuple.value, "%d", &(ppd->LanguageLevel));
597             TRACE("LanguageLevel = %d\n", ppd->LanguageLevel);
598         }
599
600         else if(!strcmp("*ColorDevice", tuple.key)) {
601             if(!strcasecmp(tuple.value, "true"))
602                 ppd->ColorDevice = TRUE;
603             TRACE("ColorDevice = %d\n", (int)ppd->ColorDevice);
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             PAGESIZE *page;
652             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
653
654             if(!page->Name) {
655                 int i;
656
657                 page->Name = tuple.option;
658                 tuple.option = NULL;
659
660                 for(i = 0; PageTrans[i].PSName; i++) {
661                     if(!strcmp(PageTrans[i].PSName, page->Name)) { /* case ? */
662                         page->WinPage = PageTrans[i].WinPage;
663                         break;
664                     }
665                 }
666                 if(!page->WinPage) {
667                     TRACE("Can't find Windows page type for '%s' - using %u\n",
668                           page->Name, UserPageType);
669                     page->WinPage = UserPageType++;
670                 }
671             }
672             if(!page->FullName) {
673                 if(tuple.opttrans) {
674                     page->FullName = tuple.opttrans;
675                     tuple.opttrans = NULL;
676                 } else
677                 {
678                     page->FullName = HeapAlloc( PSDRV_Heap, 0, strlen(page->Name)+1 );
679                     strcpy( page->FullName, page->Name );
680                 }
681             }
682             if(!page->InvocationString) {
683                 page->InvocationString = tuple.value;
684                 tuple.value = NULL;
685             }
686         }
687
688         else if(!strcmp("*DefaultPageSize", tuple.key)) {
689             if(default_pagesize) {
690                 WARN("Already set default pagesize\n");
691             } else {
692                 default_pagesize = tuple.value;
693                 tuple.value = NULL;
694            }
695         }
696
697         else if(!strcmp("*ImageableArea", tuple.key)) {
698             PAGESIZE *page;
699             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
700
701             if(!page->Name) {
702                 page->Name = tuple.option;
703                 tuple.option = NULL;
704             }
705             if(!page->FullName) {
706                 page->FullName = tuple.opttrans;
707                 tuple.opttrans = NULL;
708             }
709
710 #define PIA page->ImageableArea
711             if(!PIA) {
712                 PIA = HeapAlloc( PSDRV_Heap, 0, sizeof(*PIA) );
713                 push_lc_numeric("C");
714                 sscanf(tuple.value, "%f%f%f%f", &PIA->llx, &PIA->lly,
715                                                 &PIA->urx, &PIA->ury);
716                 pop_lc_numeric();
717             }
718 #undef PIA
719         }
720
721
722         else if(!strcmp("*PaperDimension", tuple.key)) {
723             PAGESIZE *page;
724             page = PSDRV_PPDGetPageSizeInfo(ppd, tuple.option);
725
726             if(!page->Name) {
727                 page->Name = tuple.option;
728                 tuple.option = NULL;
729             }
730             if(!page->FullName) {
731                 page->FullName = tuple.opttrans;
732                 tuple.opttrans = NULL;
733             }
734
735 #define PD page->PaperDimension
736             if(!PD) {
737                 PD = HeapAlloc( PSDRV_Heap, 0, sizeof(*PD) );
738                 push_lc_numeric("C");
739                 sscanf(tuple.value, "%f%f", &PD->x, &PD->y);
740                 pop_lc_numeric();
741             }
742 #undef PD
743         }
744
745         else if(!strcmp("*LandscapeOrientation", tuple.key)) {
746             if(!strcmp(tuple.value, "Plus90"))
747                 ppd->LandscapeOrientation = 90;
748             else if(!strcmp(tuple.value, "Minus90"))
749                 ppd->LandscapeOrientation = -90;
750
751             /* anything else, namely 'any', leaves value at 0 */
752
753             TRACE("LandscapeOrientation = %d\n",
754                   ppd->LandscapeOrientation);
755         }
756
757         else if(!strcmp("*UIConstraints", tuple.key)) {
758             char *start;
759             CONSTRAINT *con, **insert = &ppd->Constraints;
760
761             while(*insert)
762                 insert = &((*insert)->next);
763
764             con = *insert = HeapAlloc( PSDRV_Heap, HEAP_ZERO_MEMORY,
765                                        sizeof(*con) );
766
767             start = tuple.value;
768
769             con->Feature1 = PSDRV_PPDGetWord(start, &start);
770             con->Value1 = PSDRV_PPDGetWord(start, &start);
771             con->Feature2 = PSDRV_PPDGetWord(start, &start);
772             con->Value2 = PSDRV_PPDGetWord(start, &start);
773         }
774
775         else if (!strcmp("*InputSlot", tuple.key))
776         {
777
778             if (!tuple.opttrans)
779                 tuple.opttrans = tuple.option;
780
781             TRACE("Using Windows bin type %u for '%s'\n", UserBinType,
782                     tuple.option);
783
784             /* FIXME - should check for failure */
785             PSDRV_AddSlot(ppd, tuple.option, tuple.opttrans, tuple.value,
786                     UserBinType++);
787
788             tuple.option = tuple.opttrans = tuple.value = NULL;
789         }
790
791         /*
792          *  Windows treats "manual feed" as another paper source.  Most PPD
793          *  files, however, treat it as a separate option which is either on or
794          *  off.
795          */
796         else if (!strcmp("*ManualFeed", tuple.key) && tuple.option &&
797                 !strcmp ("True", tuple.option))
798         {
799             /* FIXME - should check for failure */
800             PSDRV_AddSlot(ppd, "Manual Feed", "Manual Feed", tuple.value, DMBIN_MANUAL);
801             tuple.value = NULL;
802         }
803
804         else if(!strcmp("*TTRasterizer", tuple.key)) {
805             if(!strcasecmp("None", tuple.value))
806                 ppd->TTRasterizer = RO_None;
807             else if(!strcasecmp("Accept68K", tuple.value))
808                 ppd->TTRasterizer = RO_Accept68K;
809             else if(!strcasecmp("Type42", tuple.value))
810                 ppd->TTRasterizer = RO_Type42;
811             else if(!strcasecmp("TrueImage", tuple.value))
812                 ppd->TTRasterizer = RO_TrueImage;
813             else {
814                 FIXME("Unknown option %s for *TTRasterizer\n",
815                       tuple.value);
816                 ppd->TTRasterizer = RO_None;
817             }
818             TRACE("*TTRasterizer = %d\n", ppd->TTRasterizer);
819         }
820
821         else if(!strcmp("*Duplex", tuple.key)) {
822             DUPLEX **duplex;
823             for(duplex = &ppd->Duplexes; *duplex; duplex = &(*duplex)->next)
824                 ;
825             *duplex = HeapAlloc(GetProcessHeap(), 0, sizeof(**duplex));
826             (*duplex)->Name = tuple.option;
827             (*duplex)->FullName = tuple.opttrans;
828             (*duplex)->InvocationString = tuple.value;
829             (*duplex)->next = NULL;
830             if(!strcasecmp("None", tuple.option) || !strcasecmp("False", tuple.option)
831                || !strcasecmp("Simplex", tuple.option))
832                 (*duplex)->WinDuplex = DMDUP_SIMPLEX;
833             else if(!strcasecmp("DuplexNoTumble", tuple.option))
834                 (*duplex)->WinDuplex = DMDUP_VERTICAL;
835             else if(!strcasecmp("DuplexTumble", tuple.option))
836                 (*duplex)->WinDuplex = DMDUP_HORIZONTAL;
837             else if(!strcasecmp("Notcapable", tuple.option))
838                 (*duplex)->WinDuplex = 0;
839             else {
840                 FIXME("Unknown option %s for *Duplex defaulting to simplex\n", tuple.option);
841                 (*duplex)->WinDuplex = DMDUP_SIMPLEX;
842             }
843             tuple.option = tuple.opttrans = tuple.value = NULL;
844         }
845
846         else if(!strcmp("*DefaultDuplex", tuple.key)) {
847             if(default_duplex) {
848                 WARN("Already set default duplex\n");
849             } else {
850                 default_duplex = tuple.value;
851                 tuple.value = NULL;
852            }
853         }
854
855         HeapFree(PSDRV_Heap, 0, tuple.key);
856         HeapFree(PSDRV_Heap, 0, tuple.option);
857         HeapFree(PSDRV_Heap, 0, tuple.value);
858         HeapFree(PSDRV_Heap, 0, tuple.opttrans);
859         HeapFree(PSDRV_Heap, 0, tuple.valtrans);
860
861     }
862
863
864     ppd->DefaultPageSize = NULL;
865     if(default_pagesize) {
866         PAGESIZE *page;
867         for(page = ppd->PageSizes; page; page = page->next) {
868             if(!strcmp(page->Name, default_pagesize)) {
869                 ppd->DefaultPageSize = page;
870                 TRACE("DefaultPageSize: %s\n", page->Name);
871                 break;
872             }
873         }
874         HeapFree(PSDRV_Heap, 0, default_pagesize);
875     }
876     if(!ppd->DefaultPageSize) {
877         ppd->DefaultPageSize = ppd->PageSizes;
878         TRACE("Setting DefaultPageSize to first in list\n");
879     }
880
881     ppd->DefaultDuplex = NULL;
882     if(default_duplex) {
883         DUPLEX *duplex;
884         for(duplex = ppd->Duplexes; duplex; duplex = duplex->next) {
885             if(!strcmp(duplex->Name, default_duplex)) {
886                 ppd->DefaultDuplex = duplex;
887                 TRACE("DefaultDuplex: %s\n", duplex->Name);
888                 break;
889             }
890         }
891         HeapFree(PSDRV_Heap, 0, default_duplex);
892     }
893     if(!ppd->DefaultDuplex) {
894         ppd->DefaultDuplex = ppd->Duplexes;
895         TRACE("Setting DefaultDuplex to first in list\n");
896     }
897
898
899     {
900         FONTNAME *fn;
901         PAGESIZE *page;
902         CONSTRAINT *con;
903         INPUTSLOT *slot;
904         OPTION *option;
905         OPTIONENTRY *optionEntry;
906
907         for(fn = ppd->InstalledFonts; fn; fn = fn->next)
908             TRACE("'%s'\n", fn->Name);
909
910         for(page = ppd->PageSizes; page; page = page->next) {
911             TRACE("'%s' aka '%s' (%d) invoked by '%s'\n", page->Name,
912               page->FullName, page->WinPage, page->InvocationString);
913             if(page->ImageableArea)
914                 TRACE("Area = %.2f,%.2f - %.2f, %.2f\n",
915                       page->ImageableArea->llx, page->ImageableArea->lly,
916                       page->ImageableArea->urx, page->ImageableArea->ury);
917             if(page->PaperDimension)
918                 TRACE("Dimension = %.2f x %.2f\n",
919                       page->PaperDimension->x, page->PaperDimension->y);
920         }
921
922         for(con = ppd->Constraints; con; con = con->next)
923             TRACE("CONSTRAINTS@ %s %s %s %s\n", con->Feature1,
924                   con->Value1, con->Feature2, con->Value2);
925
926         for(option = ppd->InstalledOptions; option; option = option->next) {
927             TRACE("OPTION: %s %s %s\n", option->OptionName,
928                   option->FullName, option->DefaultOption);
929             for(optionEntry = option->Options; optionEntry;
930                 optionEntry = optionEntry->next)
931                 TRACE("\tOPTIONENTRY: %s %s %s\n", optionEntry->Name,
932                       optionEntry->FullName, optionEntry->InvocationString);
933         }
934
935         for(slot = ppd->InputSlots; slot; slot = slot->next)
936             TRACE("INPUTSLOTS '%s' Name '%s' (%d) Invocation '%s'\n",
937                   slot->Name, slot->FullName, slot->WinBin,
938                   slot->InvocationString);
939     }
940
941     fclose(fp);
942     return ppd;
943 }