summaryrefslogtreecommitdiff
path: root/dviware/catdvi/readdvi.c
blob: 0e47f22565ea6babcff5447a0a1361fce2e591c4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
/* catdvi - get text from DVI files
   Copyright (C) 1999 J.H.M. Dassen (Ray) <jdassen@wi.LeidenUniv.nl>
   Copyright (C) 1999 Antti-Juhani Kaijanaho <gaia@iki.fi>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/*
 * For a thorough description of the DVI file format, see the dvitype literate
 * program as distributed e.g. with teTeX and
 * "The DVI Driver Standard, Level 0" available from your neighbourhood CTAN
 * site.
 */

#include <assert.h>
#include <ctype.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#include "fntenc.h"
#include "fontinfo.h"
#include "outenc.h"
#include "page.h"
#include "readdvi.h"
#include "regsta.h"
#include "util.h"

uint32 magnification = 1000;

#define COMMENT_MAXLEN 16384


#define DVI_set_char_0		  0
#define DVI_set_char_127	127
#define DVI_set1		128
#define DVI_set2		129
#define DVI_set3		130
#define DVI_set4		131
#define DVI_set_rule		132
#define DVI_put1		133
#define DVI_put2		134
#define DVI_put3		135
#define DVI_put4		136
#define DVI_put_rule		137
#define DVI_nop			138
#define DVI_bop			139
#define DVI_eop			140
#define DVI_push		141
#define DVI_pop			142
#define DVI_right1		143
#define DVI_right2		144
#define DVI_right3		145
#define DVI_right4		146
#define DVI_w0			147
#define DVI_w1			148
#define DVI_w2			149
#define DVI_w3			150
#define DVI_w4			151
#define DVI_x0			152
#define DVI_x1			153
#define DVI_x2			154
#define DVI_x3			155
#define DVI_x4			156
#define DVI_down1		157
#define DVI_down2		158
#define DVI_down3		159
#define DVI_down4		160
#define DVI_y0			161
#define DVI_y1			162
#define DVI_y2			163
#define DVI_y3			164
#define DVI_y4			165
#define DVI_z0			166
#define DVI_z1			167
#define DVI_z2			168
#define DVI_z3			169
#define DVI_z4			170
#define DVI_fnt_num_0		171
#define DVI_fnt_num_1		172
#define DVI_fnt_num_63		234
#define DVI_fnt1		235
#define DVI_fnt2		236
#define DVI_fnt3		237
#define DVI_fnt4		238
#define DVI_xxx1		239
#define DVI_xxx2		240
#define DVI_xxx3		241
#define DVI_xxx4		242
#define DVI_fnt_def1		243
#define DVI_fnt_def2		244
#define DVI_fnt_def3		245
#define DVI_fnt_def4		246
#define DVI_pre			247
#define DVI_post		248
#define DVI_post_post		249


static double conversion = 1; /* conversion factor DVI units --> 10^-7 m */

static void output_glyph(sint32 font, sint32 glyph)
{
        static sint32 currfont = -1;
        static int currfenc = -1;
	static fix_word_t last_axis_height = double2fw(0.25);
	static sint32 curr_math_axis;

        if (font != currfont) {
	    fix_word_t new_axis_height;
	    
            currfont = font;
            currfenc = find_fntenc(font_enc(font), font_family(font));
	    new_axis_height = font_axis_height(font);

	    if(new_axis_height > 0) {
		/* This font really has axis_height defined */
		last_axis_height = new_axis_height;
		curr_math_axis = font_scale_fw(font, new_axis_height);
	    }
	    else {
		/* Since the axis height is usually about constant in a
		 * whole family of fonts, we have a good chance that
		 * scaling up the last known one to the current font
		 * size works. But we make the value negative to mark
		 * it as bogus.
		 */
		curr_math_axis = - font_scale_fw(font, last_axis_height);
    	    }
        }

        dump_regs(86);
        pmesg(85, "OUTPUT_GLYPH: font %li, glyph %li, H %li, V %li\n",
              font, glyph, get_reg(REGISTER_H), get_reg(REGISTER_V));

        page_set_glyph(font, fnt_convert(currfenc, glyph),
                       font_char_width(currfont, glyph),
                       font_char_height(currfont, glyph),
                       font_char_depth(currfont, glyph),
		       curr_math_axis,
                       get_reg(REGISTER_H), get_reg(REGISTER_V));
}

void process_file(FILE *f) {
        byte b;
        sint32 sc;
        uint32 num, den, c;
        sint32 currfont = 0;
        char comment[COMMENT_MAXLEN+1];

        /* Process the preamble */
        efread(&b, 1, 1, f, "Could not read initial byte\n");
        if (b != DVI_pre)
                panic("Does not start with preamble\n");
        pmesg(100, "Read preamble byte\n");

        efread(&b, 1, 1, f, "Could not read second byte\n");
        if (b != 2)
                panic("Identification byte wrong\n");
        pmesg(100, "Read identification byte\n");

        num = u_readbigendiannumber(4, f);
        pmesg(80, "Read numerator: %li\n", num);

        den = u_readbigendiannumber(4, f);
        pmesg(80, "Read denominator: %li\n", den);

        conversion = ((double) num) / ((double) den);

        magnification = s_readbigendiannumber(4, f);
        pmesg(80, "Read magnification: %li\n", magnification);

        efread(&b, 1, 1, f, "Could not read comment length\n");
        pmesg(100, "Read comment length: %i\n", b);
        efread(comment, 1, b, f, "Could not read comment\n");
        comment[b+1] = '\0';
        pmesg(80, "Read comment: `%s'\n", comment);

        /* Core processing loop: read an opcode byte, and process its
         * arguments (if any) */
        while(1) {
                efread(&b, 1, 1, f, "Failed to read opcode byte\n");

                if (b == DVI_post)
                       break;

                if ((b >= DVI_set_char_0) && (b <= DVI_set_char_127)) {
                        c = b;
                        pmesg(80, "[set char %i: %c]\n", b-DVI_set_char_0, (unsigned char) (b-DVI_set_char_0));
                        output_glyph(currfont, b-DVI_set_char_0);
                        add_reg(REGISTER_H, font_char_width(currfont, b-DVI_set_char_0));
                        continue;
                }

                if ((b >= DVI_set1) && (b <= DVI_set3)) {
                        sc = u_readbigendiannumber(b-DVI_set1+1, f);
                        output_glyph(currfont, sc);
                        add_reg(REGISTER_H, font_char_width(currfont, sc));
                        pmesg(80, "[set char%i: %lX]\n", b-DVI_set1+1, c);
                        continue;
                }

                if (b == DVI_set4) {
                        sc = u_readbigendiannumber(b-DVI_set1+1, f);
                        output_glyph(currfont, sc);
                        add_reg(REGISTER_H, font_char_width(currfont, sc));
                        pmesg(80, "[set char%i: %lX]\n", b-DVI_set1+1, sc);
                        continue;
                }

                if (b == DVI_set_rule) {
	    	    	sint32 rule_width, rule_height;
		    	rule_height = s_readbigendiannumber(4, f);
		    	rule_width = s_readbigendiannumber(4, f);
			add_reg(REGISTER_H, rule_width);
                        pmesg(
			    	80,
			    	"[setrule: height=%li, width=%li]\n",
			    	rule_height,
			    	rule_width
			);
                        continue;
                }

                if ((b >= DVI_put1) && (b <= DVI_put4)) {
                        c = u_readbigendiannumber(b-DVI_put1+1, f);
                        pmesg(80, "[put char%i: %lX]\n", b-DVI_put1+1, c);
                        continue;
                }

                if (b == DVI_put_rule) {
	    	    	sint32 rule_width, rule_height;
		    	rule_height = s_readbigendiannumber(4, f);
		    	rule_width = s_readbigendiannumber(4, f);
                        pmesg(
			    	80,
			    	"[putrule: height=%li, width=%li]\n",
			    	rule_height,
			    	rule_width
			);
                        continue;
                }

                if (b == DVI_nop) {
                        pmesg(80, "[nop]\n");
                        continue;
                }

                if (b == DVI_bop) {
		    	sint32 count0;

			count0 = s_readbigendiannumber(4, f);
                        skipbytes(9*4+4, f);
                        pmesg(80, "[bop]\n");
                        init_regs_stack(100);
                        page_begin(count0);
                        continue;
                }

                if (b == DVI_eop) {
                        pmesg(80, "[eop]\n");
                        page_end();
                        continue;
                }

                if (b == DVI_push) {
                        pmesg(80, "[push]\n");
                        push_regs();
                        continue;
                }

                if (b == DVI_pop) {
                        pmesg(80, "[pop]\n");
                        pop_regs();
                        continue;
                }

                if ((b >= DVI_right1) && (b <= DVI_right4)) {
                        sint32 qwerty;
                        qwerty = s_readbigendiannumber(b-DVI_right1+1, f);
                        pmesg(80, "[right%i: %li]\n", b-DVI_right1+1, qwerty);
                        add_reg(REGISTER_H, qwerty);
                        continue;
                }

                if (b == DVI_w0) {
                        add_reg(REGISTER_H, get_reg(REGISTER_W));
                        pmesg(80, "[w0]\n");
                        continue;
                }

                if ((b >= DVI_w1) && (b <= DVI_w4)) {
                        set_reg(REGISTER_W,
                                s_readbigendiannumber(b-DVI_w1+1, f));
                        pmesg(80, "[w%i: w=%li]\n",
                              b-DVI_w1+1, get_reg(REGISTER_W));
                        add_reg(REGISTER_H, get_reg(REGISTER_W));
                        continue;
                }

                if (b == DVI_x0) {
                        pmesg(80, "[x0]\n");
                        add_reg(REGISTER_H, get_reg(REGISTER_X));
                        continue;
                }

                if ((b >= DVI_x1) && (b <= DVI_x4)) {
                        set_reg(REGISTER_X,
                                s_readbigendiannumber(b-DVI_x1+1, f));
                        pmesg(80, "[x%i: x=%li]\n",
                              b-DVI_x1+1, get_reg(REGISTER_X));
                        add_reg(REGISTER_H, get_reg(REGISTER_X));
                        continue;
                }

                if ((b >= DVI_down1) && (b <= DVI_down4)) {
                        sint32 qwerty;
                        qwerty = s_readbigendiannumber(b-DVI_down1+1, f);
                        pmesg(80, "[down%i, %li]\n", b-DVI_down1+1, qwerty);
                        add_reg(REGISTER_V, qwerty);
                        continue;
                }

                if (b == DVI_y0) {
                        pmesg(80, "[y0]\n");
                        add_reg(REGISTER_V, get_reg(REGISTER_Y));
                        continue;
                }

                if ((b >= DVI_y1) && (b <= DVI_y4)) {
                        set_reg(REGISTER_Y,
                                s_readbigendiannumber(b-DVI_y1+1, f));
                        pmesg(80, "[y%i: y=%li]\n",
                              b-DVI_y1+1, get_reg(REGISTER_Y));
                        add_reg(REGISTER_V, get_reg(REGISTER_Y));
                        continue;
                }

                if (b == DVI_z0) {
                        add_reg(REGISTER_V, get_reg(REGISTER_Z));                        
                        pmesg(80, "[z0]\n");
                        continue;
                }

                if ((b >= DVI_z1) && (b <= DVI_z4)) {
                        set_reg(REGISTER_Z,
                                s_readbigendiannumber(b-DVI_z1+1, f));
                        pmesg(80, "[z%i: z=%li]\n",
                              b-DVI_z1+1, get_reg(REGISTER_Z));
                        add_reg(REGISTER_V, get_reg(REGISTER_Z));
                        continue;
                }

                if ((b >= DVI_fnt_num_0) && (b <= DVI_fnt_num_63)) {
                        pmesg(80, "[fnt_num_%i]\n", b-DVI_fnt_num_0);
                        currfont = b-DVI_fnt_num_0;
                        continue;
                }

                if ((b >= DVI_fnt1) && (b <= DVI_fnt3)) {
                        pmesg(80, "[fnt%i]\n", b-DVI_fnt1+1);
                        currfont = u_readbigendiannumber(b-DVI_fnt1+1, f);
                        continue;
                }

                if (b == DVI_fnt4) {
                        pmesg(80, "[fnt4]\n");
                        currfont = s_readbigendiannumber(4, f);
                        continue;
                }

                if ((b >= DVI_xxx1) && (b <= DVI_xxx4)) {
                        pmesg(80, "[xxx%i]\n", b-DVI_xxx1+1);
                        c = u_readbigendiannumber(b-DVI_xxx1+1, f);
                        if (c > COMMENT_MAXLEN) {
                                panic("too long comment\n");
                        }
                        efread(comment, 1, c, f, "Could not read comment\n");
                        comment[c+1] = '\0';
                        pmesg(50, "[Comment: `%s']\n", comment);
#if 0
                        skipbytes(c, f);
#endif
                        continue;
                }

                if ((b >= DVI_fnt_def1) && (b <= DVI_fnt_def4)) {
                        sint32 k;
                        uint32 cs, s, d;
                        byte a, l;
                        char * n;

                        if (b == DVI_fnt_def4) {
                                k = s_readbigendiannumber(4, f);
                        } else {
                                k = u_readbigendiannumber(b-DVI_fnt_def1+1, f);
                        }
                        cs = u_readbigendiannumber(4, f);
                        s = u_readbigendiannumber(4, f);
                        d = u_readbigendiannumber(4, f);
                        a = u_readbigendiannumber(1, f);
                        l = u_readbigendiannumber(1, f);

                        n = malloc(a + l + 1);
                        if (n == 0) enomem();

                        efread(n, a + l, 1, f, "Failed to read font name");
                        n[a+l] = 0;

                        pmesg(80, "[fnt_def%i: %s]\n", b-DVI_fnt_def1+1, n);
                        font_def(k, cs, s, d, a, l, n);
                        free(n);
                        continue;
                }

                if (b == DVI_pre)
                        panic("Unexpected preamble start marker\n");

                if (b == DVI_post)
                        break;

                if (b == DVI_post_post)
                        panic("Unexpected postamble end marker\n");

                if (b > DVI_post_post)
                        panic("Unimplemented opcode %i\n", b);
        }

        /* FIXME: process postamble */
}