generate HAVE_ZLIB from HAVE_LIBZ and HAVE_ZLIB_H.
[swftools.git] / pdf2swf / ttf2pt1 / t1asm.c
1 /* t1asm
2  *
3  * This program `assembles' Adobe Type-1 font programs in pseudo-PostScript
4  * form into either PFB or PFA format.  The human readable/editable input is
5  * charstring- and eexec-encrypted as specified in the `Adobe Type 1 Font
6  * Format' version 1.1 (the `black book').  There is a companion program,
7  * t1disasm, which `disassembles' PFB and PFA files into a pseudo-PostScript
8  * file.
9  *
10  * Copyright (c) 1992 by I. Lee Hetherington, all rights reserved.
11  *
12  * Permission is hereby granted to use, modify, and distribute this program
13  * for any purpose provided this copyright notice and the one below remain
14  * intact.
15  *
16  * I. Lee Hetherington (ilh@lcs.mit.edu)
17  *
18  * Revision 1.2  92/05/22  11:54:45  ilh
19  * Fixed bug where integers larger than 32000 could not be encoded in
20  * charstrings.  Now integer range is correct for four-byte
21  * twos-complement integers: -(1<<31) <= i <= (1<<31)-1.  Bug detected by
22  * Piet Tutelaers (rcpt@urc.tue.nl).
23  *
24  * Revision 1.1  92/05/22  11:48:46  ilh
25  * initial version
26  *
27  * Ported to Microsoft C/C++ Compiler and MS-DOS operating system by
28  * Kai-Uwe Herbing (herbing@netmbx.netmbx.de) on June 12, 1992. Code
29  * specific to the MS-DOS version is encapsulated with #ifdef _MSDOS
30  * ... #endif, where _MSDOS is an identifier, which is automatically
31  * defined, if you compile with the Microsoft C/C++ Compiler.
32  *
33  */
34
35 #ifndef lint
36 static char copyright[] =
37   "@(#) Copyright (c) 1992 by I. Lee Hetherington, all rights reserved.";
38 #ifdef _MSDOS
39 static char portnotice[] =
40   "@(#) Ported to MS-DOS by Kai-Uwe Herbing (herbing@netmbx.netmbx.de).";
41 #endif
42 #endif
43
44 /* Note: this is ANSI C. */
45
46 #ifdef _MSDOS
47   #include <fcntl.h>
48   #include <getopt.h>
49   #include <io.h>
50 #endif
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <ctype.h>
55 #include <limits.h>
56
57 #ifdef WINDOWS
58 #       ifdef STANDALONE
59 #               define WINDOWS_FUNCTIONS
60 #               include "windows.h"
61 #       endif
62 #endif
63
64 /* int32 must be at least 32-bit and uint16 must be at least 16-bit */
65 #if INT_MAX >= 0x7FFFFFFFUL
66 typedef int int32;
67 #else
68 typedef long int32;
69 #endif
70 #if USHRT_MAX >= 0xFFFFUL
71 typedef unsigned short uint16;
72 #else
73 typedef unsigned int uint16;
74 #endif
75
76 #define LINESIZE 256
77
78 #define MAXBLOCKLEN ((1L<<17)-6)
79 #define MINBLOCKLEN ((1L<<8)-6)
80
81 #define MARKER   128
82 #define ASCII    1
83 #define BINARY   2
84 #define DONE     3
85
86 typedef unsigned char byte;
87
88 /* must be visible from outside */
89 FILE *ifp;
90 FILE *ofp;
91
92 /* flags */
93 static int pfb = 0;
94 static int active = 0;
95 static int start_charstring = 0;
96 static int in_eexec = 0;
97
98 static char line[LINESIZE];
99
100 /* lenIV and charstring start command */
101 static int lenIV = 4;
102 static char cs_start[10];
103
104 /* for charstring buffering */
105 static byte charstring_buf[65535];
106 static byte *charstring_bp;
107
108 /* for PFB block buffering */
109 static byte blockbuf[MAXBLOCKLEN];
110 static int32 blocklen = MAXBLOCKLEN;
111 static int32 blockpos = -1;
112 static int blocktyp = ASCII;
113
114 /* decryption stuff */
115 static uint16 er, cr;
116 static uint16 c1 = 52845, c2 = 22719;
117
118 /* table of charstring commands */
119 static struct command {
120   char *name;
121   int one, two;
122 } command_table[] = {
123   { "callothersubr", 12, 16 },
124   { "callsubr", 10, -1 },
125   { "closepath", 9, -1 },
126   { "div", 12, 12 },
127   { "dotsection", 12, 0 },
128   { "endchar", 14, -1 },
129   { "hlineto", 6, -1 },
130   { "hmoveto", 22, -1 },
131   { "hsbw", 13, -1 },
132   { "hstem", 1, -1 },
133   { "hstem3", 12, 2 },
134   { "hvcurveto", 31, -1 },
135   { "pop", 12, 17 },
136   { "return", 11, -1 },
137   { "rlineto", 5, -1 },
138   { "rmoveto", 21, -1 },
139   { "rrcurveto", 8, -1 },
140   { "sbw", 12, 7 },
141   { "seac", 12, 6 },
142   { "setcurrentpoint", 12, 33 },
143   { "vhcurveto", 30, -1 },
144   { "vlineto", 7, -1 },
145   { "vmoveto", 4, -1 },
146   { "vstem", 3, -1 },
147   { "vstem3", 12, 1 },
148 };                                                /* alphabetical */
149
150 /* Two separate encryption functions because eexec and charstring encryption
151    must proceed in parallel. */
152
153 static byte eencrypt(byte plain)
154 {
155   byte cipher;
156
157   cipher = (byte) (plain ^ (er >> 8));
158   er = (uint16) ((cipher + er) * c1 + c2);
159   return cipher;
160 }
161
162 static byte cencrypt(byte plain)
163 {
164   byte cipher;
165
166   cipher = (byte) (plain ^ (cr >> 8));
167   cr = (uint16) ((cipher + cr) * c1 + c2);
168   return cipher;
169 }
170
171 /* This function flushes a buffered PFB block. */
172
173 static void output_block()
174 {
175   int32 i;
176
177   /* output four-byte block length */
178   fputc((int) (blockpos & 0xff), ofp);
179   fputc((int) ((blockpos >> 8) & 0xff), ofp);
180   fputc((int) ((blockpos >> 16) & 0xff), ofp);
181   fputc((int) ((blockpos >> 24) & 0xff), ofp);
182
183   /* output block data */
184   for (i = 0; i < blockpos; i++)
185     fputc(blockbuf[i], ofp);
186
187   /* mark block buffer empty and uninitialized */
188   blockpos =  -1;
189 }
190
191 /* This function outputs a single byte.  If output is in PFB format then output
192    is buffered through blockbuf[].  If output is in PFA format, then output
193    will be hexadecimal if in_eexec is set, ASCII otherwise. */
194
195 static void output_byte(byte b)
196 {
197   static char *hexchar = "0123456789ABCDEF";
198   static int hexcol = 0;
199
200   if (pfb) {
201     /* PFB */
202     if (blockpos < 0) {
203       fputc(MARKER, ofp);
204       fputc(blocktyp, ofp);
205       blockpos = 0;
206     }
207     blockbuf[blockpos++] = b;
208     if (blockpos == blocklen)
209       output_block();
210   } else {
211     /* PFA */
212     if (in_eexec) {
213       /* trim hexadecimal lines to 64 columns */
214       if (hexcol >= 64) {
215         fputc('\n', ofp);
216         hexcol = 0;
217       }
218       fputc(hexchar[(b >> 4) & 0xf], ofp);
219       fputc(hexchar[b & 0xf], ofp);
220       hexcol += 2;
221     } else {
222       fputc(b, ofp);
223     }
224   }
225 }
226
227 /* This function outputs a byte through possible eexec encryption. */
228
229 static void eexec_byte(byte b)
230 {
231   if (in_eexec)
232     output_byte(eencrypt(b));
233   else
234     output_byte(b);
235 }
236
237 /* This function outputs a null-terminated string through possible eexec
238    encryption. */
239
240 static void eexec_string(char *string)
241 {
242   while (*string)
243     eexec_byte((byte) *string++);
244 }
245
246 /* This function gets ready for the eexec-encrypted data.  If output is in
247    PFB format then flush current ASCII block and get ready for binary block.
248    We start encryption with four random (zero) bytes. */
249
250 static void eexec_start()
251 {
252   eexec_string(line);
253   if (pfb) {
254     output_block();
255     blocktyp = BINARY;
256   }
257
258   in_eexec = 1;
259   er = 55665;
260   eexec_byte(0);
261   eexec_byte(0);
262   eexec_byte(0);
263   eexec_byte(0);
264 }
265
266 /* This function wraps-up the eexec-encrypted data.
267    If output is in PFB format then this entails flushing binary block and
268    starting an ASCII block. */
269
270 static void eexec_end()
271 {
272   int i, j;
273
274   if (pfb) {
275     output_block();
276     blocktyp = ASCII;
277   } else {
278     fputc('\n', ofp);
279   }
280   in_eexec = 0;
281   for (i = 0; i < 8; i++) {
282     for (j = 0; j < 64; j++)
283       eexec_byte('0');
284     eexec_byte('\n');
285   }
286 #if 0
287   eexec_string("cleartomark\n");
288 #endif
289 }
290
291 /* This function writes ASCII trailer.
292    If output is in PFB format then this entails flushing binary block and
293    starting an ASCII block. */
294
295 static void file_end()
296 {
297   if (pfb) {
298     output_block();
299     fputc(MARKER, ofp);
300     fputc(DONE, ofp);
301   }
302 }
303 /* This function returns an input line of characters.  A line is terminated by
304    length (including terminating null) greater than LINESIZE, a newline \n, or
305    when active (looking for charstrings) by '{'.  When terminated by a newline
306    the newline is put into line[].  When terminated by '{', the '{' is not put
307    into line[], and the flag start_charstring is set to 1. */
308
309 static void t1asm_getline()
310 {
311   int c;
312   char *p = line;
313   int comment = 0;
314
315   start_charstring = 0;
316   while (p < line + LINESIZE) {
317     c = fgetc(ifp);
318     if (c == EOF)
319       break;
320     if (c == '%')
321       comment = 1;
322     if (active && !comment && c == '{') {
323       start_charstring = 1;
324       break;
325     }
326     *p++ = (char) c;
327     if (c == '\n')
328       break;
329   }
330   *p = '\0';
331 }
332
333 /* This function is used by the binary search, bsearch(), for command names in
334    the command table. */
335
336 static int command_compare(const void *key, const void *item)
337 {
338   return strcmp((char *) key, ((struct command *) item)->name);
339 }
340
341 /* This function returns 1 if the string is an integer and 0 otherwise. */
342
343 static int is_integer(char *string)
344 {
345   if (isdigit(string[0]) || string[0] == '-' || string[0] == '+') {
346     while (*++string && isdigit(*string))
347       ;                                           /* deliberately empty */
348     if (!*string)
349       return 1;
350   }
351   return 0;
352 }
353
354 /* This function initializes charstring encryption.  Note that this is called
355    at the beginning of every charstring. */
356
357 static void charstring_start()
358 {
359   int i;
360
361   charstring_bp = charstring_buf;
362   cr = 4330;
363   for (i = 0; i < lenIV; i++)
364     *charstring_bp++ = cencrypt((byte) 0);
365 }
366
367 /* This function encrypts and buffers a single byte of charstring data. */
368
369 static void charstring_byte(int v)
370 {
371   byte b = (byte) (v & 0xff);
372
373   if (charstring_bp - charstring_buf > sizeof(charstring_buf)) {
374     fprintf(stderr, "error: charstring_buf full (%d bytes)\n",
375             sizeof(charstring_buf));
376     exit(1);
377   }
378   *charstring_bp++ = cencrypt(b);
379 }
380
381 /* This function outputs buffered, encrypted charstring data through possible
382    eexec encryption. */
383
384 static void charstring_end()
385 {
386   byte *bp;
387
388   sprintf(line, "%d ", charstring_bp - charstring_buf);
389   eexec_string(line);
390   sprintf(line, "%s ", cs_start);
391   eexec_string(line);
392   for (bp = charstring_buf; bp < charstring_bp; bp++)
393     eexec_byte(*bp);
394 }
395
396 /* This function generates the charstring representation of an integer. */
397
398 static void charstring_int(int num)
399 {
400   int x;
401
402   if (num >= -107 && num <= 107) {
403     charstring_byte(num + 139);
404   } else if (num >= 108 && num <= 1131) {
405     x = num - 108;
406     charstring_byte(x / 256 + 247);
407     charstring_byte(x % 256);
408   } else if (num >= -1131 && num <= -108) {
409     x = abs(num) - 108;
410     charstring_byte(x / 256 + 251);
411     charstring_byte(x % 256);
412   } else if (num >= (-2147483647-1) && num <= 2147483647) {
413     charstring_byte(255);
414     charstring_byte(num >> 24);
415     charstring_byte(num >> 16);
416     charstring_byte(num >> 8);
417     charstring_byte(num);
418   } else {
419     fprintf(stderr,
420             "error: cannot format the integer %d, too large\n", num);
421     exit(1);
422   }
423 }
424
425 /* This function parses an entire charstring into integers and commands,
426    outputting bytes through the charstring buffer. */
427
428 static void parse_charstring()
429 {
430   struct command *cp;
431
432   charstring_start();
433   while (fscanf(ifp, "%s", line) == 1) {
434     if (line[0] == '%') {
435       /* eat comment to end of line */
436       while (fgetc(ifp) != '\n' && !feof(ifp))
437         ;                                         /* deliberately empty */
438       continue;
439     }
440     if (line[0] == '}')
441       break;
442     if (is_integer(line)) {
443       charstring_int(atoi(line));
444     } else {
445       cp = (struct command *)
446         bsearch((void *) line, (void *) command_table,
447                 sizeof(command_table) / sizeof(struct command),
448                 sizeof(struct command),
449                 command_compare);
450       if (cp) {
451         charstring_byte(cp->one);
452         if (cp->two >= 0)
453           charstring_byte(cp->two);
454       } else {
455         fprintf(stderr, "error: cannot use `%s' in charstring\n",line);
456         exit(1);
457       }
458     }
459   }
460   charstring_end();
461 }
462
463 static void usage()
464 {
465   fprintf(stderr,
466           "usage: t1asm [-b] [-l block-length] [input [output]]\n");
467   fprintf(stderr,
468           "\n-b means output in PFB format, otherwise PFA format.\n");
469   fprintf(stderr,
470           "The block length applies to the length of blocks in the\n");
471   fprintf(stderr,
472           "PFB output file; the default is to use the largest possible.\n");
473   exit(1);
474 }
475
476 static void print_banner()
477 {
478   static char rcs_revision[] = ""; /* removed RCS */
479   static char revision[20];
480
481   if (sscanf(rcs_revision, "$Revision: %19s", revision) != 1)
482     revision[0] = '\0';
483   fprintf(stderr, "This is t1asm %s.\n", revision);
484 }
485
486 #ifdef STANDALONE
487 int main(int argc, char **argv)
488 {
489   char *p, *q, *r;
490   int c;
491
492   extern char *optarg;
493   extern int optind;
494
495   ifp = stdin;
496   ofp = stdout;
497
498   print_banner();
499
500   /* interpret command line arguments using getopt */
501   while ((c = getopt(argc, argv, "bl:")) != -1)
502     switch (c) {
503     case 'b':
504       pfb = 1;
505       break;
506     case 'l':
507       blocklen = atoi(optarg);
508       if (blocklen < MINBLOCKLEN) {
509         blocklen = MINBLOCKLEN;
510         fprintf(stderr,
511                 "warning: using minimum block length of %d\n",
512                 blocklen);
513       } else if (blocklen > MAXBLOCKLEN) {
514         blocklen = MAXBLOCKLEN;
515         fprintf(stderr,
516                 "warning: using maximum block length of %d\n",
517                 blocklen);
518       }
519       break;
520     default:
521       usage();
522       break;
523     }
524   if (argc - optind > 2)
525     usage();
526
527   /* possibly open input & output files */
528   if (argc - optind >= 1) {
529     ifp = fopen(argv[optind], "r");
530     if (!ifp) {
531       fprintf(stderr, "error: cannot open %s for reading\n", argv[1]);
532       exit(1);
533     }
534   }
535   if (argc - optind >= 2) {
536     ofp = fopen(argv[optind + 1], "w");
537     if (!ofp) {
538       fprintf(stderr, "error: cannot open %s for writing\n", argv[2]);
539       exit(1);
540     }
541   }
542
543 #else
544 int runt1asm(int pfbflag)
545 {
546   char *p, *q, *r;
547
548   pfb = pfbflag;
549 #endif
550
551   #ifdef _MSDOS
552     /* If we are processing a PFB (binary) output */
553     /* file, we must set its file mode to binary. */
554     if (pfb)
555       _setmode(_fileno(ofp), _O_BINARY);
556   #endif
557
558   /* Finally, we loop until no more input.  Some special things to look for
559      are the `currentfile eexec' line, the beginning of the `/Subrs'
560      definition, the definition of `/lenIV', and the definition of the
561      charstring start command which has `...string currentfile...' in it. */
562
563   while (!feof(ifp) && !ferror(ifp)) {
564     t1asm_getline();
565     if (strcmp(line, "currentfile eexec\n") == 0) {
566       eexec_start();
567       continue;
568     } else if (strstr(line, "/Subrs") && isspace(line[6])) {
569       active = 1;
570     } else if ((p = strstr(line, "/lenIV"))) {
571       sscanf(p, "%*s %d", &lenIV);
572     } else if ((p = strstr(line, "string currentfile"))) {
573       /* locate the name of the charstring start command */
574       *p = '\0';                                  /* damage line[] */
575       q = strrchr(line, '/');
576       if (q) {
577         r = cs_start;
578         ++q;
579         while (!isspace(*q) && *q != '{')
580           *r++ = *q++;
581         *r = '\0';
582       }
583       *p = 's';                                   /* repair line[] */
584     }
585     /* output line data */
586     eexec_string(line);
587         if ((p = strstr(line, "currentfile closefile"))) {
588                 eexec_end();
589         }
590     if (start_charstring) {
591       if (!cs_start[0]) {
592         fprintf(stderr, "error: couldn't find charstring start command\n");
593         exit(1);
594       }
595       parse_charstring();
596     }
597   }
598   file_end();
599
600   fclose(ifp);
601   fclose(ofp);
602
603   return 0;
604 }