Commit | Line | Data |
---|---|---|
8c4ebc23 JH |
1 | // -*- C++ -*- |
2 | /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc. | |
3 | Written by James Clark (jjc@jclark.com) | |
4 | ||
5 | This file is part of groff. | |
6 | ||
7 | groff is free software; you can redistribute it and/or modify it under | |
8 | the terms of the GNU General Public License as published by the Free | |
9 | Software Foundation; either version 2, or (at your option) any later | |
10 | version. | |
11 | ||
12 | groff is distributed in the hope that it will be useful, but WITHOUT ANY | |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 | for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License along | |
18 | with groff; see the file COPYING. If not, write to the Free Software | |
19 | Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | ||
21 | #include "eqn.h" | |
22 | #include "pbox.h" | |
23 | ||
24 | const char *current_roman_font; | |
25 | ||
26 | char *gfont = 0; | |
27 | char *grfont = 0; | |
28 | char *gbfont = 0; | |
29 | int gsize = 0; | |
30 | ||
31 | int script_size_reduction = -1; // negative means reduce by a percentage | |
32 | ||
33 | int positive_space = -1; | |
34 | int negative_space = -1; | |
35 | ||
36 | int minimum_size = 5; | |
37 | ||
38 | int fat_offset = 4; | |
39 | int body_height = 85; | |
40 | int body_depth = 35; | |
41 | ||
42 | int over_hang = 0; | |
43 | int accent_width = 31; | |
44 | int delimiter_factor = 900; | |
45 | int delimiter_shortfall = 50; | |
46 | ||
47 | int null_delimiter_space = 12; | |
48 | int script_space = 5; | |
49 | int thin_space = 17; | |
50 | int medium_space = 22; | |
51 | int thick_space = 28; | |
52 | ||
53 | int num1 = 70; | |
54 | int num2 = 40; | |
55 | // we don't use num3, because we don't have \atop | |
56 | int denom1 = 70; | |
57 | int denom2 = 36; | |
58 | int axis_height = 26; // in 100ths of an em | |
59 | int sup1 = 42; | |
60 | int sup2 = 37; | |
61 | int sup3 = 28; | |
62 | int default_rule_thickness = 4; | |
63 | int sub1 = 20; | |
64 | int sub2 = 23; | |
65 | int sup_drop = 38; | |
66 | int sub_drop = 5; | |
67 | int x_height = 45; | |
68 | int big_op_spacing1 = 11; | |
69 | int big_op_spacing2 = 17; | |
70 | int big_op_spacing3 = 20; | |
71 | int big_op_spacing4 = 60; | |
72 | int big_op_spacing5 = 10; | |
73 | ||
74 | // These are for piles and matrices. | |
75 | ||
76 | int baseline_sep = 140; // = num1 + denom1 | |
77 | int shift_down = 26; // = axis_height | |
78 | int column_sep = 100; // = em space | |
79 | int matrix_side_sep = 17; // = thin space | |
80 | ||
81 | int nroff = 0; // should we grok ndefine or tdefine? | |
82 | ||
83 | struct { | |
84 | const char *name; | |
85 | int *ptr; | |
86 | } param_table[] = { | |
87 | "fat_offset", &fat_offset, | |
88 | "over_hang", &over_hang, | |
89 | "accent_width", &accent_width, | |
90 | "delimiter_factor", &delimiter_factor, | |
91 | "delimiter_shortfall", &delimiter_shortfall, | |
92 | "null_delimiter_space", &null_delimiter_space, | |
93 | "script_space", &script_space, | |
94 | "thin_space", &thin_space, | |
95 | "medium_space", &medium_space, | |
96 | "thick_space", &thick_space, | |
97 | "num1", &num1, | |
98 | "num2", &num2, | |
99 | "denom1", &denom1, | |
100 | "denom2", &denom2, | |
101 | "axis_height", &axis_height, | |
102 | "sup1", ¹, | |
103 | "sup2", ², | |
104 | "sup3", ³, | |
105 | "default_rule_thickness", &default_rule_thickness, | |
106 | "sub1", &sub1, | |
107 | "sub2", &sub2, | |
108 | "sup_drop", &sup_drop, | |
109 | "sub_drop", &sub_drop, | |
110 | "x_height", &x_height, | |
111 | "big_op_spacing1", &big_op_spacing1, | |
112 | "big_op_spacing2", &big_op_spacing2, | |
113 | "big_op_spacing3", &big_op_spacing3, | |
114 | "big_op_spacing4", &big_op_spacing4, | |
115 | "big_op_spacing5", &big_op_spacing5, | |
116 | "minimum_size", &minimum_size, | |
117 | "baseline_sep", &baseline_sep, | |
118 | "shift_down", &shift_down, | |
119 | "column_sep", &column_sep, | |
120 | "matrix_side_sep", &matrix_side_sep, | |
121 | "draw_lines", &draw_flag, | |
122 | "body_height", &body_height, | |
123 | "body_depth", &body_depth, | |
124 | "nroff", &nroff, | |
125 | 0, 0 | |
126 | }; | |
127 | ||
128 | void set_param(const char *name, int value) | |
129 | { | |
130 | for (int i = 0; param_table[i].name != 0; i++) | |
131 | if (strcmp(param_table[i].name, name) == 0) { | |
132 | *param_table[i].ptr = value; | |
133 | return; | |
134 | } | |
135 | error("unrecognised parameter `%1'", name); | |
136 | } | |
137 | ||
138 | int script_style(int style) | |
139 | { | |
140 | return style > SCRIPT_STYLE ? style - 2 : style; | |
141 | } | |
142 | ||
143 | int cramped_style(int style) | |
144 | { | |
145 | return (style & 1) ? style - 1 : style; | |
146 | } | |
147 | ||
148 | void set_space(int n) | |
149 | { | |
150 | if (n < 0) | |
151 | negative_space = -n; | |
152 | else | |
153 | positive_space = n; | |
154 | } | |
155 | ||
156 | // Return 0 if the specified size is bad. | |
157 | // The caller is responsible for giving the error message. | |
158 | ||
159 | int set_gsize(const char *s) | |
160 | { | |
161 | const char *p = (*s == '+' || *s == '-') ? s + 1 : s; | |
162 | char *end; | |
163 | long n = strtol(p, &end, 10); | |
164 | if (n <= 0 || *end != '\0' || n > INT_MAX) | |
165 | return 0; | |
166 | if (p > s) { | |
167 | if (!gsize) | |
168 | gsize = 10; | |
169 | if (*s == '+') { | |
170 | if (gsize > INT_MAX - n) | |
171 | return 0; | |
172 | gsize += int(n); | |
173 | } | |
174 | else { | |
175 | if (gsize - n <= 0) | |
176 | return 0; | |
177 | gsize -= int(n); | |
178 | } | |
179 | } | |
180 | else | |
181 | gsize = int(n); | |
182 | return 1; | |
183 | } | |
184 | ||
185 | void set_script_reduction(int n) | |
186 | { | |
187 | script_size_reduction = n; | |
188 | } | |
189 | ||
190 | const char *get_gfont() | |
191 | { | |
192 | return gfont ? gfont : "I"; | |
193 | } | |
194 | ||
195 | const char *get_grfont() | |
196 | { | |
197 | return grfont ? grfont : "R"; | |
198 | } | |
199 | ||
200 | const char *get_gbfont() | |
201 | { | |
202 | return gbfont ? gbfont : "B"; | |
203 | } | |
204 | ||
205 | void set_gfont(const char *s) | |
206 | { | |
207 | a_delete gfont; | |
208 | gfont = strsave(s); | |
209 | } | |
210 | ||
211 | void set_grfont(const char *s) | |
212 | { | |
213 | a_delete grfont; | |
214 | grfont = strsave(s); | |
215 | } | |
216 | ||
217 | void set_gbfont(const char *s) | |
218 | { | |
219 | a_delete gbfont; | |
220 | gbfont = strsave(s); | |
221 | } | |
222 | ||
223 | // this must be precisely 2 characters in length | |
224 | #define COMPATIBLE_REG "0C" | |
225 | ||
226 | void start_string() | |
227 | { | |
228 | printf(".nr " COMPATIBLE_REG " \\n(.C\n"); | |
229 | printf(".cp 0\n"); | |
230 | printf(".ds " LINE_STRING "\n"); | |
231 | } | |
232 | ||
233 | void output_string() | |
234 | { | |
235 | printf("\\*[" LINE_STRING "]\n"); | |
236 | } | |
237 | ||
238 | void restore_compatibility() | |
239 | { | |
240 | printf(".cp \\n(" COMPATIBLE_REG "\n"); | |
241 | } | |
242 | ||
243 | void do_text(const char *s) | |
244 | { | |
245 | printf(".eo\n"); | |
246 | printf(".as " LINE_STRING " \"%s\n", s); | |
247 | printf(".ec\n"); | |
248 | } | |
249 | ||
250 | void set_minimum_size(int n) | |
251 | { | |
252 | minimum_size = n; | |
253 | } | |
254 | ||
255 | void set_script_size() | |
256 | { | |
257 | if (minimum_size < 0) | |
258 | minimum_size = 0; | |
259 | if (script_size_reduction >= 0) | |
260 | printf(".ps \\n[.s]-%d>?%d\n", script_size_reduction, minimum_size); | |
261 | else | |
262 | printf(".ps (u;\\n[.s]*7+5/10>?%d)*1z\n", minimum_size); | |
263 | } | |
264 | ||
265 | int box::next_uid = 0; | |
266 | ||
267 | box::box() : uid(next_uid++), spacing_type(ORDINARY_TYPE) | |
268 | { | |
269 | } | |
270 | ||
271 | box::~box() | |
272 | { | |
273 | } | |
274 | ||
275 | void box::top_level() | |
276 | { | |
277 | // debug_print(); | |
278 | // putc('\n', stderr); | |
279 | box *b = this; | |
280 | printf(".nr " SAVED_FONT_REG " \\n[.f]\n"); | |
281 | printf(".ft\n"); | |
282 | printf(".nr " SAVED_PREV_FONT_REG " \\n[.f]\n"); | |
283 | printf(".ft %s\n", get_gfont()); | |
284 | printf(".nr " SAVED_SIZE_REG " \\n[.s]z\n"); | |
285 | if (gsize > 0) { | |
286 | char buf[INT_DIGITS + 1]; | |
287 | sprintf(buf, "%d", gsize); | |
288 | b = new size_box(strsave(buf), b); | |
289 | } | |
290 | current_roman_font = get_grfont(); | |
291 | // This catches tabs used within \Z (which aren't allowed). | |
292 | b->check_tabs(0); | |
293 | int r = b->compute_metrics(DISPLAY_STYLE); | |
294 | printf(".ft \\n[" SAVED_PREV_FONT_REG "]\n"); | |
295 | printf(".ft \\n[" SAVED_FONT_REG "]\n"); | |
296 | printf(".nr " MARK_OR_LINEUP_FLAG_REG " %d\n", r); | |
297 | if (r == FOUND_MARK) { | |
298 | printf(".nr " SAVED_MARK_REG " \\n[" MARK_REG "]\n"); | |
299 | printf(".nr " MARK_WIDTH_REG " 0\\n[" WIDTH_FORMAT "]\n", b->uid); | |
300 | } | |
301 | else if (r == FOUND_LINEUP) | |
302 | printf(".if r" SAVED_MARK_REG " .as " LINE_STRING " \\h'\\n[" | |
303 | SAVED_MARK_REG "]u-\\n[" MARK_REG "]u'\n"); | |
304 | else | |
305 | assert(r == FOUND_NOTHING); | |
306 | // The problem here is that the argument to \f is read in copy mode, | |
307 | // so we cannot use \E there; so we hide it in a string instead. | |
308 | // Another problem is that if we use \R directly, then the space will | |
309 | // prevent it working in a macro argument. | |
310 | printf(".ds " SAVE_FONT_STRING " " | |
311 | "\\R'" SAVED_INLINE_FONT_REG " \\\\n[.f]'" | |
312 | "\\fP" | |
313 | "\\R'" SAVED_INLINE_PREV_FONT_REG " \\\\n[.f]'" | |
314 | "\\R'" SAVED_INLINE_SIZE_REG " \\\\n[.s]z'" | |
315 | "\\s0" | |
316 | "\\R'" SAVED_INLINE_PREV_SIZE_REG " \\\\n[.s]z'" | |
317 | "\n" | |
318 | ".ds " RESTORE_FONT_STRING " " | |
319 | "\\f[\\\\n[" SAVED_INLINE_PREV_FONT_REG "]]" | |
320 | "\\f[\\\\n[" SAVED_INLINE_FONT_REG "]]" | |
321 | "\\s'\\\\n[" SAVED_INLINE_PREV_SIZE_REG "]u'" | |
322 | "\\s'\\\\n[" SAVED_INLINE_SIZE_REG "]u'" | |
323 | "\n"); | |
324 | printf(".as " LINE_STRING " \\&\\E*[" SAVE_FONT_STRING "]"); | |
325 | printf("\\f[%s]", get_gfont()); | |
326 | printf("\\s'\\En[" SAVED_SIZE_REG "]u'"); | |
327 | current_roman_font = get_grfont(); | |
328 | b->output(); | |
329 | printf("\\E*[" RESTORE_FONT_STRING "]\n"); | |
330 | if (r == FOUND_LINEUP) | |
331 | printf(".if r" SAVED_MARK_REG " .as " LINE_STRING " \\h'\\n[" | |
332 | MARK_WIDTH_REG "]u-\\n[" SAVED_MARK_REG "]u-(\\n[" | |
333 | WIDTH_FORMAT "]u-\\n[" MARK_REG "]u)'\n", | |
334 | b->uid); | |
335 | b->extra_space(); | |
336 | if (!inline_flag) | |
337 | printf(".ne \\n[" HEIGHT_FORMAT "]u-%dM>?0+(\\n[" | |
338 | DEPTH_FORMAT "]u-%dM>?0)\n", | |
339 | b->uid, body_height, b->uid, body_depth); | |
340 | delete b; | |
341 | next_uid = 0; | |
342 | } | |
343 | ||
344 | // gpic defines this register so as to make geqn not produce `\x's | |
345 | #define EQN_NO_EXTRA_SPACE_REG "0x" | |
346 | ||
347 | void box::extra_space() | |
348 | { | |
349 | printf(".if !r" EQN_NO_EXTRA_SPACE_REG " " | |
350 | ".nr " EQN_NO_EXTRA_SPACE_REG " 0\n"); | |
351 | if (positive_space >= 0 || negative_space >= 0) { | |
352 | if (positive_space > 0) | |
353 | printf(".if !\\n[" EQN_NO_EXTRA_SPACE_REG "] " | |
354 | ".as " LINE_STRING " \\x'-%dM'\n", positive_space); | |
355 | if (negative_space > 0) | |
356 | printf(".if !\\n[" EQN_NO_EXTRA_SPACE_REG "] " | |
357 | ".as " LINE_STRING " \\x'%dM'\n", negative_space); | |
358 | positive_space = negative_space = -1; | |
359 | } | |
360 | else { | |
361 | printf(".if !\\n[" EQN_NO_EXTRA_SPACE_REG "] " | |
362 | ".if \\n[" HEIGHT_FORMAT "]>%dM .as " LINE_STRING | |
363 | " \\x'-(\\n[" HEIGHT_FORMAT | |
364 | "]u-%dM)'\n", | |
365 | uid, body_height, uid, body_height); | |
366 | printf(".if !\\n[" EQN_NO_EXTRA_SPACE_REG "] " | |
367 | ".if \\n[" DEPTH_FORMAT "]>%dM .as " LINE_STRING | |
368 | " \\x'\\n[" DEPTH_FORMAT | |
369 | "]u-%dM'\n", | |
370 | uid, body_depth, uid, body_depth); | |
371 | } | |
372 | } | |
373 | ||
374 | int box::compute_metrics(int) | |
375 | { | |
376 | printf(".nr " WIDTH_FORMAT " 0\n", uid); | |
377 | printf(".nr " HEIGHT_FORMAT " 0\n", uid); | |
378 | printf(".nr " DEPTH_FORMAT " 0\n", uid); | |
379 | return FOUND_NOTHING; | |
380 | } | |
381 | ||
382 | void box::compute_subscript_kern() | |
383 | { | |
384 | printf(".nr " SUB_KERN_FORMAT " 0\n", uid); | |
385 | } | |
386 | ||
387 | void box::compute_skew() | |
388 | { | |
389 | printf(".nr " SKEW_FORMAT " 0\n", uid); | |
390 | } | |
391 | ||
392 | void box::output() | |
393 | { | |
394 | } | |
395 | ||
396 | void box::check_tabs(int) | |
397 | { | |
398 | } | |
399 | ||
400 | int box::is_char() | |
401 | { | |
402 | return 0; | |
403 | } | |
404 | ||
405 | int box::left_is_italic() | |
406 | { | |
407 | return 0; | |
408 | } | |
409 | ||
410 | int box::right_is_italic() | |
411 | { | |
412 | return 0; | |
413 | } | |
414 | ||
415 | void box::hint(unsigned) | |
416 | { | |
417 | } | |
418 | ||
419 | void box::handle_char_type(int, int) | |
420 | { | |
421 | } | |
422 | ||
423 | ||
424 | box_list::box_list(box *pp) | |
425 | { | |
426 | p = new box*[10]; | |
427 | for (int i = 0; i < 10; i++) | |
428 | p[i] = 0; | |
429 | maxlen = 10; | |
430 | len = 1; | |
431 | p[0] = pp; | |
432 | } | |
433 | ||
434 | void box_list::append(box *pp) | |
435 | { | |
436 | if (len + 1 > maxlen) { | |
437 | box **oldp = p; | |
438 | maxlen *= 2; | |
439 | p = new box*[maxlen]; | |
440 | memcpy(p, oldp, sizeof(box*)*len); | |
441 | a_delete oldp; | |
442 | } | |
443 | p[len++] = pp; | |
444 | } | |
445 | ||
446 | box_list::~box_list() | |
447 | { | |
448 | for (int i = 0; i < len; i++) | |
449 | delete p[i]; | |
450 | a_delete p; | |
451 | } | |
452 | ||
453 | void box_list::list_check_tabs(int level) | |
454 | { | |
455 | for (int i = 0; i < len; i++) | |
456 | p[i]->check_tabs(level); | |
457 | } | |
458 | ||
459 | ||
460 | pointer_box::pointer_box(box *pp) : p(pp) | |
461 | { | |
462 | spacing_type = p->spacing_type; | |
463 | } | |
464 | ||
465 | pointer_box::~pointer_box() | |
466 | { | |
467 | delete p; | |
468 | } | |
469 | ||
470 | int pointer_box::compute_metrics(int style) | |
471 | { | |
472 | int r = p->compute_metrics(style); | |
473 | printf(".nr " WIDTH_FORMAT " 0\\n[" WIDTH_FORMAT "]\n", uid, p->uid); | |
474 | printf(".nr " HEIGHT_FORMAT " \\n[" HEIGHT_FORMAT "]\n", uid, p->uid); | |
475 | printf(".nr " DEPTH_FORMAT " \\n[" DEPTH_FORMAT "]\n", uid, p->uid); | |
476 | return r; | |
477 | } | |
478 | ||
479 | void pointer_box::compute_subscript_kern() | |
480 | { | |
481 | p->compute_subscript_kern(); | |
482 | printf(".nr " SUB_KERN_FORMAT " \\n[" SUB_KERN_FORMAT "]\n", uid, p->uid); | |
483 | } | |
484 | ||
485 | void pointer_box::compute_skew() | |
486 | { | |
487 | p->compute_skew(); | |
488 | printf(".nr " SKEW_FORMAT " 0\\n[" SKEW_FORMAT "]\n", | |
489 | uid, p->uid); | |
490 | } | |
491 | ||
492 | void pointer_box::check_tabs(int level) | |
493 | { | |
494 | p->check_tabs(level); | |
495 | } | |
496 | ||
497 | int simple_box::compute_metrics(int) | |
498 | { | |
499 | printf(".nr " WIDTH_FORMAT " 0\\w" DELIMITER_CHAR, uid); | |
500 | output(); | |
501 | printf(DELIMITER_CHAR "\n"); | |
502 | printf(".nr " HEIGHT_FORMAT " 0>?\\n[rst]\n", uid); | |
503 | printf(".nr " DEPTH_FORMAT " 0-\\n[rsb]>?0\n", uid); | |
504 | printf(".nr " SUB_KERN_FORMAT " 0-\\n[ssc]>?0\n", uid); | |
505 | printf(".nr " SKEW_FORMAT " 0\\n[skw]\n", uid); | |
506 | return FOUND_NOTHING; | |
507 | } | |
508 | ||
509 | void simple_box::compute_subscript_kern() | |
510 | { | |
511 | // do nothing, we already computed it in do_metrics | |
512 | } | |
513 | ||
514 | void simple_box::compute_skew() | |
515 | { | |
516 | // do nothing, we already computed it in do_metrics | |
517 | } | |
518 | ||
519 | int box::is_simple() | |
520 | { | |
521 | return 0; | |
522 | } | |
523 | ||
524 | int simple_box::is_simple() | |
525 | { | |
526 | return 1; | |
527 | } | |
528 | ||
529 | quoted_text_box::quoted_text_box(char *s) : text(s) | |
530 | { | |
531 | } | |
532 | ||
533 | quoted_text_box::~quoted_text_box() | |
534 | { | |
535 | a_delete text; | |
536 | } | |
537 | ||
538 | void quoted_text_box::output() | |
539 | { | |
540 | if (text) | |
541 | fputs(text, stdout); | |
542 | } | |
543 | ||
544 | tab_box::tab_box() : disabled(0) | |
545 | { | |
546 | } | |
547 | ||
548 | // We treat a tab_box as having width 0 for width computations. | |
549 | ||
550 | void tab_box::output() | |
551 | { | |
552 | if (!disabled) | |
553 | printf("\\t"); | |
554 | } | |
555 | ||
556 | void tab_box::check_tabs(int level) | |
557 | { | |
558 | if (level > 0) { | |
559 | error("tabs allowed only at outermost level"); | |
560 | disabled = 1; | |
561 | } | |
562 | } | |
563 | ||
564 | space_box::space_box() | |
565 | { | |
566 | spacing_type = SUPPRESS_TYPE; | |
567 | } | |
568 | ||
569 | void space_box::output() | |
570 | { | |
571 | printf("\\h'%dM'", thick_space); | |
572 | } | |
573 | ||
574 | half_space_box::half_space_box() | |
575 | { | |
576 | spacing_type = SUPPRESS_TYPE; | |
577 | } | |
578 | ||
579 | void half_space_box::output() | |
580 | { | |
581 | printf("\\h'%dM'", thin_space); | |
582 | } | |
583 | ||
584 | void box_list::list_debug_print(const char *sep) | |
585 | { | |
586 | p[0]->debug_print(); | |
587 | for (int i = 1; i < len; i++) { | |
588 | fprintf(stderr, "%s", sep); | |
589 | p[i]->debug_print(); | |
590 | } | |
591 | } | |
592 | ||
593 | void quoted_text_box::debug_print() | |
594 | { | |
595 | fprintf(stderr, "\"%s\"", (text ? text : "")); | |
596 | } | |
597 | ||
598 | void half_space_box::debug_print() | |
599 | { | |
600 | fprintf(stderr, "^"); | |
601 | } | |
602 | ||
603 | void space_box::debug_print() | |
604 | { | |
605 | fprintf(stderr, "~"); | |
606 | } | |
607 | ||
608 | void tab_box::debug_print() | |
609 | { | |
610 | fprintf(stderr, "<tab>"); | |
611 | } |