?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Another try to update getopt files. This time we add a dummy
[s-roff.git] / src / roff / troff / input.cpp
blob15077e947fba73c16b03bf3a46128ecc19d7ea27
1 // -*- C++ -*-
2 /* Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Written by James Clark (jjc@jclark.com)
5
6 This file is part of groff.
7
8 groff is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 groff is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with groff; see the file COPYING. If not, write to the Free Software
20 Foundation, 51 Franklin St - Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 #define DEBUGGING
23
24 #include "troff.h"
25 #include "dictionary.h"
26 #include "hvunits.h"
27 #include "stringclass.h"
28 #include "mtsm.h"
29 #include "env.h"
30 #include "request.h"
31 #include "node.h"
32 #include "token.h"
33 #include "div.h"
34 #include "reg.h"
35 #include "charinfo.h"
36 #include "macropath.h"
37 #include "input.h"
38 #include "defs.h"
39 #include "font.h"
40 #include "unicode.h"
41
42 // Needed for getpid() and isatty()
43 #include "posix.h"
44
45 #include "nonposix.h"
46
47 #ifdef NEED_DECLARATION_PUTENV
48 extern "C" {
49 int putenv(const char *);
50 }
51 #endif /* NEED_DECLARATION_PUTENV */
52
53 #define MACRO_PREFIX "tmac."
54 #define MACRO_POSTFIX ".tmac"
55 #define INITIAL_STARTUP_FILE "troffrc"
56 #define FINAL_STARTUP_FILE "troffrc-end"
57 #define DEFAULT_INPUT_STACK_LIMIT 1000
58
59 #ifndef DEFAULT_WARNING_MASK
60 // warnings that are enabled by default
61 #define DEFAULT_WARNING_MASK \
62 (WARN_CHAR|WARN_NUMBER|WARN_BREAK|WARN_SPACE|WARN_FONT)
63 #endif
64
65 // initial size of buffer for reading names; expanded as necessary
66 #define ABUF_SIZE 16
67
68 extern "C" const char *program_name;
69 extern "C" const char *Version_string;
70
71 #ifdef COLUMN
72 void init_column_requests();
73 #endif /* COLUMN */
74
75 static node *read_draw_node();
76 static void read_color_draw_node(token &);
77 static void push_token(const token &);
78 void copy_file();
79 #ifdef COLUMN
80 void vjustify();
81 #endif /* COLUMN */
82 void transparent_file();
83
84 token tok;
85 int break_flag = 0;
86 int color_flag = 1; // colors are on by default
87 static int backtrace_flag = 0;
88 #ifndef POPEN_MISSING
89 char *pipe_command = 0;
90 #endif
91 charinfo *charset_table[256];
92 unsigned char hpf_code_table[256];
93
94 static int warning_mask = DEFAULT_WARNING_MASK;
95 static int inhibit_errors = 0;
96 static int ignoring = 0;
97
98 static void enable_warning(const char *);
99 static void disable_warning(const char *);
100
101 static int escape_char = '\\';
102 static symbol end_macro_name;
103 static symbol blank_line_macro_name;
104 static int compatible_flag = 0;
105 int ascii_output_flag = 0;
106 int suppress_output_flag = 0;
107 int is_html = 0;
108 int begin_level = 0; // number of nested \O escapes
109
110 int have_input = 0; // whether \f, \F, \D'F...', \H, \m, \M,
111 // \R, \s, or \S has been processed in
112 // token::next()
113 int old_have_input = 0; // value of have_input right before \n
114 int tcommand_flag = 0;
115 int safer_flag = 1; // safer by default
116
117 int have_string_arg = 0; // whether we have \*[foo bar...]
118
119 double spread_limit = -3.0 - 1.0; // negative means deactivated
120
121 double warn_scale;
122 char warn_scaling_indicator;
123 int debug_state = 0; // turns on debugging of the html troff state
124
125 search_path *mac_path = &safer_macro_path;
126
127 // Defaults to the current directory.
128 search_path include_search_path(0, 0, 0, 1);
129
130 static int get_copy(node**, int = 0);
131 static void copy_mode_error(const char *,
132 const errarg & = empty_errarg,
133 const errarg & = empty_errarg,
134 const errarg & = empty_errarg);
135
136 enum read_mode { ALLOW_EMPTY, WITH_ARGS, NO_ARGS };
137 static symbol read_escape_name(read_mode mode = NO_ARGS);
138 static symbol read_long_escape_name(read_mode mode = NO_ARGS);
139 static void interpolate_string(symbol);
140 static void interpolate_string_with_args(symbol);
141 static void interpolate_macro(symbol);
142 static void interpolate_number_format(symbol);
143 static void interpolate_environment_variable(symbol);
144
145 static symbol composite_glyph_name(symbol);
146 static void interpolate_arg(symbol);
147 static request_or_macro *lookup_request(symbol);
148 static int get_delim_number(units *, unsigned char);
149 static int get_delim_number(units *, unsigned char, units);
150 static symbol do_get_long_name(int, char);
151 static int get_line_arg(units *res, unsigned char si, charinfo **cp);
152 static int read_size(int *);
153 static symbol get_delim_name();
154 static void init_registers();
155 static void trapping_blank_line();
156
157 class input_iterator;
158 input_iterator *make_temp_iterator(const char *);
159 const char *input_char_description(int);
160
161 void process_input_stack();
162 void chop_macro(); // declare to avoid friend name injection
163
164
165 void set_escape_char()
166 {
167 if (has_arg()) {
168 if (tok.ch() == 0) {
169 error("bad escape character");
170 escape_char = '\\';
171 }
172 else
173 escape_char = tok.ch();
174 }
175 else
176 escape_char = '\\';
177 skip_line();
178 }
179
180 void escape_off()
181 {
182 escape_char = 0;
183 skip_line();
184 }
185
186 static int saved_escape_char = '\\';
187
188 void save_escape_char()
189 {
190 saved_escape_char = escape_char;
191 skip_line();
192 }
193
194 void restore_escape_char()
195 {
196 escape_char = saved_escape_char;
197 skip_line();
198 }
199
200 class input_iterator {
201 public:
202 input_iterator();
203 input_iterator(int is_div);
204 virtual ~input_iterator() {}
205 int get(node **);
206 friend class input_stack;
207 int is_diversion;
208 statem *diversion_state;
209 protected:
210 const unsigned char *ptr;
211 const unsigned char *eptr;
212 input_iterator *next;
213 private:
214 virtual int fill(node **);
215 virtual int peek();
216 virtual int has_args() { return 0; }
217 virtual int nargs() { return 0; }
218 virtual input_iterator *get_arg(int) { return 0; }
219 virtual int get_location(int, const char **, int *) { return 0; }
220 virtual void backtrace() {}
221 virtual int set_location(const char *, int) { return 0; }
222 virtual int next_file(FILE *, const char *) { return 0; }
223 virtual void shift(int) {}
224 virtual int is_boundary() {return 0; }
225 virtual int is_file() { return 0; }
226 virtual int is_macro() { return 0; }
227 virtual void save_compatible_flag(int) {}
228 virtual int get_compatible_flag() { return 0; }
229 };
230
231 input_iterator::input_iterator()
232 : is_diversion(0), ptr(0), eptr(0)
233 {
234 }
235
236 input_iterator::input_iterator(int is_div)
237 : is_diversion(is_div), ptr(0), eptr(0)
238 {
239 }
240
241 int input_iterator::fill(node **)
242 {
243 return EOF;
244 }
245
246 int input_iterator::peek()
247 {
248 return EOF;
249 }
250
251 inline int input_iterator::get(node **p)
252 {
253 return ptr < eptr ? *ptr++ : fill(p);
254 }
255
256 class input_boundary : public input_iterator {
257 public:
258 int is_boundary() { return 1; }
259 };
260
261 class input_return_boundary : public input_iterator {
262 public:
263 int is_boundary() { return 2; }
264 };
265
266 class file_iterator : public input_iterator {
267 FILE *fp;
268 int lineno;
269 const char *filename;
270 int popened;
271 int newline_flag;
272 int seen_escape;
273 enum { BUF_SIZE = 512 };
274 unsigned char buf[BUF_SIZE];
275 void close();
276 public:
277 file_iterator(FILE *, const char *, int = 0);
278 ~file_iterator();
279 int fill(node **);
280 int peek();
281 int get_location(int, const char **, int *);
282 void backtrace();
283 int set_location(const char *, int);
284 int next_file(FILE *, const char *);
285 int is_file();
286 };
287
288 file_iterator::file_iterator(FILE *f, const char *fn, int po)
289 : fp(f), lineno(1), filename(fn), popened(po),
290 newline_flag(0), seen_escape(0)
291 {
292 if ((font::use_charnames_in_special) && (fn != 0)) {
293 if (!the_output)
294 init_output();
295 the_output->put_filename(fn);
296 }
297 }
298
299 file_iterator::~file_iterator()
300 {
301 close();
302 }
303
304 void file_iterator::close()
305 {
306 if (fp == stdin)
307 clearerr(stdin);
308 #ifndef POPEN_MISSING
309 else if (popened)
310 pclose(fp);
311 #endif /* not POPEN_MISSING */
312 else
313 fclose(fp);
314 }
315
316 int file_iterator::is_file()
317 {
318 return 1;
319 }
320
321 int file_iterator::next_file(FILE *f, const char *s)
322 {
323 close();
324 filename = s;
325 fp = f;
326 lineno = 1;
327 newline_flag = 0;
328 seen_escape = 0;
329 popened = 0;
330 ptr = 0;
331 eptr = 0;
332 return 1;
333 }
334
335 int file_iterator::fill(node **)
336 {
337 if (newline_flag)
338 lineno++;
339 newline_flag = 0;
340 unsigned char *p = buf;
341 ptr = p;
342 unsigned char *e = p + BUF_SIZE;
343 while (p < e) {
344 int c = getc(fp);
345 if (c == EOF)
346 break;
347 if (invalid_input_char(c))
348 warning(WARN_INPUT, "invalid input character code %1", int(c));
349 else {
350 *p++ = c;
351 if (c == '\n') {
352 seen_escape = 0;
353 newline_flag = 1;
354 break;
355 }
356 seen_escape = (c == '\\');
357 }
358 }
359 if (p > buf) {
360 eptr = p;
361 return *ptr++;
362 }
363 else {
364 eptr = p;
365 return EOF;
366 }
367 }
368
369 int file_iterator::peek()
370 {
371 int c = getc(fp);
372 while (invalid_input_char(c)) {
373 warning(WARN_INPUT, "invalid input character code %1", int(c));
374 c = getc(fp);
375 }
376 if (c != EOF)
377 ungetc(c, fp);
378 return c;
379 }
380
381 int file_iterator::get_location(int /*allow_macro*/,
382 const char **filenamep, int *linenop)
383 {
384 *linenop = lineno;
385 if (filename != 0 && strcmp(filename, "-") == 0)
386 *filenamep = "<standard input>";
387 else
388 *filenamep = filename;
389 return 1;
390 }
391
392 void file_iterator::backtrace()
393 {
394 errprint("%1:%2: backtrace: %3 `%1'\n", filename, lineno,
395 popened ? "process" : "file");
396 }
397
398 int file_iterator::set_location(const char *f, int ln)
399 {
400 if (f) {
401 filename = f;
402 if (!the_output)
403 init_output();
404 the_output->put_filename(f);
405 }
406 lineno = ln;
407 return 1;
408 }
409
410 input_iterator nil_iterator;
411
412 class input_stack {
413 public:
414 static int get(node **);
415 static int peek();
416 static void push(input_iterator *);
417 static input_iterator *get_arg(int);
418 static int nargs();
419 static int get_location(int, const char **, int *);
420 static int set_location(const char *, int);
421 static void backtrace();
422 static void backtrace_all();
423 static void next_file(FILE *, const char *);
424 static void end_file();
425 static void shift(int n);
426 static void add_boundary();
427 static void add_return_boundary();
428 static int is_return_boundary();
429 static void remove_boundary();
430 static int get_level();
431 static int get_div_level();
432 static void increase_level();
433 static void decrease_level();
434 static void clear();
435 static void pop_macro();
436 static void save_compatible_flag(int);
437 static int get_compatible_flag();
438 static statem *get_diversion_state();
439 static void check_end_diversion(input_iterator *t);
440 static int limit;
441 static int div_level;
442 static statem *diversion_state;
443 private:
444 static input_iterator *top;
445 static int level;
446 static int finish_get(node **);
447 static int finish_peek();
448 };
449
450 input_iterator *input_stack::top = &nil_iterator;
451 int input_stack::level = 0;
452 int input_stack::limit = DEFAULT_INPUT_STACK_LIMIT;
453 int input_stack::div_level = 0;
454 statem *input_stack::diversion_state = NULL;
455 int suppress_push=0;
456
457
458 inline int input_stack::get_level()
459 {
460 return level;
461 }
462
463 inline void input_stack::increase_level()
464 {
465 level++;
466 }
467
468 inline void input_stack::decrease_level()
469 {
470 level--;
471 }
472
473 inline int input_stack::get_div_level()
474 {
475 return div_level;
476 }
477
478 inline int input_stack::get(node **np)
479 {
480 int res = (top->ptr < top->eptr) ? *top->ptr++ : finish_get(np);
481 if (res == '\n') {
482 old_have_input = have_input;
483 have_input = 0;
484 }
485 return res;
486 }
487
488 int input_stack::finish_get(node **np)
489 {
490 for (;;) {
491 int c = top->fill(np);
492 if (c != EOF || top->is_boundary())
493 return c;
494 if (top == &nil_iterator)
495 break;
496 input_iterator *tem = top;
497 check_end_diversion(tem);
498 #if defined(DEBUGGING)
499 if (debug_state)
500 if (tem->is_diversion)
501 fprintf(stderr,
502 "in diversion level = %d\n", input_stack::get_div_level());
503 #endif
504 top = top->next;
505 level--;
506 delete tem;
507 if (top->ptr < top->eptr)
508 return *top->ptr++;
509 }
510 assert(level == 0);
511 return EOF;
512 }
513
514 inline int input_stack::peek()
515 {
516 return (top->ptr < top->eptr) ? *top->ptr : finish_peek();
517 }
518
519 void input_stack::check_end_diversion(input_iterator *t)
520 {
521 if (t->is_diversion) {
522 div_level--;
523 diversion_state = t->diversion_state;
524 }
525 }
526
527 int input_stack::finish_peek()
528 {
529 for (;;) {
530 int c = top->peek();
531 if (c != EOF || top->is_boundary())
532 return c;
533 if (top == &nil_iterator)
534 break;
535 input_iterator *tem = top;
536 check_end_diversion(tem);
537 top = top->next;
538 level--;
539 delete tem;
540 if (top->ptr < top->eptr)
541 return *top->ptr;
542 }
543 assert(level == 0);
544 return EOF;
545 }
546
547 void input_stack::add_boundary()
548 {
549 push(new input_boundary);
550 }
551
552 void input_stack::add_return_boundary()
553 {
554 push(new input_return_boundary);
555 }
556
557 int input_stack::is_return_boundary()
558 {
559 return top->is_boundary() == 2;
560 }
561
562 void input_stack::remove_boundary()
563 {
564 assert(top->is_boundary());
565 input_iterator *temp = top->next;
566 check_end_diversion(top);
567
568 delete top;
569 top = temp;
570 level--;
571 }
572
573 void input_stack::push(input_iterator *in)
574 {
575 if (in == 0)
576 return;
577 if (++level > limit && limit > 0)
578 fatal("input stack limit exceeded (probable infinite loop)");
579 in->next = top;
580 top = in;
581 if (top->is_diversion) {
582 div_level++;
583 in->diversion_state = diversion_state;
584 diversion_state = curenv->construct_state(0);
585 #if defined(DEBUGGING)
586 if (debug_state) {
587 curenv->dump_troff_state();
588 fflush(stderr);
589 }
590 #endif
591 }
592 #if defined(DEBUGGING)
593 if (debug_state)
594 if (top->is_diversion) {
595 fprintf(stderr,
596 "in diversion level = %d\n", input_stack::get_div_level());
597 fflush(stderr);
598 }
599 #endif
600 }
601
602 statem *get_diversion_state()
603 {
604 return input_stack::get_diversion_state();
605 }
606
607 statem *input_stack::get_diversion_state()
608 {
609 if (diversion_state == NULL)
610 return NULL;
611 else
612 return new statem(diversion_state);
613 }
614
615 input_iterator *input_stack::get_arg(int i)
616 {
617 input_iterator *p;
618 for (p = top; p != 0; p = p->next)
619 if (p->has_args())
620 return p->get_arg(i);
621 return 0;
622 }
623
624 void input_stack::shift(int n)
625 {
626 for (input_iterator *p = top; p; p = p->next)
627 if (p->has_args()) {
628 p->shift(n);
629 return;
630 }
631 }
632
633 int input_stack::nargs()
634 {
635 for (input_iterator *p =top; p != 0; p = p->next)
636 if (p->has_args())
637 return p->nargs();
638 return 0;
639 }
640
641 int input_stack::get_location(int allow_macro, const char **filenamep, int *linenop)
642 {
643 for (input_iterator *p = top; p; p = p->next)
644 if (p->get_location(allow_macro, filenamep, linenop))
645 return 1;
646 return 0;
647 }
648
649 void input_stack::backtrace()
650 {
651 const char *f;
652 int n;
653 // only backtrace down to (not including) the topmost file
654 for (input_iterator *p = top;
655 p && !p->get_location(0, &f, &n);
656 p = p->next)
657 p->backtrace();
658 }
659
660 void input_stack::backtrace_all()
661 {
662 for (input_iterator *p = top; p; p = p->next)
663 p->backtrace();
664 }
665
666 int input_stack::set_location(const char *filename, int lineno)
667 {
668 for (input_iterator *p = top; p; p = p->next)
669 if (p->set_location(filename, lineno))
670 return 1;
671 return 0;
672 }
673
674 void input_stack::next_file(FILE *fp, const char *s)
675 {
676 input_iterator **pp;
677 for (pp = &top; *pp != &nil_iterator; pp = &(*pp)->next)
678 if ((*pp)->next_file(fp, s))
679 return;
680 if (++level > limit && limit > 0)
681 fatal("input stack limit exceeded");
682 *pp = new file_iterator(fp, s);
683 (*pp)->next = &nil_iterator;
684 }
685
686 void input_stack::end_file()
687 {
688 for (input_iterator **pp = &top; *pp != &nil_iterator; pp = &(*pp)->next)
689 if ((*pp)->is_file()) {
690 input_iterator *tem = *pp;
691 check_end_diversion(tem);
692 *pp = (*pp)->next;
693 delete tem;
694 level--;
695 return;
696 }
697 }
698
699 void input_stack::clear()
700 {
701 int nboundaries = 0;
702 while (top != &nil_iterator) {
703 if (top->is_boundary())
704 nboundaries++;
705 input_iterator *tem = top;
706 check_end_diversion(tem);
707 top = top->next;
708 level--;
709 delete tem;
710 }
711 // Keep while_request happy.
712 for (; nboundaries > 0; --nboundaries)
713 add_return_boundary();
714 }
715
716 void input_stack::pop_macro()
717 {
718 int nboundaries = 0;
719 int is_macro = 0;
720 do {
721 if (top->next == &nil_iterator)
722 break;
723 if (top->is_boundary())
724 nboundaries++;
725 is_macro = top->is_macro();
726 input_iterator *tem = top;
727 check_end_diversion(tem);
728 top = top->next;
729 level--;
730 delete tem;
731 } while (!is_macro);
732 // Keep while_request happy.
733 for (; nboundaries > 0; --nboundaries)
734 add_return_boundary();
735 }
736
737 inline void input_stack::save_compatible_flag(int f)
738 {
739 top->save_compatible_flag(f);
740 }
741
742 inline int input_stack::get_compatible_flag()
743 {
744 return top->get_compatible_flag();
745 }
746
747 void backtrace_request()
748 {
749 input_stack::backtrace_all();
750 fflush(stderr);
751 skip_line();
752 }
753
754 void next_file()
755 {
756 symbol nm = get_long_name();
757 while (!tok.newline() && !tok.eof())
758 tok.next();
759 if (nm.is_null())
760 input_stack::end_file();
761 else {
762 errno = 0;
763 FILE *fp = include_search_path.open_file_cautious(nm.contents());
764 if (!fp)
765 error("can't open `%1': %2", nm.contents(), strerror(errno));
766 else
767 input_stack::next_file(fp, nm.contents());
768 }
769 tok.next();
770 }
771
772 void shift()
773 {
774 int n;
775 if (!has_arg() || !get_integer(&n))
776 n = 1;
777 input_stack::shift(n);
778 skip_line();
779 }
780
781 static char get_char_for_escape_name(int allow_space = 0)
782 {
783 int c = get_copy(0);
784 switch (c) {
785 case EOF:
786 copy_mode_error("end of input in escape name");
787 return '\0';
788 default:
789 if (!invalid_input_char(c))
790 break;
791 // fall through
792 case '\n':
793 if (c == '\n')
794 input_stack::push(make_temp_iterator("\n"));
795 // fall through
796 case ' ':
797 if (c == ' ' && allow_space)
798 break;
799 // fall through
800 case '\t':
801 case '\001':
802 case '\b':
803 copy_mode_error("%1 is not allowed in an escape name",
804 input_char_description(c));
805 return '\0';
806 }
807 return c;
808 }
809
810 static symbol read_two_char_escape_name()
811 {
812 char buf[3];
813 buf[0] = get_char_for_escape_name();
814 if (buf[0] != '\0') {
815 buf[1] = get_char_for_escape_name();
816 if (buf[1] == '\0')
817 buf[0] = 0;
818 else
819 buf[2] = 0;
820 }
821 return symbol(buf);
822 }
823
824 static symbol read_long_escape_name(read_mode mode)
825 {
826 int start_level = input_stack::get_level();
827 char abuf[ABUF_SIZE];
828 char *buf = abuf;
829 int buf_size = ABUF_SIZE;
830 int i = 0;
831 char c;
832 int have_char = 0;
833 for (;;) {
834 c = get_char_for_escape_name(have_char && mode == WITH_ARGS);
835 if (c == 0) {
836 if (buf != abuf)
837 a_delete buf;
838 return NULL_SYMBOL;
839 }
840 have_char = 1;
841 if (mode == WITH_ARGS && c == ' ')
842 break;
843 if (i + 2 > buf_size) {
844 if (buf == abuf) {
845 buf = new char[ABUF_SIZE*2];
846 memcpy(buf, abuf, buf_size);
847 buf_size = ABUF_SIZE*2;
848 }
849 else {
850 char *old_buf = buf;
851 buf = new char[buf_size*2];
852 memcpy(buf, old_buf, buf_size);
853 buf_size *= 2;
854 a_delete old_buf;
855 }
856 }
857 if (c == ']' && input_stack::get_level() == start_level)
858 break;
859 buf[i++] = c;
860 }
861 buf[i] = 0;
862 if (c == ' ')
863 have_string_arg = 1;
864 if (buf == abuf) {
865 if (i == 0) {
866 if (mode != ALLOW_EMPTY)
867 copy_mode_error("empty escape name");
868 return EMPTY_SYMBOL;
869 }
870 return symbol(abuf);
871 }
872 else {
873 symbol s(buf);
874 a_delete buf;
875 return s;
876 }
877 }
878
879 static symbol read_escape_name(read_mode mode)
880 {
881 char c = get_char_for_escape_name();
882 if (c == 0)
883 return NULL_SYMBOL;
884 if (c == '(')
885 return read_two_char_escape_name();
886 if (c == '[' && !compatible_flag)
887 return read_long_escape_name(mode);
888 char buf[2];
889 buf[0] = c;
890 buf[1] = '\0';
891 return symbol(buf);
892 }
893
894 static symbol read_increment_and_escape_name(int *incp)
895 {
896 char c = get_char_for_escape_name();
897 switch (c) {
898 case 0:
899 *incp = 0;
900 return NULL_SYMBOL;
901 case '(':
902 *incp = 0;
903 return read_two_char_escape_name();
904 case '+':
905 *incp = 1;
906 return read_escape_name();
907 case '-':
908 *incp = -1;
909 return read_escape_name();
910 case '[':
911 if (!compatible_flag) {
912 *incp = 0;
913 return read_long_escape_name();
914 }
915 break;
916 }
917 *incp = 0;
918 char buf[2];
919 buf[0] = c;
920 buf[1] = '\0';
921 return symbol(buf);
922 }
923
924 static int get_copy(node **nd, int defining)
925 {
926 for (;;) {
927 int c = input_stack::get(nd);
928 if (c == PUSH_GROFF_MODE) {
929 input_stack::save_compatible_flag(compatible_flag);
930 compatible_flag = 0;
931 continue;
932 }
933 if (c == PUSH_COMP_MODE) {
934 input_stack::save_compatible_flag(compatible_flag);
935 compatible_flag = 1;
936 continue;
937 }
938 if (c == POP_GROFFCOMP_MODE) {
939 compatible_flag = input_stack::get_compatible_flag();
940 continue;
941 }
942 if (c == BEGIN_QUOTE) {
943 input_stack::increase_level();
944 continue;
945 }
946 if (c == END_QUOTE) {
947 input_stack::decrease_level();
948 continue;
949 }
950 if (c == ESCAPE_NEWLINE) {
951 if (defining)
952 return c;
953 do {
954 c = input_stack::get(nd);
955 } while (c == ESCAPE_NEWLINE);
956 }
957 if (c != escape_char || escape_char <= 0)
958 return c;
959 c = input_stack::peek();
960 switch(c) {
961 case 0:
962 return escape_char;
963 case '"':
964 (void)input_stack::get(0);
965 while ((c = input_stack::get(0)) != '\n' && c != EOF)
966 ;
967 return c;
968 case '#': // Like \" but newline is ignored.
969 (void)input_stack::get(0);
970 while ((c = input_stack::get(0)) != '\n')
971 if (c == EOF)
972 return EOF;
973 break;
974 case '$':
975 {
976 (void)input_stack::get(0);
977 symbol s = read_escape_name();
978 if (!(s.is_null() || s.is_empty()))
979 interpolate_arg(s);
980 break;
981 }
982 case '*':
983 {
984 (void)input_stack::get(0);
985 symbol s = read_escape_name(WITH_ARGS);
986 if (!(s.is_null() || s.is_empty())) {
987 if (have_string_arg) {
988 have_string_arg = 0;
989 interpolate_string_with_args(s);
990 }
991 else
992 interpolate_string(s);
993 }
994 break;
995 }
996 case 'a':
997 (void)input_stack::get(0);
998 return '\001';
999 case 'e':
1000 (void)input_stack::get(0);
1001 return ESCAPE_e;
1002 case 'E':
1003 (void)input_stack::get(0);
1004 return ESCAPE_E;
1005 case 'n':
1006 {
1007 (void)input_stack::get(0);
1008 int inc;
1009 symbol s = read_increment_and_escape_name(&inc);
1010 if (!(s.is_null() || s.is_empty()))
1011 interpolate_number_reg(s, inc);
1012 break;
1013 }
1014 case 'g':
1015 {
1016 (void)input_stack::get(0);
1017 symbol s = read_escape_name();
1018 if (!(s.is_null() || s.is_empty()))
1019 interpolate_number_format(s);
1020 break;
1021 }
1022 case 't':
1023 (void)input_stack::get(0);
1024 return '\t';
1025 case 'V':
1026 {
1027 (void)input_stack::get(0);
1028 symbol s = read_escape_name();
1029 if (!(s.is_null() || s.is_empty()))
1030 interpolate_environment_variable(s);
1031 break;
1032 }
1033 case '\n':
1034 (void)input_stack::get(0);
1035 if (defining)
1036 return ESCAPE_NEWLINE;
1037 break;
1038 case ' ':
1039 (void)input_stack::get(0);
1040 return ESCAPE_SPACE;
1041 case '~':
1042 (void)input_stack::get(0);
1043 return ESCAPE_TILDE;
1044 case ':':
1045 (void)input_stack::get(0);
1046 return ESCAPE_COLON;
1047 case '|':
1048 (void)input_stack::get(0);
1049 return ESCAPE_BAR;
1050 case '^':
1051 (void)input_stack::get(0);
1052 return ESCAPE_CIRCUMFLEX;
1053 case '{':
1054 (void)input_stack::get(0);
1055 return ESCAPE_LEFT_BRACE;
1056 case '}':
1057 (void)input_stack::get(0);
1058 return ESCAPE_RIGHT_BRACE;
1059 case '`':
1060 (void)input_stack::get(0);
1061 return ESCAPE_LEFT_QUOTE;
1062 case '\'':
1063 (void)input_stack::get(0);
1064 return ESCAPE_RIGHT_QUOTE;
1065 case '-':
1066 (void)input_stack::get(0);
1067 return ESCAPE_HYPHEN;
1068 case '_':
1069 (void)input_stack::get(0);
1070 return ESCAPE_UNDERSCORE;
1071 case 'c':
1072 (void)input_stack::get(0);
1073 return ESCAPE_c;
1074 case '!':
1075 (void)input_stack::get(0);
1076 return ESCAPE_BANG;
1077 case '?':
1078 (void)input_stack::get(0);
1079 return ESCAPE_QUESTION;
1080 case '&':
1081 (void)input_stack::get(0);
1082 return ESCAPE_AMPERSAND;
1083 case ')':
1084 (void)input_stack::get(0);
1085 return ESCAPE_RIGHT_PARENTHESIS;
1086 case '.':
1087 (void)input_stack::get(0);
1088 return c;
1089 case '%':
1090 (void)input_stack::get(0);
1091 return ESCAPE_PERCENT;
1092 default:
1093 if (c == escape_char) {
1094 (void)input_stack::get(0);
1095 return c;
1096 }
1097 else
1098 return escape_char;
1099 }
1100 }
1101 }
1102
1103 class non_interpreted_char_node : public node {
1104 unsigned char c;
1105 public:
1106 non_interpreted_char_node(unsigned char);
1107 node *copy();
1108 int interpret(macro *);
1109 int same(node *);
1110 const char *type();
1111 int force_tprint();
1112 int is_tag();
1113 };
1114
1115 int non_interpreted_char_node::same(node *nd)
1116 {
1117 return c == ((non_interpreted_char_node *)nd)->c;
1118 }
1119
1120 const char *non_interpreted_char_node::type()
1121 {
1122 return "non_interpreted_char_node";
1123 }
1124
1125 int non_interpreted_char_node::force_tprint()
1126 {
1127 return 0;
1128 }
1129
1130 int non_interpreted_char_node::is_tag()
1131 {
1132 return 0;
1133 }
1134
1135 non_interpreted_char_node::non_interpreted_char_node(unsigned char n) : c(n)
1136 {
1137 assert(n != 0);
1138 }
1139
1140 node *non_interpreted_char_node::copy()
1141 {
1142 return new non_interpreted_char_node(c);
1143 }
1144
1145 int non_interpreted_char_node::interpret(macro *mac)
1146 {
1147 mac->append(c);
1148 return 1;
1149 }
1150
1151 static void do_width();
1152 static node *do_non_interpreted();
1153 static node *do_special();
1154 static node *do_suppress(symbol nm);
1155 static void do_register();
1156
1157 dictionary color_dictionary(501);
1158
1159 static color *lookup_color(symbol nm)
1160 {
1161 assert(!nm.is_null());
1162 if (nm == default_symbol)
1163 return &default_color;
1164 color *c = (color *)color_dictionary.lookup(nm);
1165 if (c == 0)
1166 warning(WARN_COLOR, "color `%1' not defined", nm.contents());
1167 return c;
1168 }
1169
1170 void do_glyph_color(symbol nm)
1171 {
1172 if (nm.is_null())
1173 return;
1174 if (nm.is_empty())
1175 curenv->set_glyph_color(curenv->get_prev_glyph_color());
1176 else {
1177 color *tem = lookup_color(nm);
1178 if (tem)
1179 curenv->set_glyph_color(tem);
1180 else
1181 (void)color_dictionary.lookup(nm, new color(nm));
1182 }
1183 }
1184
1185 void do_fill_color(symbol nm)
1186 {
1187 if (nm.is_null())
1188 return;
1189 if (nm.is_empty())
1190 curenv->set_fill_color(curenv->get_prev_fill_color());
1191 else {
1192 color *tem = lookup_color(nm);
1193 if (tem)
1194 curenv->set_fill_color(tem);
1195 else
1196 (void)color_dictionary.lookup(nm, new color(nm));
1197 }
1198 }
1199
1200 static unsigned int get_color_element(const char *scheme, const char *col)
1201 {
1202 units val;
1203 if (!get_number(&val, 'f')) {
1204 warning(WARN_COLOR, "%1 in %2 definition set to 0", col, scheme);
1205 tok.next();
1206 return 0;
1207 }
1208 if (val < 0) {
1209 warning(WARN_RANGE, "%1 cannot be negative: set to 0", col);
1210 return 0;
1211 }
1212 if (val > color::MAX_COLOR_VAL+1) {
1213 warning(WARN_RANGE, "%1 cannot be greater than 1", col);
1214 // we change 0x10000 to 0xffff
1215 return color::MAX_COLOR_VAL;
1216 }
1217 return (unsigned int)val;
1218 }
1219
1220 static color *read_rgb(char end = 0)
1221 {
1222 symbol component = do_get_long_name(0, end);
1223 if (component.is_null()) {
1224 warning(WARN_COLOR, "missing rgb color values");
1225 return 0;
1226 }
1227 const char *s = component.contents();
1228 color *col = new color;
1229 if (*s == '#') {
1230 if (!col->read_rgb(s)) {
1231 warning(WARN_COLOR, "expecting rgb color definition not `%1'", s);
1232 delete col;
1233 return 0;
1234 }
1235 }
1236 else {
1237 if (!end)
1238 input_stack::push(make_temp_iterator(" "));
1239 input_stack::push(make_temp_iterator(s));
1240 tok.next();
1241 unsigned int r = get_color_element("rgb color", "red component");
1242 unsigned int g = get_color_element("rgb color", "green component");
1243 unsigned int b = get_color_element("rgb color", "blue component");
1244 col->set_rgb(r, g, b);
1245 }
1246 return col;
1247 }
1248
1249 static color *read_cmy(char end = 0)
1250 {
1251 symbol component = do_get_long_name(0, end);
1252 if (component.is_null()) {
1253 warning(WARN_COLOR, "missing cmy color values");
1254 return 0;
1255 }
1256 const char *s = component.contents();
1257 color *col = new color;
1258 if (*s == '#') {
1259 if (!col->read_cmy(s)) {
1260 warning(WARN_COLOR, "expecting cmy color definition not `%1'", s);
1261 delete col;
1262 return 0;
1263 }
1264 }
1265 else {
1266 if (!end)
1267 input_stack::push(make_temp_iterator(" "));
1268 input_stack::push(make_temp_iterator(s));
1269 tok.next();
1270 unsigned int c = get_color_element("cmy color", "cyan component");
1271 unsigned int m = get_color_element("cmy color", "magenta component");
1272 unsigned int y = get_color_element("cmy color", "yellow component");
1273 col->set_cmy(c, m, y);
1274 }
1275 return col;
1276 }
1277
1278 static color *read_cmyk(char end = 0)
1279 {
1280 symbol component = do_get_long_name(0, end);
1281 if (component.is_null()) {
1282 warning(WARN_COLOR, "missing cmyk color values");
1283 return 0;
1284 }
1285 const char *s = component.contents();
1286 color *col = new color;
1287 if (*s == '#') {
1288 if (!col->read_cmyk(s)) {
1289 warning(WARN_COLOR, "`expecting a cmyk color definition not `%1'", s);
1290 delete col;
1291 return 0;
1292 }
1293 }
1294 else {
1295 if (!end)
1296 input_stack::push(make_temp_iterator(" "));
1297 input_stack::push(make_temp_iterator(s));
1298 tok.next();
1299 unsigned int c = get_color_element("cmyk color", "cyan component");
1300 unsigned int m = get_color_element("cmyk color", "magenta component");
1301 unsigned int y = get_color_element("cmyk color", "yellow component");
1302 unsigned int k = get_color_element("cmyk color", "black component");
1303 col->set_cmyk(c, m, y, k);
1304 }
1305 return col;
1306 }
1307
1308 static color *read_gray(char end = 0)
1309 {
1310 symbol component = do_get_long_name(0, end);
1311 if (component.is_null()) {
1312 warning(WARN_COLOR, "missing gray values");
1313 return 0;
1314 }
1315 const char *s = component.contents();
1316 color *col = new color;
1317 if (*s == '#') {
1318 if (!col->read_gray(s)) {
1319 warning(WARN_COLOR, "`expecting a gray definition not `%1'", s);
1320 delete col;
1321 return 0;
1322 }
1323 }
1324 else {
1325 if (!end)
1326 input_stack::push(make_temp_iterator("\n"));
1327 input_stack::push(make_temp_iterator(s));
1328 tok.next();
1329 unsigned int g = get_color_element("gray", "gray value");
1330 col->set_gray(g);
1331 }
1332 return col;
1333 }
1334
1335 static void activate_color()
1336 {
1337 int n;
1338 if (has_arg() && get_integer(&n))
1339 color_flag = n != 0;
1340 else
1341 color_flag = 1;
1342 skip_line();
1343 }
1344
1345 static void define_color()
1346 {
1347 symbol color_name = get_long_name(1);
1348 if (color_name.is_null()) {
1349 skip_line();
1350 return;
1351 }
1352 if (color_name == default_symbol) {
1353 warning(WARN_COLOR, "default color can't be redefined");
1354 skip_line();
1355 return;
1356 }
1357 symbol style = get_long_name(1);
1358 if (style.is_null()) {
1359 skip_line();
1360 return;
1361 }
1362 color *col;
1363 if (strcmp(style.contents(), "rgb") == 0)
1364 col = read_rgb();
1365 else if (strcmp(style.contents(), "cmyk") == 0)
1366 col = read_cmyk();
1367 else if (strcmp(style.contents(), "gray") == 0)
1368 col = read_gray();
1369 else if (strcmp(style.contents(), "grey") == 0)
1370 col = read_gray();
1371 else if (strcmp(style.contents(), "cmy") == 0)
1372 col = read_cmy();
1373 else {
1374 warning(WARN_COLOR,
1375 "unknown color space `%1'; use rgb, cmyk, gray or cmy",
1376 style.contents());
1377 skip_line();
1378 return;
1379 }
1380 if (col) {
1381 col->nm = color_name;
1382 (void)color_dictionary.lookup(color_name, col);
1383 }
1384 skip_line();
1385 }
1386
1387 static node *do_overstrike()
1388 {
1389 token start;
1390 overstrike_node *on = new overstrike_node;
1391 int start_level = input_stack::get_level();
1392 start.next();
1393 for (;;) {
1394 tok.next();
1395 if (tok.newline() || tok.eof()) {
1396 warning(WARN_DELIM, "missing closing delimiter");
1397 input_stack::push(make_temp_iterator("\n"));
1398 break;
1399 }
1400 if (tok == start
1401 && (compatible_flag || input_stack::get_level() == start_level))
1402 break;
1403 charinfo *ci = tok.get_char(1);
1404 if (ci) {
1405 node *n = curenv->make_char_node(ci);
1406 if (n)
1407 on->overstrike(n);
1408 }
1409 }
1410 return on;
1411 }
1412
1413 static node *do_bracket()
1414 {
1415 token start;
1416 bracket_node *bn = new bracket_node;
1417 start.next();
1418 int start_level = input_stack::get_level();
1419 for (;;) {
1420 tok.next();
1421 if (tok.eof()) {
1422 warning(WARN_DELIM, "missing closing delimiter");
1423 break;
1424 }
1425 if (tok.newline()) {
1426 warning(WARN_DELIM, "missing closing delimiter");
1427 input_stack::push(make_temp_iterator("\n"));
1428 break;
1429 }
1430 if (tok == start
1431 && (compatible_flag || input_stack::get_level() == start_level))
1432 break;
1433 charinfo *ci = tok.get_char(1);
1434 if (ci) {
1435 node *n = curenv->make_char_node(ci);
1436 if (n)
1437 bn->bracket(n);
1438 }
1439 }
1440 return bn;
1441 }
1442
1443 static int do_name_test()
1444 {
1445 token start;
1446 start.next();
1447 int start_level = input_stack::get_level();
1448 int bad_char = 0;
1449 int some_char = 0;
1450 for (;;) {
1451 tok.next();
1452 if (tok.newline() || tok.eof()) {
1453 warning(WARN_DELIM, "missing closing delimiter");
1454 input_stack::push(make_temp_iterator("\n"));
1455 break;
1456 }
1457 if (tok == start
1458 && (compatible_flag || input_stack::get_level() == start_level))
1459 break;
1460 if (!tok.ch())
1461 bad_char = 1;
1462 some_char = 1;
1463 }
1464 return some_char && !bad_char;
1465 }
1466
1467 static int do_expr_test()
1468 {
1469 token start;
1470 start.next();
1471 int start_level = input_stack::get_level();
1472 if (!start.delimiter(1))
1473 return 0;
1474 tok.next();
1475 // disable all warning and error messages temporarily
1476 int saved_warning_mask = warning_mask;
1477 int saved_inhibit_errors = inhibit_errors;
1478 warning_mask = 0;
1479 inhibit_errors = 1;
1480 int dummy;
1481 int result = get_number_rigidly(&dummy, 'u');
1482 warning_mask = saved_warning_mask;
1483 inhibit_errors = saved_inhibit_errors;
1484 if (tok == start && input_stack::get_level() == start_level)
1485 return result;
1486 // ignore everything up to the delimiter in case we aren't right there
1487 for (;;) {
1488 tok.next();
1489 if (tok.newline() || tok.eof()) {
1490 warning(WARN_DELIM, "missing closing delimiter");
1491 input_stack::push(make_temp_iterator("\n"));
1492 break;
1493 }
1494 if (tok == start && input_stack::get_level() == start_level)
1495 break;
1496 }
1497 return 0;
1498 }
1499
1500 #if 0
1501 static node *do_zero_width()
1502 {
1503 token start;
1504 start.next();
1505 int start_level = input_stack::get_level();
1506 environment env(curenv);
1507 environment *oldenv = curenv;
1508 curenv = &env;
1509 for (;;) {
1510 tok.next();
1511 if (tok.newline() || tok.eof()) {
1512 error("missing closing delimiter");
1513 break;
1514 }
1515 if (tok == start
1516 && (compatible_flag || input_stack::get_level() == start_level))
1517 break;
1518 tok.process();
1519 }
1520 curenv = oldenv;
1521 node *rev = env.extract_output_line();
1522 node *n = 0;
1523 while (rev) {
1524 node *tem = rev;
1525 rev = rev->next;
1526 tem->next = n;
1527 n = tem;
1528 }
1529 return new zero_width_node(n);
1530 }
1531
1532 #else
1533
1534 // It's undesirable for \Z to change environments, because then
1535 // \n(.w won't work as expected.
1536
1537 static node *do_zero_width()
1538 {
1539 node *rev = new dummy_node;
1540 token start;
1541 start.next();
1542 int start_level = input_stack::get_level();
1543 for (;;) {
1544 tok.next();
1545 if (tok.newline() || tok.eof()) {
1546 warning(WARN_DELIM, "missing closing delimiter");
1547 input_stack::push(make_temp_iterator("\n"));
1548 break;
1549 }
1550 if (tok == start
1551 && (compatible_flag || input_stack::get_level() == start_level))
1552 break;
1553 if (!tok.add_to_node_list(&rev))
1554 error("invalid token in argument to \\Z");
1555 }
1556 node *n = 0;
1557 while (rev) {
1558 node *tem = rev;
1559 rev = rev->next;
1560 tem->next = n;
1561 n = tem;
1562 }
1563 return new zero_width_node(n);
1564 }
1565
1566 #endif
1567
1568 token_node *node::get_token_node()
1569 {
1570 return 0;
1571 }
1572
1573 class token_node : public node {
1574 public:
1575 token tk;
1576 token_node(const token &t);
1577 node *copy();
1578 token_node *get_token_node();
1579 int same(node *);
1580 const char *type();
1581 int force_tprint();
1582 int is_tag();
1583 };
1584
1585 token_node::token_node(const token &t) : tk(t)
1586 {
1587 }
1588
1589 node *token_node::copy()
1590 {
1591 return new token_node(tk);
1592 }
1593
1594 token_node *token_node::get_token_node()
1595 {
1596 return this;
1597 }
1598
1599 int token_node::same(node *nd)
1600 {
1601 return tk == ((token_node *)nd)->tk;
1602 }
1603
1604 const char *token_node::type()
1605 {
1606 return "token_node";
1607 }
1608
1609 int token_node::force_tprint()
1610 {
1611 return 0;
1612 }
1613
1614 int token_node::is_tag()
1615 {
1616 return 0;
1617 }
1618
1619 token::token() : nd(0), type(TOKEN_EMPTY)
1620 {
1621 }
1622
1623 token::~token()
1624 {
1625 delete nd;
1626 }
1627
1628 token::token(const token &t)
1629 : nm(t.nm), c(t.c), val(t.val), dim(t.dim), type(t.type)
1630 {
1631 // Use two statements to work around bug in SGI C++.
1632 node *tem = t.nd;
1633 nd = tem ? tem->copy() : 0;
1634 }
1635
1636 void token::operator=(const token &t)
1637 {
1638 delete nd;
1639 nm = t.nm;
1640 // Use two statements to work around bug in SGI C++.
1641 node *tem = t.nd;
1642 nd = tem ? tem->copy() : 0;
1643 c = t.c;
1644 val = t.val;
1645 dim = t.dim;
1646 type = t.type;
1647 }
1648
1649 void token::skip()
1650 {
1651 while (space())
1652 next();
1653 }
1654
1655 int has_arg()
1656 {
1657 while (tok.space())
1658 tok.next();
1659 return !tok.newline();
1660 }
1661
1662 void token::make_space()
1663 {
1664 type = TOKEN_SPACE;
1665 }
1666
1667 void token::make_newline()
1668 {
1669 type = TOKEN_NEWLINE;
1670 }
1671
1672 void token::next()
1673 {
1674 if (nd) {
1675 delete nd;
1676 nd = 0;
1677 }
1678 units x;
1679 for (;;) {
1680 node *n = 0;
1681 int cc = input_stack::get(&n);
1682 if (cc != escape_char || escape_char == 0) {
1683 handle_normal_char:
1684 switch(cc) {
1685 case PUSH_GROFF_MODE:
1686 input_stack::save_compatible_flag(compatible_flag);
1687 compatible_flag = 0;
1688 continue;
1689 case PUSH_COMP_MODE:
1690 input_stack::save_compatible_flag(compatible_flag);
1691 compatible_flag = 1;
1692 continue;
1693 case POP_GROFFCOMP_MODE:
1694 compatible_flag = input_stack::get_compatible_flag();
1695 continue;
1696 case BEGIN_QUOTE:
1697 input_stack::increase_level();
1698 continue;
1699 case END_QUOTE:
1700 input_stack::decrease_level();
1701 continue;
1702 case EOF:
1703 type = TOKEN_EOF;
1704 return;
1705 case TRANSPARENT_FILE_REQUEST:
1706 case TITLE_REQUEST:
1707 case COPY_FILE_REQUEST:
1708 #ifdef COLUMN
1709 case VJUSTIFY_REQUEST:
1710 #endif /* COLUMN */
1711 type = TOKEN_REQUEST;
1712 c = cc;
1713 return;
1714 case BEGIN_TRAP:
1715 type = TOKEN_BEGIN_TRAP;
1716 return;
1717 case END_TRAP:
1718 type = TOKEN_END_TRAP;
1719 return;
1720 case LAST_PAGE_EJECTOR:
1721 seen_last_page_ejector = 1;
1722 // fall through
1723 case PAGE_EJECTOR:
1724 type = TOKEN_PAGE_EJECTOR;
1725 return;
1726 case ESCAPE_PERCENT:
1727 ESCAPE_PERCENT:
1728 type = TOKEN_HYPHEN_INDICATOR;
1729 return;
1730 case ESCAPE_SPACE:
1731 ESCAPE_SPACE:
1732 type = TOKEN_UNSTRETCHABLE_SPACE;
1733 return;
1734 case ESCAPE_TILDE:
1735 ESCAPE_TILDE:
1736 type = TOKEN_STRETCHABLE_SPACE;
1737 return;
1738 case ESCAPE_COLON:
1739 ESCAPE_COLON:
1740 type = TOKEN_ZERO_WIDTH_BREAK;
1741 return;
1742 case ESCAPE_e:
1743 ESCAPE_e:
1744 type = TOKEN_ESCAPE;
1745 return;
1746 case ESCAPE_E:
1747 goto handle_escape_char;
1748 case ESCAPE_BAR:
1749 ESCAPE_BAR:
1750 type = TOKEN_NODE;
1751 nd = new hmotion_node(curenv->get_narrow_space_width(),
1752 curenv->get_fill_color());
1753 return;
1754 case ESCAPE_CIRCUMFLEX:
1755 ESCAPE_CIRCUMFLEX:
1756 type = TOKEN_NODE;
1757 nd = new hmotion_node(curenv->get_half_narrow_space_width(),
1758 curenv->get_fill_color());
1759 return;
1760 case ESCAPE_NEWLINE:
1761 have_input = 0;
1762 break;
1763 case ESCAPE_LEFT_BRACE:
1764 ESCAPE_LEFT_BRACE:
1765 type = TOKEN_LEFT_BRACE;
1766 return;
1767 case ESCAPE_RIGHT_BRACE:
1768 ESCAPE_RIGHT_BRACE:
1769 type = TOKEN_RIGHT_BRACE;
1770 return;
1771 case ESCAPE_LEFT_QUOTE:
1772 ESCAPE_LEFT_QUOTE:
1773 type = TOKEN_SPECIAL;
1774 nm = symbol("ga");
1775 return;
1776 case ESCAPE_RIGHT_QUOTE:
1777 ESCAPE_RIGHT_QUOTE:
1778 type = TOKEN_SPECIAL;
1779 nm = symbol("aa");
1780 return;
1781 case ESCAPE_HYPHEN:
1782 ESCAPE_HYPHEN:
1783 type = TOKEN_SPECIAL;
1784 nm = symbol("-");
1785 return;
1786 case ESCAPE_UNDERSCORE:
1787 ESCAPE_UNDERSCORE:
1788 type = TOKEN_SPECIAL;
1789 nm = symbol("ul");
1790 return;
1791 case ESCAPE_c:
1792 ESCAPE_c:
1793 type = TOKEN_INTERRUPT;
1794 return;
1795 case ESCAPE_BANG:
1796 ESCAPE_BANG:
1797 type = TOKEN_TRANSPARENT;
1798 return;
1799 case ESCAPE_QUESTION:
1800 ESCAPE_QUESTION:
1801 nd = do_non_interpreted();
1802 if (nd) {
1803 type = TOKEN_NODE;
1804 return;
1805 }
1806 break;
1807 case ESCAPE_AMPERSAND:
1808 ESCAPE_AMPERSAND:
1809 type = TOKEN_DUMMY;
1810 return;
1811 case ESCAPE_RIGHT_PARENTHESIS:
1812 ESCAPE_RIGHT_PARENTHESIS:
1813 type = TOKEN_TRANSPARENT_DUMMY;
1814 return;
1815 case '\b':
1816 type = TOKEN_BACKSPACE;
1817 return;
1818 case ' ':
1819 type = TOKEN_SPACE;
1820 return;
1821 case '\t':
1822 type = TOKEN_TAB;
1823 return;
1824 case '\n':
1825 type = TOKEN_NEWLINE;
1826 return;
1827 case '\001':
1828 type = TOKEN_LEADER;
1829 return;
1830 case 0:
1831 {
1832 assert(n != 0);
1833 token_node *tn = n->get_token_node();
1834 if (tn) {
1835 *this = tn->tk;
1836 delete tn;
1837 }
1838 else {
1839 nd = n;
1840 type = TOKEN_NODE;
1841 }
1842 }
1843 return;
1844 default:
1845 type = TOKEN_CHAR;
1846 c = cc;
1847 return;
1848 }
1849 }
1850 else {
1851 handle_escape_char:
1852 cc = input_stack::get(&n);
1853 switch(cc) {
1854 case '(':
1855 nm = read_two_char_escape_name();
1856 type = TOKEN_SPECIAL;
1857 return;
1858 case EOF:
1859 type = TOKEN_EOF;
1860 error("end of input after escape character");
1861 return;
1862 case '`':
1863 goto ESCAPE_LEFT_QUOTE;
1864 case '\'':
1865 goto ESCAPE_RIGHT_QUOTE;
1866 case '-':
1867 goto ESCAPE_HYPHEN;
1868 case '_':
1869 goto ESCAPE_UNDERSCORE;
1870 case '%':
1871 goto ESCAPE_PERCENT;
1872 case ' ':
1873 goto ESCAPE_SPACE;
1874 case '0':
1875 nd = new hmotion_node(curenv->get_digit_width(),
1876 curenv->get_fill_color());
1877 type = TOKEN_NODE;
1878 return;
1879 case '|':
1880 goto ESCAPE_BAR;
1881 case '^':
1882 goto ESCAPE_CIRCUMFLEX;
1883 case '/':
1884 type = TOKEN_ITALIC_CORRECTION;
1885 return;
1886 case ',':
1887 type = TOKEN_NODE;
1888 nd = new left_italic_corrected_node;
1889 return;
1890 case '&':
1891 goto ESCAPE_AMPERSAND;
1892 case ')':
1893 goto ESCAPE_RIGHT_PARENTHESIS;
1894 case '!':
1895 goto ESCAPE_BANG;
1896 case '?':
1897 goto ESCAPE_QUESTION;
1898 case '~':
1899 goto ESCAPE_TILDE;
1900 case ':':
1901 goto ESCAPE_COLON;
1902 case '"':
1903 while ((cc = input_stack::get(0)) != '\n' && cc != EOF)
1904 ;
1905 if (cc == '\n')
1906 type = TOKEN_NEWLINE;
1907 else
1908 type = TOKEN_EOF;
1909 return;
1910 case '#': // Like \" but newline is ignored.
1911 while ((cc = input_stack::get(0)) != '\n')
1912 if (cc == EOF) {
1913 type = TOKEN_EOF;
1914 return;
1915 }
1916 break;
1917 case '$':
1918 {
1919 symbol s = read_escape_name();
1920 if (!(s.is_null() || s.is_empty()))
1921 interpolate_arg(s);
1922 break;
1923 }
1924 case '*':
1925 {
1926 symbol s = read_escape_name(WITH_ARGS);
1927 if (!(s.is_null() || s.is_empty())) {
1928 if (have_string_arg) {
1929 have_string_arg = 0;
1930 interpolate_string_with_args(s);
1931 }
1932 else
1933 interpolate_string(s);
1934 }
1935 break;
1936 }
1937 case 'a':
1938 nd = new non_interpreted_char_node('\001');
1939 type = TOKEN_NODE;
1940 return;
1941 case 'A':
1942 c = '0' + do_name_test();
1943 type = TOKEN_CHAR;
1944 return;
1945 case 'b':
1946 nd = do_bracket();
1947 type = TOKEN_NODE;
1948 return;
1949 case 'B':
1950 c = '0' + do_expr_test();
1951 type = TOKEN_CHAR;
1952 return;
1953 case 'c':
1954 goto ESCAPE_c;
1955 case 'C':
1956 nm = get_delim_name();
1957 if (nm.is_null())
1958 break;
1959 type = TOKEN_SPECIAL;
1960 return;
1961 case 'd':
1962 type = TOKEN_NODE;
1963 nd = new vmotion_node(curenv->get_size() / 2,
1964 curenv->get_fill_color());
1965 return;
1966 case 'D':
1967 nd = read_draw_node();
1968 if (!nd)
1969 break;
1970 type = TOKEN_NODE;
1971 return;
1972 case 'e':
1973 goto ESCAPE_e;
1974 case 'E':
1975 goto handle_escape_char;
1976 case 'f':
1977 {
1978 symbol s = read_escape_name(ALLOW_EMPTY);
1979 if (s.is_null())
1980 break;
1981 const char *p;
1982 for (p = s.contents(); *p != '\0'; p++)
1983 if (!csdigit(*p))
1984 break;
1985 if (*p || s.is_empty())
1986 curenv->set_font(s);
1987 else
1988 curenv->set_font(atoi(s.contents()));
1989 if (!compatible_flag)
1990 have_input = 1;
1991 break;
1992 }
1993 case 'F':
1994 {
1995 symbol s = read_escape_name(ALLOW_EMPTY);
1996 if (s.is_null())
1997 break;
1998 curenv->set_family(s);
1999 have_input = 1;
2000 break;
2001 }
2002 case 'g':
2003 {
2004 symbol s = read_escape_name();
2005 if (!(s.is_null() || s.is_empty()))
2006 interpolate_number_format(s);
2007 break;
2008 }
2009 case 'h':
2010 if (!get_delim_number(&x, 'm'))
2011 break;
2012 type = TOKEN_NODE;
2013 nd = new hmotion_node(x, curenv->get_fill_color());
2014 return;
2015 case 'H':
2016 // don't take height increments relative to previous height if
2017 // in compatibility mode
2018 if (!compatible_flag && curenv->get_char_height())
2019 {
2020 if (get_delim_number(&x, 'z', curenv->get_char_height()))
2021 curenv->set_char_height(x);
2022 }
2023 else
2024 {
2025 if (get_delim_number(&x, 'z', curenv->get_requested_point_size()))
2026 curenv->set_char_height(x);
2027 }
2028 if (!compatible_flag)
2029 have_input = 1;
2030 break;
2031 case 'k':
2032 nm = read_escape_name();
2033 if (nm.is_null() || nm.is_empty())
2034 break;
2035 type = TOKEN_MARK_INPUT;
2036 return;
2037 case 'l':
2038 case 'L':
2039 {
2040 charinfo *s = 0;
2041 if (!get_line_arg(&x, (cc == 'l' ? 'm': 'v'), &s))
2042 break;
2043 if (s == 0)
2044 s = get_charinfo(cc == 'l' ? "ru" : "br");
2045 type = TOKEN_NODE;
2046 node *char_node = curenv->make_char_node(s);
2047 if (cc == 'l')
2048 nd = new hline_node(x, char_node);
2049 else
2050 nd = new vline_node(x, char_node);
2051 return;
2052 }
2053 case 'm':
2054 do_glyph_color(read_escape_name(ALLOW_EMPTY));
2055 if (!compatible_flag)
2056 have_input = 1;
2057 break;
2058 case 'M':
2059 do_fill_color(read_escape_name(ALLOW_EMPTY));
2060 if (!compatible_flag)
2061 have_input = 1;
2062 break;
2063 case 'n':
2064 {
2065 int inc;
2066 symbol s = read_increment_and_escape_name(&inc);
2067 if (!(s.is_null() || s.is_empty()))
2068 interpolate_number_reg(s, inc);
2069 break;
2070 }
2071 case 'N':
2072 if (!get_delim_number(&val, 0))
2073 break;
2074 type = TOKEN_NUMBERED_CHAR;
2075 return;
2076 case 'o':
2077 nd = do_overstrike();
2078 type = TOKEN_NODE;
2079 return;
2080 case 'O':
2081 nd = do_suppress(read_escape_name());
2082 if (!nd)
2083 break;
2084 type = TOKEN_NODE;
2085 return;
2086 case 'p':
2087 type = TOKEN_SPREAD;
2088 return;
2089 case 'r':
2090 type = TOKEN_NODE;
2091 nd = new vmotion_node(-curenv->get_size(), curenv->get_fill_color());
2092 return;
2093 case 'R':
2094 do_register();
2095 if (!compatible_flag)
2096 have_input = 1;
2097 break;
2098 case 's':
2099 if (read_size(&x))
2100 curenv->set_size(x);
2101 if (!compatible_flag)
2102 have_input = 1;
2103 break;
2104 case 'S':
2105 if (get_delim_number(&x, 0))
2106 curenv->set_char_slant(x);
2107 if (!compatible_flag)
2108 have_input = 1;
2109 break;
2110 case 't':
2111 type = TOKEN_NODE;
2112 nd = new non_interpreted_char_node('\t');
2113 return;
2114 case 'u':
2115 type = TOKEN_NODE;
2116 nd = new vmotion_node(-curenv->get_size() / 2,
2117 curenv->get_fill_color());
2118 return;
2119 case 'v':
2120 if (!get_delim_number(&x, 'v'))
2121 break;
2122 type = TOKEN_NODE;
2123 nd = new vmotion_node(x, curenv->get_fill_color());
2124 return;
2125 case 'V':
2126 {
2127 symbol s = read_escape_name();
2128 if (!(s.is_null() || s.is_empty()))
2129 interpolate_environment_variable(s);
2130 break;
2131 }
2132 case 'w':
2133 do_width();
2134 break;
2135 case 'x':
2136 if (!get_delim_number(&x, 'v'))
2137 break;
2138 type = TOKEN_NODE;
2139 nd = new extra_size_node(x);
2140 return;
2141 case 'X':
2142 nd = do_special();
2143 if (!nd)
2144 break;
2145 type = TOKEN_NODE;
2146 return;
2147 case 'Y':
2148 {
2149 symbol s = read_escape_name();
2150 if (s.is_null() || s.is_empty())
2151 break;
2152 request_or_macro *p = lookup_request(s);
2153 macro *m = p->to_macro();
2154 if (!m) {
2155 error("can't transparently throughput a request");
2156 break;
2157 }
2158 nd = new special_node(*m);
2159 type = TOKEN_NODE;
2160 return;
2161 }
2162 case 'z':
2163 {
2164 next();
2165 if (type == TOKEN_NODE)
2166 nd = new zero_width_node(nd);
2167 else {
2168 charinfo *ci = get_char(1);
2169 if (ci == 0)
2170 break;
2171 node *gn = curenv->make_char_node(ci);
2172 if (gn == 0)
2173 break;
2174 nd = new zero_width_node(gn);
2175 type = TOKEN_NODE;
2176 }
2177 return;
2178 }
2179 case 'Z':
2180 nd = do_zero_width();
2181 if (nd == 0)
2182 break;
2183 type = TOKEN_NODE;
2184 return;
2185 case '{':
2186 goto ESCAPE_LEFT_BRACE;
2187 case '}':
2188 goto ESCAPE_RIGHT_BRACE;
2189 case '\n':
2190 break;
2191 case '[':
2192 if (!compatible_flag) {
2193 symbol s = read_long_escape_name(WITH_ARGS);
2194 if (s.is_null() || s.is_empty())
2195 break;
2196 if (have_string_arg) {
2197 have_string_arg = 0;
2198 nm = composite_glyph_name(s);
2199 }
2200 else {
2201 const char *gn = check_unicode_name(s.contents());
2202 if (gn) {
2203 const char *gn_decomposed = decompose_unicode(gn);
2204 if (gn_decomposed)
2205 gn = &gn_decomposed[1];
2206 const char *groff_gn = unicode_to_glyph_name(gn);
2207 if (groff_gn)
2208 nm = symbol(groff_gn);
2209 else {
2210 char *buf = new char[strlen(gn) + 1 + 1];
2211 strcpy(buf, "u");
2212 strcat(buf, gn);
2213 nm = symbol(buf);
2214 a_delete buf;
2215 }
2216 }
2217 else
2218 nm = symbol(s.contents());
2219 }
2220 type = TOKEN_SPECIAL;
2221 return;
2222 }
2223 goto handle_normal_char;
2224 default:
2225 if (cc != escape_char && cc != '.')
2226 warning(WARN_ESCAPE, "escape character ignored before %1",
2227 input_char_description(cc));
2228 goto handle_normal_char;
2229 }
2230 }
2231 }
2232 }
2233
2234 int token::operator==(const token &t)
2235 {
2236 if (type != t.type)
2237 return 0;
2238 switch(type) {
2239 case TOKEN_CHAR:
2240 return c == t.c;
2241 case TOKEN_SPECIAL:
2242 return nm == t.nm;
2243 case TOKEN_NUMBERED_CHAR:
2244 return val == t.val;
2245 default:
2246 return 1;
2247 }
2248 }
2249
2250 int token::operator!=(const token &t)
2251 {
2252 return !(*this == t);
2253 }
2254
2255 // is token a suitable delimiter (like ')?
2256
2257 int token::delimiter(int err)
2258 {
2259 switch(type) {
2260 case TOKEN_CHAR:
2261 switch(c) {
2262 case '0':
2263 case '1':
2264 case '2':
2265 case '3':
2266 case '4':
2267 case '5':
2268 case '6':
2269 case '7':
2270 case '8':
2271 case '9':
2272 case '+':
2273 case '-':
2274 case '/':
2275 case '*':
2276 case '%':
2277 case '<':
2278 case '>':
2279 case '=':
2280 case '&':
2281 case ':':
2282 case '(':
2283 case ')':
2284 case '.':
2285 if (err)
2286 error("cannot use character `%1' as a starting delimiter", char(c));
2287 return 0;
2288 default:
2289 return 1;
2290 }
2291 case TOKEN_NODE:
2292 case TOKEN_SPACE:
2293 case TOKEN_STRETCHABLE_SPACE:
2294 case TOKEN_UNSTRETCHABLE_SPACE:
2295 case TOKEN_TAB:
2296 case TOKEN_NEWLINE:
2297 if (err)
2298 error("cannot use %1 as a starting delimiter", description());
2299 return 0;
2300 default:
2301 return 1;
2302 }
2303 }
2304
2305 const char *token::description()
2306 {
2307 static char buf[4];
2308 switch (type) {
2309 case TOKEN_BACKSPACE:
2310 return "a backspace character";
2311 case TOKEN_CHAR:
2312 buf[0] = '`';
2313 buf[1] = c;
2314 buf[2] = '\'';
2315 buf[3] = '\0';
2316 return buf;
2317 case TOKEN_DUMMY:
2318 return "`\\&'";
2319 case TOKEN_ESCAPE:
2320 return "`\\e'";
2321 case TOKEN_HYPHEN_INDICATOR:
2322 return "`\\%'";
2323 case TOKEN_INTERRUPT:
2324 return "`\\c'";
2325 case TOKEN_ITALIC_CORRECTION:
2326 return "`\\/'";
2327 case TOKEN_LEADER:
2328 return "a leader character";
2329 case TOKEN_LEFT_BRACE:
2330 return "`\\{'";
2331 case TOKEN_MARK_INPUT:
2332 return "`\\k'";
2333 case TOKEN_NEWLINE:
2334 return "newline";
2335 case TOKEN_NODE:
2336 return "a node";
2337 case TOKEN_NUMBERED_CHAR:
2338 return "`\\N'";
2339 case TOKEN_RIGHT_BRACE:
2340 return "`\\}'";
2341 case TOKEN_SPACE:
2342 return "a space";
2343 case TOKEN_SPECIAL:
2344 return "a special character";
2345 case TOKEN_SPREAD:
2346 return "`\\p'";
2347 case TOKEN_STRETCHABLE_SPACE:
2348 return "`\\~'";
2349 case TOKEN_UNSTRETCHABLE_SPACE:
2350 return "`\\ '";
2351 case TOKEN_TAB:
2352 return "a tab character";
2353 case TOKEN_TRANSPARENT:
2354 return "`\\!'";
2355 case TOKEN_TRANSPARENT_DUMMY:
2356 return "`\\)'";
2357 case TOKEN_ZERO_WIDTH_BREAK:
2358 return "`\\:'";
2359 case TOKEN_EOF:
2360 return "end of input";
2361 default:
2362 break;
2363 }
2364 return "a magic token";
2365 }
2366
2367 void skip_line()
2368 {
2369 while (!tok.newline())
2370 if (tok.eof())
2371 return;
2372 else
2373 tok.next();
2374 tok.next();
2375 }
2376
2377 void compatible()
2378 {
2379 int n;
2380 if (has_arg() && get_integer(&n))
2381 compatible_flag = n != 0;
2382 else
2383 compatible_flag = 1;
2384 skip_line();
2385 }
2386
2387 static void empty_name_warning(int required)
2388 {
2389 if (tok.newline() || tok.eof()) {
2390 if (required)
2391 warning(WARN_MISSING, "missing name");
2392 }
2393 else if (tok.right_brace() || tok.tab()) {
2394 const char *start = tok.description();
2395 do {
2396 tok.next();
2397 } while (tok.space() || tok.right_brace() || tok.tab());
2398 if (!tok.newline() && !tok.eof())
2399 error("%1 is not allowed before an argument", start);
2400 else if (required)
2401 warning(WARN_MISSING, "missing name");
2402 }
2403 else if (required)
2404 error("name expected (got %1)", tok.description());
2405 else
2406 error("name expected (got %1): treated as missing", tok.description());
2407 }
2408
2409 static void non_empty_name_warning()
2410 {
2411 if (!tok.newline() && !tok.eof() && !tok.space() && !tok.tab()
2412 && !tok.right_brace()
2413 // We don't want to give a warning for .el\{
2414 && !tok.left_brace())
2415 error("%1 is not allowed in a name", tok.description());
2416 }
2417
2418 symbol get_name(int required)
2419 {
2420 if (compatible_flag) {
2421 char buf[3];
2422 tok.skip();
2423 if ((buf[0] = tok.ch()) != 0) {
2424 tok.next();
2425 if ((buf[1] = tok.ch()) != 0) {
2426 buf[2] = 0;
2427 tok.make_space();
2428 }
2429 else
2430 non_empty_name_warning();
2431 return symbol(buf);
2432 }
2433 else {
2434 empty_name_warning(required);
2435 return NULL_SYMBOL;
2436 }
2437 }
2438 else
2439 return get_long_name(required);
2440 }
2441
2442 symbol get_long_name(int required)
2443 {
2444 return do_get_long_name(required, 0);
2445 }
2446
2447 static symbol do_get_long_name(int required, char end)
2448 {
2449 while (tok.space())
2450 tok.next();
2451 char abuf[ABUF_SIZE];
2452 char *buf = abuf;
2453 int buf_size = ABUF_SIZE;
2454 int i = 0;
2455 for (;;) {
2456 // If end != 0 we normally have to append a null byte
2457 if (i + 2 > buf_size) {
2458 if (buf == abuf) {
2459 buf = new char[ABUF_SIZE*2];
2460 memcpy(buf, abuf, buf_size);
2461 buf_size = ABUF_SIZE*2;
2462 }
2463 else {
2464 char *old_buf = buf;
2465 buf = new char[buf_size*2];
2466 memcpy(buf, old_buf, buf_size);
2467 buf_size *= 2;
2468 a_delete old_buf;
2469 }
2470 }
2471 if ((buf[i] = tok.ch()) == 0 || buf[i] == end)
2472 break;
2473 i++;
2474 tok.next();
2475 }
2476 if (i == 0) {
2477 empty_name_warning(required);
2478 return NULL_SYMBOL;
2479 }
2480 if (end && buf[i] == end)
2481 buf[i+1] = '\0';
2482 else
2483 non_empty_name_warning();
2484 if (buf == abuf)
2485 return symbol(buf);
2486 else {
2487 symbol s(buf);
2488 a_delete buf;
2489 return s;
2490 }
2491 }
2492
2493 void exit_troff()
2494 {
2495 exit_started = 1;
2496 topdiv->set_last_page();
2497 if (!end_macro_name.is_null()) {
2498 spring_trap(end_macro_name);
2499 tok.next();
2500 process_input_stack();
2501 }
2502 curenv->final_break();
2503 tok.next();
2504 process_input_stack();
2505 end_diversions();
2506 if (topdiv->get_page_length() > 0) {
2507 done_end_macro = 1;
2508 topdiv->set_ejecting();
2509 static unsigned char buf[2] = { LAST_PAGE_EJECTOR, '\0' };
2510 input_stack::push(make_temp_iterator((char *)buf));
2511 topdiv->space(topdiv->get_page_length(), 1);
2512 tok.next();
2513 process_input_stack();
2514 seen_last_page_ejector = 1; // should be set already
2515 topdiv->set_ejecting();
2516 push_page_ejector();
2517 topdiv->space(topdiv->get_page_length(), 1);
2518 tok.next();
2519 process_input_stack();
2520 }
2521 // This will only happen if a trap-invoked macro starts a diversion,
2522 // or if vertical position traps have been disabled.
2523 cleanup_and_exit(0);
2524 }
2525
2526 // This implements .ex. The input stack must be cleared before calling
2527 // exit_troff().
2528
2529 void exit_request()
2530 {
2531 input_stack::clear();
2532 if (exit_started)
2533 tok.next();
2534 else
2535 exit_troff();
2536 }
2537
2538 void return_macro_request()
2539 {
2540 if (has_arg() && tok.ch())
2541 input_stack::pop_macro();
2542 input_stack::pop_macro();
2543 tok.next();
2544 }
2545
2546 void end_macro()
2547 {
2548 end_macro_name = get_name();
2549 skip_line();
2550 }
2551
2552 void blank_line_macro()
2553 {
2554 blank_line_macro_name = get_name();
2555 skip_line();
2556 }
2557
2558 static void trapping_blank_line()
2559 {
2560 if (!blank_line_macro_name.is_null())
2561 spring_trap(blank_line_macro_name);
2562 else
2563 blank_line();
2564 }
2565
2566 void do_request()
2567 {
2568 int old_compatible_flag = compatible_flag;
2569 compatible_flag = 0;
2570 symbol nm = get_name();
2571 if (nm.is_null())
2572 skip_line();
2573 else
2574 interpolate_macro(nm);
2575 compatible_flag = old_compatible_flag;
2576 }
2577
2578 inline int possibly_handle_first_page_transition()
2579 {
2580 if (topdiv->before_first_page && curdiv == topdiv && !curenv->is_dummy()) {
2581 handle_first_page_transition();
2582 return 1;
2583 }
2584 else
2585 return 0;
2586 }
2587
2588 static int transparent_translate(int cc)
2589 {
2590 if (!invalid_input_char(cc)) {
2591 charinfo *ci = charset_table[cc];
2592 switch (ci->get_special_translation(1)) {
2593 case charinfo::TRANSLATE_SPACE:
2594 return ' ';
2595 case charinfo::TRANSLATE_STRETCHABLE_SPACE:
2596 return ESCAPE_TILDE;
2597 case charinfo::TRANSLATE_DUMMY:
2598 return ESCAPE_AMPERSAND;
2599 case charinfo::TRANSLATE_HYPHEN_INDICATOR:
2600 return ESCAPE_PERCENT;
2601 }
2602 // This is really ugly.
2603 ci = ci->get_translation(1);
2604 if (ci) {
2605 int c = ci->get_ascii_code();
2606 if (c != '\0')
2607 return c;
2608 error("can't translate %1 to special character `%2'"
2609 " in transparent throughput",
2610 input_char_description(cc),
2611 ci->nm.contents());
2612 }
2613 }
2614 return cc;
2615 }
2616
2617 class int_stack {
2618 struct int_stack_element {
2619 int n;
2620 int_stack_element *next;
2621 } *top;
2622 public:
2623 int_stack();
2624 ~int_stack();
2625 void push(int);
2626 int is_empty();
2627 int pop();
2628 };
2629
2630 int_stack::int_stack()
2631 {
2632 top = 0;
2633 }
2634
2635 int_stack::~int_stack()
2636 {
2637 while (top != 0) {
2638 int_stack_element *temp = top;
2639 top = top->next;
2640 delete temp;
2641 }
2642 }
2643
2644 int int_stack::is_empty()
2645 {
2646 return top == 0;
2647 }
2648
2649 void int_stack::push(int n)
2650 {
2651 int_stack_element *p = new int_stack_element;
2652 p->next = top;
2653 p->n = n;
2654 top = p;
2655 }
2656
2657 int int_stack::pop()
2658 {
2659 assert(top != 0);
2660 int_stack_element *p = top;
2661 top = top->next;
2662 int n = p->n;
2663 delete p;
2664 return n;
2665 }
2666
2667 int node::reread(int *)
2668 {
2669 return 0;
2670 }
2671
2672 int global_diverted_space = 0;
2673
2674 int diverted_space_node::reread(int *bolp)
2675 {
2676 global_diverted_space = 1;
2677 if (curenv->get_fill())
2678 trapping_blank_line();
2679 else
2680 curdiv->space(n);
2681 global_diverted_space = 0;
2682 *bolp = 1;
2683 return 1;
2684 }
2685
2686 int diverted_copy_file_node::reread(int *bolp)
2687 {
2688 curdiv->copy_file(filename.contents());
2689 *bolp = 1;
2690 return 1;
2691 }
2692
2693 int word_space_node::reread(int *)
2694 {
2695 if (unformat) {
2696 for (width_list *w = orig_width; w; w = w->next)
2697 curenv->space(w->width, w->sentence_width);
2698 unformat = 0;
2699 return 1;
2700 }
2701 return 0;
2702 }
2703
2704 int unbreakable_space_node::reread(int *)
2705 {
2706 return 0;
2707 }
2708
2709 int hmotion_node::reread(int *)
2710 {
2711 if (unformat && was_tab) {
2712 curenv->handle_tab(0);
2713 unformat = 0;
2714 return 1;
2715 }
2716 return 0;
2717 }
2718
2719 void process_input_stack()
2720 {
2721 int_stack trap_bol_stack;
2722 int bol = 1;
2723 for (;;) {
2724 int suppress_next = 0;
2725 switch (tok.type) {
2726 case token::TOKEN_CHAR:
2727 {
2728 unsigned char ch = tok.c;
2729 if (bol && !have_input
2730 && (ch == curenv->control_char
2731 || ch == curenv->no_break_control_char)) {
2732 break_flag = ch == curenv->control_char;
2733 // skip tabs as well as spaces here
2734 do {
2735 tok.next();
2736 } while (tok.white_space());
2737 symbol nm = get_name();
2738 #if defined(DEBUGGING)
2739 if (debug_state) {
2740 if (! nm.is_null()) {
2741 if (strcmp(nm.contents(), "test") == 0) {
2742 fprintf(stderr, "found it!\n");
2743 fflush(stderr);
2744 }
2745 fprintf(stderr, "interpreting [%s]", nm.contents());
2746 if (strcmp(nm.contents(), "di") == 0 && topdiv != curdiv)
2747 fprintf(stderr, " currently in diversion: %s",
2748 curdiv->get_diversion_name());
2749 fprintf(stderr, "\n");
2750 fflush(stderr);
2751 }
2752 }
2753 #endif
2754 if (nm.is_null())
2755 skip_line();
2756 else {
2757 interpolate_macro(nm);
2758 #if defined(DEBUGGING)
2759 if (debug_state) {
2760 fprintf(stderr, "finished interpreting [%s] and environment state is\n", nm.contents());
2761 curenv->dump_troff_state();
2762 }
2763 #endif
2764 }
2765 suppress_next = 1;
2766 }
2767 else {
2768 if (possibly_handle_first_page_transition())
2769 ;
2770 else {
2771 for (;;) {
2772 #if defined(DEBUGGING)
2773 if (debug_state) {
2774 fprintf(stderr, "found [%c]\n", ch); fflush(stderr);
2775 }
2776 #endif
2777 curenv->add_char(charset_table[ch]);
2778 tok.next();
2779 if (tok.type != token::TOKEN_CHAR)
2780 break;
2781 ch = tok.c;
2782 }
2783 suppress_next = 1;
2784 bol = 0;
2785 }
2786 }
2787 break;
2788 }
2789 case token::TOKEN_TRANSPARENT:
2790 {
2791 if (bol) {
2792 if (possibly_handle_first_page_transition())
2793 ;
2794 else {
2795 int cc;
2796 do {
2797 node *n;
2798 cc = get_copy(&n);
2799 if (cc != EOF)
2800 if (cc != '\0')
2801 curdiv->transparent_output(transparent_translate(cc));
2802 else
2803 curdiv->transparent_output(n);
2804 } while (cc != '\n' && cc != EOF);
2805 if (cc == EOF)
2806 curdiv->transparent_output('\n');
2807 }
2808 }
2809 break;
2810 }
2811 case token::TOKEN_NEWLINE:
2812 {
2813 if (bol && !old_have_input
2814 && !curenv->get_prev_line_interrupted())
2815 trapping_blank_line();
2816 else {
2817 curenv->newline();
2818 bol = 1;
2819 }
2820 break;
2821 }
2822 case token::TOKEN_REQUEST:
2823 {
2824 int request_code = tok.c;
2825 tok.next();
2826 switch (request_code) {
2827 case TITLE_REQUEST:
2828 title();
2829 break;
2830 case COPY_FILE_REQUEST:
2831 copy_file();
2832 break;
2833 case TRANSPARENT_FILE_REQUEST:
2834 transparent_file();
2835 break;
2836 #ifdef COLUMN
2837 case VJUSTIFY_REQUEST:
2838 vjustify();
2839 break;
2840 #endif /* COLUMN */
2841 default:
2842 assert(0);
2843 break;
2844 }
2845 suppress_next = 1;
2846 break;
2847 }
2848 case token::TOKEN_SPACE:
2849 {
2850 if (possibly_handle_first_page_transition())
2851 ;
2852 else if (bol && !curenv->get_prev_line_interrupted()) {
2853 int nspaces = 0;
2854 // save space_width now so that it isn't changed by \f or \s
2855 // which we wouldn't notice here
2856 hunits space_width = curenv->get_space_width();
2857 do {
2858 nspaces += tok.nspaces();
2859 tok.next();
2860 } while (tok.space());
2861 if (tok.newline())
2862 trapping_blank_line();
2863 else {
2864 push_token(tok);
2865 curenv->do_break();
2866 curenv->add_node(new hmotion_node(space_width * nspaces,
2867 curenv->get_fill_color()));
2868 bol = 0;
2869 }
2870 }
2871 else {
2872 curenv->space();
2873 bol = 0;
2874 }
2875 break;
2876 }
2877 case token::TOKEN_EOF:
2878 return;
2879 case token::TOKEN_NODE:
2880 {
2881 if (possibly_handle_first_page_transition())
2882 ;
2883 else if (tok.nd->reread(&bol)) {
2884 delete tok.nd;
2885 tok.nd = 0;
2886 }
2887 else {
2888 curenv->add_node(tok.nd);
2889 tok.nd = 0;
2890 bol = 0;
2891 curenv->possibly_break_line(1);
2892 }
2893 break;
2894 }
2895 case token::TOKEN_PAGE_EJECTOR:
2896 {
2897 continue_page_eject();
2898 // I think we just want to preserve bol.
2899 // bol = 1;
2900 break;
2901 }
2902 case token::TOKEN_BEGIN_TRAP:
2903 {
2904 trap_bol_stack.push(bol);
2905 bol = 1;
2906 have_input = 0;
2907 break;
2908 }
2909 case token::TOKEN_END_TRAP:
2910 {
2911 if (trap_bol_stack.is_empty())
2912 error("spurious end trap token detected!");
2913 else
2914 bol = trap_bol_stack.pop();
2915 have_input = 0;
2916
2917 /* I'm not totally happy about this. But I can't think of any other
2918 way to do it. Doing an output_pending_lines() whenever a
2919 TOKEN_END_TRAP is detected doesn't work: for example,
2920
2921 .wh -1i x
2922 .de x
2923 'bp
2924 ..
2925 .wh -.5i y
2926 .de y
2927 .tl ''-%-''
2928 ..
2929 .br
2930 .ll .5i
2931 .sp |\n(.pu-1i-.5v
2932 a\%very\%very\%long\%word
2933
2934 will print all but the first lines from the word immediately
2935 after the footer, rather than on the next page. */
2936
2937 if (trap_bol_stack.is_empty())
2938 curenv->output_pending_lines();
2939 break;
2940 }
2941 default:
2942 {
2943 bol = 0;
2944 tok.process();
2945 break;
2946 }
2947 }
2948 if (!suppress_next)
2949 tok.next();
2950 trap_sprung_flag = 0;
2951 }
2952 }
2953
2954 #ifdef WIDOW_CONTROL
2955
2956 void flush_pending_lines()
2957 {
2958 while (!tok.newline() && !tok.eof())
2959 tok.next();
2960 curenv->output_pending_lines();
2961 tok.next();
2962 }
2963
2964 #endif /* WIDOW_CONTROL */
2965
2966 request_or_macro::request_or_macro()
2967 {
2968 }
2969
2970 macro *request_or_macro::to_macro()
2971 {
2972 return 0;
2973 }
2974
2975 request::request(REQUEST_FUNCP pp) : p(pp)
2976 {
2977 }
2978
2979 void request::invoke(symbol)
2980 {
2981 (*p)();
2982 }
2983
2984 struct char_block {
2985 enum { SIZE = 128 };
2986 unsigned char s[SIZE];
2987 char_block *next;
2988 char_block();
2989 };
2990
2991 char_block::char_block()
2992 : next(0)
2993 {
2994 }
2995
2996 class char_list {
2997 public:
2998 char_list();
2999 ~char_list();
3000 void append(unsigned char);
3001 void set(unsigned char, int);
3002 unsigned char get(int);
3003 int length();
3004 private:
3005 unsigned char *ptr;
3006 int len;
3007 char_block *head;
3008 char_block *tail;
3009 friend class macro_header;
3010 friend class string_iterator;
3011 };
3012
3013 char_list::char_list()
3014 : ptr(0), len(0), head(0), tail(0)
3015 {
3016 }
3017
3018 char_list::~char_list()
3019 {
3020 while (head != 0) {
3021 char_block *tem = head;
3022 head = head->next;
3023 delete tem;
3024 }
3025 }
3026
3027 int char_list::length()
3028 {
3029 return len;
3030 }
3031
3032 void char_list::append(unsigned char c)
3033 {
3034 if (tail == 0) {
3035 head = tail = new char_block;
3036 ptr = tail->s;
3037 }
3038 else {
3039 if (ptr >= tail->s + char_block::SIZE) {
3040 tail->next = new char_block;
3041 tail = tail->next;
3042 ptr = tail->s;
3043 }
3044 }
3045 *ptr++ = c;
3046 len++;
3047 }
3048
3049 void char_list::set(unsigned char c, int offset)
3050 {
3051 assert(len > offset);
3052 // optimization for access at the end
3053 int boundary = len - len % char_block::SIZE;
3054 if (offset >= boundary) {
3055 *(tail->s + offset - boundary) = c;
3056 return;
3057 }
3058 char_block *tem = head;
3059 int l = 0;
3060 for (;;) {
3061 l += char_block::SIZE;
3062 if (l > offset) {
3063 *(tem->s + offset % char_block::SIZE) = c;
3064 return;
3065 }
3066 tem = tem->next;
3067 }
3068 }
3069
3070 unsigned char char_list::get(int offset)
3071 {
3072 assert(len > offset);
3073 // optimization for access at the end
3074 int boundary = len - len % char_block::SIZE;
3075 if (offset >= boundary)
3076 return *(tail->s + offset - boundary);
3077 char_block *tem = head;
3078 int l = 0;
3079 for (;;) {
3080 l += char_block::SIZE;
3081 if (l > offset)
3082 return *(tem->s + offset % char_block::SIZE);
3083 tem = tem->next;
3084 }
3085 }
3086
3087 class node_list {
3088 node *head;
3089 node *tail;
3090 public:
3091 node_list();
3092 ~node_list();
3093 void append(node *);
3094 int length();
3095 node *extract();
3096
3097 friend class macro_header;
3098 friend class string_iterator;
3099 };
3100
3101 void node_list::append(node *n)
3102 {
3103 if (head == 0) {
3104 n->next = 0;
3105 head = tail = n;
3106 }
3107 else {
3108 n->next = 0;
3109 tail = tail->next = n;
3110 }
3111 }
3112
3113 int node_list::length()
3114 {
3115 int total = 0;
3116 for (node *n = head; n != 0; n = n->next)
3117 ++total;
3118 return total;
3119 }
3120
3121 node_list::node_list()
3122 {
3123 head = tail = 0;
3124 }
3125
3126 node *node_list::extract()
3127 {
3128 node *temp = head;
3129 head = tail = 0;
3130 return temp;
3131 }
3132
3133 node_list::~node_list()
3134 {
3135 delete_node_list(head);
3136 }
3137
3138 class macro_header {
3139 public:
3140 int count;
3141 char_list cl;
3142 node_list nl;
3143 macro_header() { count = 1; }
3144 macro_header *copy(int);
3145 };
3146
3147 macro::~macro()
3148 {
3149 if (p != 0 && --(p->count) <= 0)
3150 delete p;
3151 }
3152
3153 macro::macro()
3154 : is_a_diversion(0)
3155 {
3156 if (!input_stack::get_location(1, &filename, &lineno)) {
3157 filename = 0;
3158 lineno = 0;
3159 }
3160 len = 0;
3161 empty_macro = 1;
3162 p = 0;
3163 }
3164
3165 macro::macro(const macro &m)
3166 : filename(m.filename), lineno(m.lineno), len(m.len),
3167 empty_macro(m.empty_macro), is_a_diversion(m.is_a_diversion), p(m.p)
3168 {
3169 if (p != 0)
3170 p->count++;
3171 }
3172
3173 macro::macro(int is_div)
3174 : is_a_diversion(is_div)
3175 {
3176 if (!input_stack::get_location(1, &filename, &lineno)) {
3177 filename = 0;
3178 lineno = 0;
3179 }
3180 len = 0;
3181 empty_macro = 1;
3182 p = 0;
3183 }
3184
3185 int macro::is_diversion()
3186 {
3187 return is_a_diversion;
3188 }
3189
3190 macro &macro::operator=(const macro &m)
3191 {
3192 // don't assign object
3193 if (m.p != 0)
3194 m.p->count++;
3195 if (p != 0 && --(p->count) <= 0)
3196 delete p;
3197 p = m.p;
3198 filename = m.filename;
3199 lineno = m.lineno;
3200 len = m.len;
3201 empty_macro = m.empty_macro;
3202 is_a_diversion = m.is_a_diversion;
3203 return *this;
3204 }
3205
3206 void macro::append(unsigned char c)
3207 {
3208 assert(c != 0);
3209 if (p == 0)
3210 p = new macro_header;
3211 if (p->cl.length() != len) {
3212 macro_header *tem = p->copy(len);
3213 if (--(p->count) <= 0)
3214 delete p;
3215 p = tem;
3216 }
3217 p->cl.append(c);
3218 ++len;
3219 if (c != PUSH_GROFF_MODE && c != PUSH_COMP_MODE && c != POP_GROFFCOMP_MODE)
3220 empty_macro = 0;
3221 }
3222
3223 void macro::set(unsigned char c, int offset)
3224 {
3225 assert(p != 0);
3226 assert(c != 0);
3227 p->cl.set(c, offset);
3228 }
3229
3230 unsigned char macro::get(int offset)
3231 {
3232 assert(p != 0);
3233 return p->cl.get(offset);
3234 }
3235
3236 int macro::length()
3237 {
3238 return len;
3239 }
3240
3241 void macro::append_str(const char *s)
3242 {
3243 int i = 0;
3244
3245 if (s) {
3246 while (s[i] != (char)0) {
3247 append(s[i]);
3248 i++;
3249 }
3250 }
3251 }
3252
3253 void macro::append(node *n)
3254 {
3255 assert(n != 0);
3256 if (p == 0)
3257 p = new macro_header;
3258 if (p->cl.length() != len) {
3259 macro_header *tem = p->copy(len);
3260 if (--(p->count) <= 0)
3261 delete p;
3262 p = tem;
3263 }
3264 p->cl.append(0);
3265 p->nl.append(n);
3266 ++len;
3267 empty_macro = 0;
3268 }
3269
3270 void macro::append_unsigned(unsigned int i)
3271 {
3272 unsigned int j = i / 10;
3273 if (j != 0)
3274 append_unsigned(j);
3275 append(((unsigned char)(((int)'0') + i % 10)));
3276 }
3277
3278 void macro::append_int(int i)
3279 {
3280 if (i < 0) {
3281 append('-');
3282 i = -i;
3283 }
3284 append_unsigned((unsigned int)i);
3285 }
3286
3287 void macro::print_size()
3288 {
3289 errprint("%1", len);
3290 }
3291
3292 // make a copy of the first n bytes
3293
3294 macro_header *macro_header::copy(int n)
3295 {
3296 macro_header *p = new macro_header;
3297 char_block *bp = cl.head;
3298 unsigned char *ptr = bp->s;
3299 node *nd = nl.head;
3300 while (--n >= 0) {
3301 if (ptr >= bp->s + char_block::SIZE) {
3302 bp = bp->next;
3303 ptr = bp->s;
3304 }
3305 unsigned char c = *ptr++;
3306 p->cl.append(c);
3307 if (c == 0) {
3308 p->nl.append(nd->copy());
3309 nd = nd->next;
3310 }
3311 }
3312 return p;
3313 }
3314
3315 void print_macros()
3316 {
3317 object_dictionary_iterator iter(request_dictionary);
3318 request_or_macro *rm;
3319 symbol s;
3320 while (iter.get(&s, (object **)&rm)) {
3321 assert(!s.is_null());
3322 macro *m = rm->to_macro();
3323 if (m) {
3324 errprint("%1\t", s.contents());
3325 m->print_size();
3326 errprint("\n");
3327 }
3328 }
3329 fflush(stderr);
3330 skip_line();
3331 }
3332
3333 class string_iterator : public input_iterator {
3334 macro mac;
3335 const char *how_invoked;
3336 int newline_flag;
3337 int lineno;
3338 char_block *bp;
3339 int count; // of characters remaining
3340 node *nd;
3341 int saved_compatible_flag;
3342 protected:
3343 symbol nm;
3344 string_iterator();
3345 public:
3346 string_iterator(const macro &m, const char *p = 0, symbol s = NULL_SYMBOL);
3347 int fill(node **);
3348 int peek();
3349 int get_location(int, const char **, int *);
3350 void backtrace();
3351 void save_compatible_flag(int f) { saved_compatible_flag = f; }
3352 int get_compatible_flag() { return saved_compatible_flag; }
3353 int is_diversion();
3354 };
3355
3356 string_iterator::string_iterator(const macro &m, const char *p, symbol s)
3357 : input_iterator(m.is_a_diversion), mac(m), how_invoked(p), newline_flag(0),
3358 lineno(1), nm(s)
3359 {
3360 count = mac.len;
3361 if (count != 0) {
3362 bp = mac.p->cl.head;
3363 nd = mac.p->nl.head;
3364 ptr = eptr = bp->s;
3365 }
3366 else {
3367 bp = 0;
3368 nd = 0;
3369 ptr = eptr = 0;
3370 }
3371 }
3372
3373 string_iterator::string_iterator()
3374 {
3375 bp = 0;
3376 nd = 0;
3377 ptr = eptr = 0;
3378 newline_flag = 0;
3379 how_invoked = 0;
3380 lineno = 1;
3381 count = 0;
3382 }
3383
3384 int string_iterator::is_diversion()
3385 {
3386 return mac.is_diversion();
3387 }
3388
3389 int string_iterator::fill(node **np)
3390 {
3391 if (newline_flag)
3392 lineno++;
3393 newline_flag = 0;
3394 if (count <= 0)
3395 return EOF;
3396 const unsigned char *p = eptr;
3397 if (p >= bp->s + char_block::SIZE) {
3398 bp = bp->next;
3399 p = bp->s;
3400 }
3401 if (*p == '\0') {
3402 if (np) {
3403 *np = nd->copy();
3404 if (is_diversion())
3405 (*np)->div_nest_level = input_stack::get_div_level();
3406 else
3407 (*np)->div_nest_level = 0;
3408 }
3409 nd = nd->next;
3410 eptr = ptr = p + 1;
3411 count--;
3412 return 0;
3413 }
3414 const unsigned char *e = bp->s + char_block::SIZE;
3415 if (e - p > count)
3416 e = p + count;
3417 ptr = p;
3418 while (p < e) {
3419 unsigned char c = *p;
3420 if (c == '\n' || c == ESCAPE_NEWLINE) {
3421 newline_flag = 1;
3422 p++;
3423 break;
3424 }
3425 if (c == '\0')
3426 break;
3427 p++;
3428 }
3429 eptr = p;
3430 count -= p - ptr;
3431 return *ptr++;
3432 }
3433
3434 int string_iterator::peek()
3435 {
3436 if (count <= 0)
3437 return EOF;
3438 const unsigned char *p = eptr;
3439 if (p >= bp->s + char_block::SIZE) {
3440 p = bp->next->s;
3441 }
3442 return *p;
3443 }
3444
3445 int string_iterator::get_location(int allow_macro,
3446 const char **filep, int *linep)
3447 {
3448 if (!allow_macro)
3449 return 0;
3450 if (mac.filename == 0)
3451 return 0;
3452 *filep = mac.filename;
3453 *linep = mac.lineno + lineno - 1;
3454 return 1;
3455 }
3456
3457 void string_iterator::backtrace()
3458 {
3459 if (mac.filename) {
3460 errprint("%1:%2: backtrace", mac.filename, mac.lineno + lineno - 1);
3461 if (how_invoked) {
3462 if (!nm.is_null())
3463 errprint(": %1 `%2'\n", how_invoked, nm.contents());
3464 else
3465 errprint(": %1\n", how_invoked);
3466 }
3467 else
3468 errprint("\n");
3469 }
3470 }
3471
3472 class temp_iterator : public input_iterator {
3473 unsigned char *base;
3474 temp_iterator(const char *, int len);
3475 public:
3476 ~temp_iterator();
3477 friend input_iterator *make_temp_iterator(const char *);
3478 };
3479
3480 #ifdef __GNUG__
3481 inline
3482 #endif
3483 temp_iterator::temp_iterator(const char *s, int len)
3484 {
3485 base = new unsigned char[len];
3486 memcpy(base, s, len);
3487 ptr = base;
3488 eptr = base + len;
3489 }
3490
3491 temp_iterator::~temp_iterator()
3492 {
3493 a_delete base;
3494 }
3495
3496 class small_temp_iterator : public input_iterator {
3497 private:
3498 small_temp_iterator(const char *, int);
3499 ~small_temp_iterator();
3500 enum { BLOCK = 16 };
3501 static small_temp_iterator *free_list;
3502 void *operator new(size_t);
3503 void operator delete(void *);
3504 enum { SIZE = 12 };
3505 unsigned char buf[SIZE];
3506 friend input_iterator *make_temp_iterator(const char *);
3507 };
3508
3509 small_temp_iterator *small_temp_iterator::free_list = 0;
3510
3511 void *small_temp_iterator::operator new(size_t n)
3512 {
3513 assert(n == sizeof(small_temp_iterator));
3514 if (!free_list) {
3515 free_list =
3516 (small_temp_iterator *)new char[sizeof(small_temp_iterator)*BLOCK];
3517 for (int i = 0; i < BLOCK - 1; i++)
3518 free_list[i].next = free_list + i + 1;
3519 free_list[BLOCK-1].next = 0;
3520 }
3521 small_temp_iterator *p = free_list;
3522 free_list = (small_temp_iterator *)(free_list->next);
3523 p->next = 0;
3524 return p;
3525 }
3526
3527 #ifdef __GNUG__
3528 inline
3529 #endif
3530 void small_temp_iterator::operator delete(void *p)
3531 {
3532 if (p) {
3533 ((small_temp_iterator *)p)->next = free_list;
3534 free_list = (small_temp_iterator *)p;
3535 }
3536 }
3537
3538 small_temp_iterator::~small_temp_iterator()
3539 {
3540 }
3541
3542 #ifdef __GNUG__
3543 inline
3544 #endif
3545 small_temp_iterator::small_temp_iterator(const char *s, int len)
3546 {
3547 for (int i = 0; i < len; i++)
3548 buf[i] = s[i];
3549 ptr = buf;
3550 eptr = buf + len;
3551 }
3552
3553 input_iterator *make_temp_iterator(const char *s)
3554 {
3555 if (s == 0)
3556 return new small_temp_iterator(s, 0);
3557 else {
3558 int n = strlen(s);
3559 if (n <= small_temp_iterator::SIZE)
3560 return new small_temp_iterator(s, n);
3561 else
3562 return new temp_iterator(s, n);
3563 }
3564 }
3565
3566 // this is used when macros with arguments are interpolated
3567
3568 struct arg_list {
3569 macro mac;
3570 arg_list *next;
3571 arg_list(const macro &);
3572 ~arg_list();
3573 };
3574
3575 arg_list::arg_list(const macro &m) : mac(m), next(0)
3576 {
3577 }
3578
3579 arg_list::~arg_list()
3580 {
3581 }
3582
3583 class macro_iterator : public string_iterator {
3584 arg_list *args;
3585 int argc;
3586 public:
3587 macro_iterator(symbol, macro &, const char *how_invoked = "macro");
3588 macro_iterator();
3589 ~macro_iterator();
3590 int has_args() { return 1; }
3591 input_iterator *get_arg(int i);
3592 int nargs() { return argc; }
3593 void add_arg(const macro &m);
3594 void shift(int n);
3595 int is_macro() { return 1; }
3596 int is_diversion();
3597 };
3598
3599 input_iterator *macro_iterator::get_arg(int i)
3600 {
3601 if (i == 0)
3602 return make_temp_iterator(nm.contents());
3603 if (i > 0 && i <= argc) {
3604 arg_list *p = args;
3605 for (int j = 1; j < i; j++) {
3606 assert(p != 0);
3607 p = p->next;
3608 }
3609 return new string_iterator(p->mac);
3610 }
3611 else
3612 return 0;
3613 }
3614
3615 void macro_iterator::add_arg(const macro &m)
3616 {
3617 arg_list **p;
3618 for (p = &args; *p; p = &((*p)->next))
3619 ;
3620 *p = new arg_list(m);
3621 ++argc;
3622 }
3623
3624 void macro_iterator::shift(int n)
3625 {
3626 while (n > 0 && argc > 0) {
3627 arg_list *tem = args;
3628 args = args->next;
3629 delete tem;
3630 --argc;
3631 --n;
3632 }
3633 }
3634
3635 // This gets used by eg .if '\?xxx\?''.
3636
3637 int operator==(const macro &m1, const macro &m2)
3638 {
3639 if (m1.len != m2.len)
3640 return 0;
3641 string_iterator iter1(m1);
3642 string_iterator iter2(m2);
3643 int n = m1.len;
3644 while (--n >= 0) {
3645 node *nd1 = 0;
3646 int c1 = iter1.get(&nd1);
3647 assert(c1 != EOF);
3648 node *nd2 = 0;
3649 int c2 = iter2.get(&nd2);
3650 assert(c2 != EOF);
3651 if (c1 != c2) {
3652 if (c1 == 0)
3653 delete nd1;
3654 else if (c2 == 0)
3655 delete nd2;
3656 return 0;
3657 }
3658 if (c1 == 0) {
3659 assert(nd1 != 0);
3660 assert(nd2 != 0);
3661 int are_same = nd1->type() == nd2->type() && nd1->same(nd2);
3662 delete nd1;
3663 delete nd2;
3664 if (!are_same)
3665 return 0;
3666 }
3667 }
3668 return 1;
3669 }
3670
3671 static void interpolate_macro(symbol nm)
3672 {
3673 request_or_macro *p = (request_or_macro *)request_dictionary.lookup(nm);
3674 if (p == 0) {
3675 int warned = 0;
3676 const char *s = nm.contents();
3677 if (strlen(s) > 2) {
3678 request_or_macro *r;
3679 char buf[3];
3680 buf[0] = s[0];
3681 buf[1] = s[1];
3682 buf[2] = '\0';
3683 r = (request_or_macro *)request_dictionary.lookup(symbol(buf));
3684 if (r) {
3685 macro *m = r->to_macro();
3686 if (!m || !m->empty())
3687 warned = warning(WARN_SPACE,
3688 "macro `%1' not defined "
3689 "(probably missing space after `%2')",
3690 nm.contents(), buf);
3691 }
3692 }
3693 if (!warned) {
3694 warning(WARN_MAC, "macro `%1' not defined", nm.contents());
3695 p = new macro;
3696 request_dictionary.define(nm, p);
3697 }
3698 }
3699 if (p)
3700 p->invoke(nm);
3701 else {
3702 skip_line();
3703 return;
3704 }
3705 }
3706
3707 static void decode_args(macro_iterator *mi)
3708 {
3709 if (!tok.newline() && !tok.eof()) {
3710 node *n;
3711 int c = get_copy(&n);
3712 for (;;) {
3713 while (c == ' ')
3714 c = get_copy(&n);
3715 if (c == '\n' || c == EOF)
3716 break;
3717 macro arg;
3718 int quote_input_level = 0;
3719 int done_tab_warning = 0;
3720 if (c == '"') {
3721 quote_input_level = input_stack::get_level();
3722 c = get_copy(&n);
3723 }
3724 arg.append(compatible_flag ? PUSH_COMP_MODE : PUSH_GROFF_MODE);
3725 while (c != EOF && c != '\n' && !(c == ' ' && quote_input_level == 0)) {
3726 if (quote_input_level > 0 && c == '"'
3727 && (compatible_flag
3728 || input_stack::get_level() == quote_input_level)) {
3729 c = get_copy(&n);
3730 if (c == '"') {
3731 arg.append(c);
3732 c = get_copy(&n);
3733 }
3734 else
3735 break;
3736 }
3737 else {
3738 if (c == 0)
3739 arg.append(n);
3740 else {
3741 if (c == '\t' && quote_input_level == 0 && !done_tab_warning) {
3742 warning(WARN_TAB, "tab character in unquoted macro argument");
3743 done_tab_warning = 1;
3744 }
3745 arg.append(c);
3746 }
3747 c = get_copy(&n);
3748 }
3749 }
3750 arg.append(POP_GROFFCOMP_MODE);
3751 mi->add_arg(arg);
3752 }
3753 }
3754 }
3755
3756 static void decode_string_args(macro_iterator *mi)
3757 {
3758 node *n;
3759 int c = get_copy(&n);
3760 for (;;) {
3761 while (c == ' ')
3762 c = get_copy(&n);
3763 if (c == '\n' || c == EOF) {
3764 error("missing `]'");
3765 break;
3766 }
3767 if (c == ']')
3768 break;
3769 macro arg;
3770 int quote_input_level = 0;
3771 int done_tab_warning = 0;
3772 if (c == '"') {
3773 quote_input_level = input_stack::get_level();
3774 c = get_copy(&n);
3775 }
3776 while (c != EOF && c != '\n'
3777 && !(c == ']' && quote_input_level == 0)
3778 && !(c == ' ' && quote_input_level == 0)) {
3779 if (quote_input_level > 0 && c == '"'
3780 && input_stack::get_level() == quote_input_level) {
3781 c = get_copy(&n);
3782 if (c == '"') {
3783 arg.append(c);
3784 c = get_copy(&n);
3785 }
3786 else
3787 break;
3788 }
3789 else {
3790 if (c == 0)
3791 arg.append(n);
3792 else {
3793 if (c == '\t' && quote_input_level == 0 && !done_tab_warning) {
3794 warning(WARN_TAB, "tab character in unquoted string argument");
3795 done_tab_warning = 1;
3796 }
3797 arg.append(c);
3798 }
3799 c = get_copy(&n);
3800 }
3801 }
3802 mi->add_arg(arg);
3803 }
3804 }
3805
3806 void macro::invoke(symbol nm)
3807 {
3808 macro_iterator *mi = new macro_iterator(nm, *this);
3809 decode_args(mi);
3810 input_stack::push(mi);
3811 tok.next();
3812 }
3813
3814 macro *macro::to_macro()
3815 {
3816 return this;
3817 }
3818
3819 int macro::empty()
3820 {
3821 return empty_macro == 1;
3822 }
3823
3824 macro_iterator::macro_iterator(symbol s, macro &m, const char *how_called)
3825 : string_iterator(m, how_called, s), args(0), argc(0)
3826 {
3827 }
3828
3829 macro_iterator::macro_iterator() : args(0), argc(0)
3830 {
3831 }
3832
3833 macro_iterator::~macro_iterator()
3834 {
3835 while (args != 0) {
3836 arg_list *tem = args;
3837 args = args->next;
3838 delete tem;
3839 }
3840 }
3841
3842 dictionary composite_dictionary(17);
3843
3844 void composite_request()
3845 {
3846 symbol from = get_name(1);
3847 if (!from.is_null()) {
3848 const char *from_gn = glyph_name_to_unicode(from.contents());
3849 if (!from_gn) {
3850 from_gn = check_unicode_name(from.contents());
3851 if (!from_gn) {
3852 error("invalid composite glyph name `%1'", from.contents());
3853 skip_line();
3854 return;
3855 }
3856 }
3857 const char *from_decomposed = decompose_unicode(from_gn);
3858 if (from_decomposed)
3859 from_gn = &from_decomposed[1];
3860 symbol to = get_name(1);
3861 if (to.is_null())
3862 composite_dictionary.remove(symbol(from_gn));
3863 else {
3864 const char *to_gn = glyph_name_to_unicode(to.contents());
3865 if (!to_gn) {
3866 to_gn = check_unicode_name(to.contents());
3867 if (!to_gn) {
3868 error("invalid composite glyph name `%1'", to.contents());
3869 skip_line();
3870 return;
3871 }
3872 }
3873 const char *to_decomposed = decompose_unicode(to_gn);
3874 if (to_decomposed)
3875 to_gn = &to_decomposed[1];
3876 if (strcmp(from_gn, to_gn) == 0)
3877 composite_dictionary.remove(symbol(from_gn));
3878 else
3879 (void)composite_dictionary.lookup(symbol(from_gn), (void *)to_gn);
3880 }
3881 }
3882 skip_line();
3883 }
3884
3885 static symbol composite_glyph_name(symbol nm)
3886 {
3887 macro_iterator *mi = new macro_iterator();
3888 decode_string_args(mi);
3889 input_stack::push(mi);
3890 const char *gn = glyph_name_to_unicode(nm.contents());
3891 if (!gn) {
3892 gn = check_unicode_name(nm.contents());
3893 if (!gn) {
3894 error("invalid base glyph `%1' in composite glyph name", nm.contents());
3895 return EMPTY_SYMBOL;
3896 }
3897 }
3898 const char *gn_decomposed = decompose_unicode(gn);
3899 string glyph_name(gn_decomposed ? &gn_decomposed[1] : gn);
3900 string gl;
3901 int n = input_stack::nargs();
3902 for (int i = 1; i <= n; i++) {
3903 glyph_name += '_';
3904 input_iterator *p = input_stack::get_arg(i);
3905 gl.clear();
3906 int c;
3907 while ((c = p->get(0)) != EOF)
3908 gl += c;
3909 gl += '\0';
3910 const char *u = glyph_name_to_unicode(gl.contents());
3911 if (!u) {
3912 u = check_unicode_name(gl.contents());
3913 if (!u) {
3914 error("invalid component `%1' in composite glyph name",
3915 gl.contents());
3916 return EMPTY_SYMBOL;
3917 }
3918 }
3919 const char *decomposed = decompose_unicode(u);
3920 if (decomposed)
3921 u = &decomposed[1];
3922 void *mapped_composite = composite_dictionary.lookup(symbol(u));
3923 if (mapped_composite)
3924 u = (const char *)mapped_composite;
3925 glyph_name += u;
3926 }
3927 glyph_name += '\0';
3928 const char *groff_gn = unicode_to_glyph_name(glyph_name.contents());
3929 if (groff_gn)
3930 return symbol(groff_gn);
3931 gl.clear();
3932 gl += 'u';
3933 gl += glyph_name;
3934 return symbol(gl.contents());
3935 }
3936
3937 int trap_sprung_flag = 0;
3938 int postpone_traps_flag = 0;
3939 symbol postponed_trap;
3940
3941 void spring_trap(symbol nm)
3942 {
3943 assert(!nm.is_null());
3944 trap_sprung_flag = 1;
3945 if (postpone_traps_flag) {
3946 postponed_trap = nm;
3947 return;
3948 }
3949 static char buf[2] = { BEGIN_TRAP, 0 };
3950 static char buf2[2] = { END_TRAP, '\0' };
3951 input_stack::push(make_temp_iterator(buf2));
3952 request_or_macro *p = lookup_request(nm);
3953 macro *m = p->to_macro();
3954 if (m)
3955 input_stack::push(new macro_iterator(nm, *m, "trap-invoked macro"));
3956 else
3957 error("you can't invoke a request with a trap");
3958 input_stack::push(make_temp_iterator(buf));
3959 }
3960
3961 void postpone_traps()
3962 {
3963 postpone_traps_flag = 1;
3964 }
3965
3966 int unpostpone_traps()
3967 {
3968 postpone_traps_flag = 0;
3969 if (!postponed_trap.is_null()) {
3970 spring_trap(postponed_trap);
3971 postponed_trap = NULL_SYMBOL;
3972 return 1;
3973 }
3974 else
3975 return 0;
3976 }
3977
3978 void read_request()
3979 {
3980 macro_iterator *mi = new macro_iterator;
3981 int reading_from_terminal = isatty(fileno(stdin));
3982 int had_prompt = 0;
3983 if (!tok.newline() && !tok.eof()) {
3984 int c = get_copy(0);
3985 while (c == ' ')
3986 c = get_copy(0);
3987 while (c != EOF && c != '\n' && c != ' ') {
3988 if (!invalid_input_char(c)) {
3989 if (reading_from_terminal)
3990 fputc(c, stderr);
3991 had_prompt = 1;
3992 }
3993 c = get_copy(0);
3994 }
3995 if (c == ' ') {
3996 tok.make_space();
3997 decode_args(mi);
3998 }
3999 }
4000 if (reading_from_terminal) {
4001 fputc(had_prompt ? ':' : '\a', stderr);
4002 fflush(stderr);
4003 }
4004 input_stack::push(mi);
4005 macro mac;
4006 int nl = 0;
4007 int c;
4008 while ((c = getchar()) != EOF) {
4009 if (invalid_input_char(c))
4010 warning(WARN_INPUT, "invalid input character code %1", int(c));
4011 else {
4012 if (c == '\n') {
4013 if (nl)
4014 break;
4015 else
4016 nl = 1;
4017 }
4018 else
4019 nl = 0;
4020 mac.append(c);
4021 }
4022 }
4023 if (reading_from_terminal)
4024 clearerr(stdin);
4025 input_stack::push(new string_iterator(mac));
4026 tok.next();
4027 }
4028
4029 enum define_mode { DEFINE_NORMAL, DEFINE_APPEND, DEFINE_IGNORE };
4030 enum calling_mode { CALLING_NORMAL, CALLING_INDIRECT };
4031 enum comp_mode { COMP_IGNORE, COMP_DISABLE, COMP_ENABLE };
4032
4033 void do_define_string(define_mode mode, comp_mode comp)
4034 {
4035 symbol nm;
4036 node *n = 0; // pacify compiler
4037 int c;
4038 nm = get_name(1);
4039 if (nm.is_null()) {
4040 skip_line();
4041 return;
4042 }
4043 if (tok.newline())
4044 c = '\n';
4045 else if (tok.tab())
4046 c = '\t';
4047 else if (!tok.space()) {
4048 error("bad string definition");
4049 skip_line();
4050 return;
4051 }
4052 else
4053 c = get_copy(&n);
4054 while (c == ' ')
4055 c = get_copy(&n);
4056 if (c == '"')
4057 c = get_copy(&n);
4058 macro mac;
4059 request_or_macro *rm = (request_or_macro *)request_dictionary.lookup(nm);
4060 macro *mm = rm ? rm->to_macro() : 0;
4061 if (mode == DEFINE_APPEND && mm)
4062 mac = *mm;
4063 if (comp == COMP_DISABLE)
4064 mac.append(PUSH_GROFF_MODE);
4065 else if (comp == COMP_ENABLE)
4066 mac.append(PUSH_COMP_MODE);
4067 while (c != '\n' && c != EOF) {
4068 if (c == 0)
4069 mac.append(n);
4070 else
4071 mac.append((unsigned char)c);
4072 c = get_copy(&n);
4073 }
4074 if (!mm) {
4075 mm = new macro;
4076 request_dictionary.define(nm, mm);
4077 }
4078 if (comp == COMP_DISABLE || comp == COMP_ENABLE)
4079 mac.append(POP_GROFFCOMP_MODE);
4080 *mm = mac;
4081 tok.next();
4082 }
4083
4084 void define_string()
4085 {
4086 do_define_string(DEFINE_NORMAL,
4087 compatible_flag ? COMP_ENABLE: COMP_IGNORE);
4088 }
4089
4090 void define_nocomp_string()
4091 {
4092 do_define_string(DEFINE_NORMAL, COMP_DISABLE);
4093 }
4094
4095 void append_string()
4096 {
4097 do_define_string(DEFINE_APPEND,
4098 compatible_flag ? COMP_ENABLE : COMP_IGNORE);
4099 }
4100
4101 void append_nocomp_string()
4102 {
4103 do_define_string(DEFINE_APPEND, COMP_DISABLE);
4104 }
4105
4106 void do_define_character(char_mode mode, const char *font_name)
4107 {
4108 node *n = 0; // pacify compiler
4109 int c;
4110 tok.skip();
4111 charinfo *ci = tok.get_char(1);
4112 if (ci == 0) {
4113 skip_line();
4114 return;
4115 }
4116 if (font_name) {
4117 string s(font_name);
4118 s += ' ';
4119 s += ci->nm.contents();
4120 s += '\0';
4121 ci = get_charinfo(symbol(s.contents()));
4122 }
4123 tok.next();
4124 if (tok.newline())
4125 c = '\n';
4126 else if (tok.tab())
4127 c = '\t';
4128 else if (!tok.space()) {
4129 error("bad character definition");
4130 skip_line();
4131 return;
4132 }
4133 else
4134 c = get_copy(&n);
4135 while (c == ' ' || c == '\t')
4136 c = get_copy(&n);
4137 if (c == '"')
4138 c = get_copy(&n);
4139 macro *m = new macro;
4140 while (c != '\n' && c != EOF) {
4141 if (c == 0)
4142 m->append(n);
4143 else
4144 m->append((unsigned char)c);
4145 c = get_copy(&n);
4146 }
4147 m = ci->setx_macro(m, mode);
4148 if (m)
4149 delete m;
4150 tok.next();
4151 }
4152
4153 void define_character()
4154 {
4155 do_define_character(CHAR_NORMAL);
4156 }
4157
4158 void define_fallback_character()
4159 {
4160 do_define_character(CHAR_FALLBACK);
4161 }
4162
4163 void define_special_character()
4164 {
4165 do_define_character(CHAR_SPECIAL);
4166 }
4167
4168 static void remove_character()
4169 {
4170 tok.skip();
4171 while (!tok.newline() && !tok.eof()) {
4172 if (!tok.space() && !tok.tab()) {
4173 charinfo *ci = tok.get_char(1);
4174 if (!ci)
4175 break;
4176 macro *m = ci->set_macro(0);
4177 if (m)
4178 delete m;
4179 }
4180 tok.next();
4181 }
4182 skip_line();
4183 }
4184
4185 static void interpolate_string(symbol nm)
4186 {
4187 request_or_macro *p = lookup_request(nm);
4188 macro *m = p->to_macro();
4189 if (!m)
4190 error("you can only invoke a string or macro using \\*");
4191 else {
4192 string_iterator *si = new string_iterator(*m, "string", nm);
4193 input_stack::push(si);
4194 }
4195 }
4196
4197 static void interpolate_string_with_args(symbol s)
4198 {
4199 request_or_macro *p = lookup_request(s);
4200 macro *m = p->to_macro();
4201 if (!m)
4202 error("you can only invoke a string or macro using \\*");
4203 else {
4204 macro_iterator *mi = new macro_iterator(s, *m);
4205 decode_string_args(mi);
4206 input_stack::push(mi);
4207 }
4208 }
4209
4210 static void interpolate_arg(symbol nm)
4211 {
4212 const char *s = nm.contents();
4213 if (!s || *s == '\0')
4214 copy_mode_error("missing argument name");
4215 else if (s[1] == 0 && csdigit(s[0]))
4216 input_stack::push(input_stack::get_arg(s[0] - '0'));
4217 else if (s[0] == '*' && s[1] == '\0') {
4218 int limit = input_stack::nargs();
4219 string args;
4220 for (int i = 1; i <= limit; i++) {
4221 input_iterator *p = input_stack::get_arg(i);
4222 int c;
4223 while ((c = p->get(0)) != EOF)
4224 args += c;
4225 if (i != limit)
4226 args += ' ';
4227 }
4228 if (limit > 0) {
4229 args += '\0';
4230 input_stack::push(make_temp_iterator(args.contents()));
4231 }
4232 }
4233 else if (s[0] == '@' && s[1] == '\0') {
4234 int limit = input_stack::nargs();
4235 string args;
4236 for (int i = 1; i <= limit; i++) {
4237 args += '"';
4238 args += BEGIN_QUOTE;
4239 input_iterator *p = input_stack::get_arg(i);
4240 int c;
4241 while ((c = p->get(0)) != EOF)
4242 args += c;
4243 args += END_QUOTE;
4244 args += '"';
4245 if (i != limit)
4246 args += ' ';
4247 }
4248 if (limit > 0) {
4249 args += '\0';
4250 input_stack::push(make_temp_iterator(args.contents()));
4251 }
4252 }
4253 else {
4254 const char *p;
4255 for (p = s; *p && csdigit(*p); p++)
4256 ;
4257 if (*p)
4258 copy_mode_error("bad argument name `%1'", s);
4259 else
4260 input_stack::push(input_stack::get_arg(atoi(s)));
4261 }
4262 }
4263
4264 void handle_first_page_transition()
4265 {
4266 push_token(tok);
4267 topdiv->begin_page();
4268 }
4269
4270 // We push back a token by wrapping it up in a token_node, and
4271 // wrapping that up in a string_iterator.
4272
4273 static void push_token(const token &t)
4274 {
4275 macro m;
4276 m.append(new token_node(t));
4277 input_stack::push(new string_iterator(m));
4278 }
4279
4280 void push_page_ejector()
4281 {
4282 static char buf[2] = { PAGE_EJECTOR, '\0' };
4283 input_stack::push(make_temp_iterator(buf));
4284 }
4285
4286 void handle_initial_request(unsigned char code)
4287 {
4288 char buf[2];
4289 buf[0] = code;
4290 buf[1] = '\0';
4291 macro mac;
4292 mac.append(new token_node(tok));
4293 input_stack::push(new string_iterator(mac));
4294 input_stack::push(make_temp_iterator(buf));
4295 topdiv->begin_page();
4296 tok.next();
4297 }
4298
4299 void handle_initial_title()
4300 {
4301 handle_initial_request(TITLE_REQUEST);
4302 }
4303
4304 // this should be local to define_macro, but cfront 1.2 doesn't support that
4305 static symbol dot_symbol(".");
4306
4307 void do_define_macro(define_mode mode, calling_mode calling, comp_mode comp)
4308 {
4309 symbol nm, term;
4310 if (calling == CALLING_INDIRECT) {
4311 symbol temp1 = get_name(1);
4312 if (temp1.is_null()) {
4313 skip_line();
4314 return;
4315 }
4316 symbol temp2 = get_name();
4317 input_stack::push(make_temp_iterator("\n"));
4318 if (!temp2.is_null()) {
4319 interpolate_string(temp2);
4320 input_stack::push(make_temp_iterator(" "));
4321 }
4322 interpolate_string(temp1);
4323 input_stack::push(make_temp_iterator(" "));
4324 tok.next();
4325 }
4326 if (mode == DEFINE_NORMAL || mode == DEFINE_APPEND) {
4327 nm = get_name(1);
4328 if (nm.is_null()) {
4329 skip_line();
4330 return;
4331 }
4332 }
4333 term = get_name(); // the request that terminates the definition
4334 if (term.is_null())
4335 term = dot_symbol;
4336 while (!tok.newline() && !tok.eof())
4337 tok.next();
4338 const char *start_filename;
4339 int start_lineno;
4340 int have_start_location = input_stack::get_location(0, &start_filename,
4341 &start_lineno);
4342 node *n;
4343 // doing this here makes the line numbers come out right
4344 int c = get_copy(&n, 1);
4345 macro mac;
4346 macro *mm = 0;
4347 if (mode == DEFINE_NORMAL || mode == DEFINE_APPEND) {
4348 request_or_macro *rm =
4349 (request_or_macro *)request_dictionary.lookup(nm);
4350 if (rm)
4351 mm = rm->to_macro();
4352 if (mm && mode == DEFINE_APPEND)
4353 mac = *mm;
4354 }
4355 int bol = 1;
4356 if (comp == COMP_DISABLE)
4357 mac.append(PUSH_GROFF_MODE);
4358 else if (comp == COMP_ENABLE)
4359 mac.append(PUSH_COMP_MODE);
4360 for (;;) {
4361 while (c == ESCAPE_NEWLINE) {
4362 if (mode == DEFINE_NORMAL || mode == DEFINE_APPEND)
4363 mac.append(c);
4364 c = get_copy(&n, 1);
4365 }
4366 if (bol && c == '.') {
4367 const char *s = term.contents();
4368 int d = 0;
4369 // see if it matches term
4370 int i = 0;
4371 if (s[0] != 0) {
4372 while ((d = get_copy(&n)) == ' ' || d == '\t')
4373 ;
4374 if ((unsigned char)s[0] == d) {
4375 for (i = 1; s[i] != 0; i++) {
4376 d = get_copy(&n);
4377 if ((unsigned char)s[i] != d)
4378 break;
4379 }
4380 }
4381 }
4382 if (s[i] == 0
4383 && ((i == 2 && compatible_flag)
4384 || (d = get_copy(&n)) == ' '
4385 || d == '\n')) { // we found it
4386 if (d == '\n')
4387 tok.make_newline();
4388 else
4389 tok.make_space();
4390 if (mode == DEFINE_APPEND || mode == DEFINE_NORMAL) {
4391 if (!mm) {
4392 mm = new macro;
4393 request_dictionary.define(nm, mm);
4394 }
4395 if (comp == COMP_DISABLE || comp == COMP_ENABLE)
4396 mac.append(POP_GROFFCOMP_MODE);
4397 *mm = mac;
4398 }
4399 if (term != dot_symbol) {
4400 ignoring = 0;
4401 interpolate_macro(term);
4402 }
4403 else
4404 skip_line();
4405 return;
4406 }
4407 if (mode == DEFINE_APPEND || mode == DEFINE_NORMAL) {
4408 mac.append(c);
4409 for (int j = 0; j < i; j++)
4410 mac.append(s[j]);
4411 }
4412 c = d;
4413 }
4414 if (c == EOF) {
4415 if (mode == DEFINE_NORMAL || mode == DEFINE_APPEND) {
4416 if (have_start_location)
4417 error_with_file_and_line(start_filename, start_lineno,
4418 "end of file while defining macro `%1'",
4419 nm.contents());
4420 else
4421 error("end of file while defining macro `%1'", nm.contents());
4422 }
4423 else {
4424 if (have_start_location)
4425 error_with_file_and_line(start_filename, start_lineno,
4426 "end of file while ignoring input lines");
4427 else
4428 error("end of file while ignoring input lines");
4429 }
4430 tok.next();
4431 return;
4432 }
4433 if (mode == DEFINE_NORMAL || mode == DEFINE_APPEND) {
4434 if (c == 0)
4435 mac.append(n);
4436 else
4437 mac.append(c);
4438 }
4439 bol = (c == '\n');
4440 c = get_copy(&n, 1);
4441 }
4442 }
4443
4444 void define_macro()
4445 {
4446 do_define_macro(DEFINE_NORMAL, CALLING_NORMAL,
4447 compatible_flag ? COMP_ENABLE : COMP_IGNORE);
4448 }
4449
4450 void define_nocomp_macro()
4451 {
4452 do_define_macro(DEFINE_NORMAL, CALLING_NORMAL, COMP_DISABLE);
4453 }
4454
4455 void define_indirect_macro()
4456 {
4457 do_define_macro(DEFINE_NORMAL, CALLING_INDIRECT,
4458 compatible_flag ? COMP_ENABLE : COMP_IGNORE);
4459 }
4460
4461 void define_indirect_nocomp_macro()
4462 {
4463 do_define_macro(DEFINE_NORMAL, CALLING_INDIRECT, COMP_DISABLE);
4464 }
4465
4466 void append_macro()
4467 {
4468 do_define_macro(DEFINE_APPEND, CALLING_NORMAL,
4469 compatible_flag ? COMP_ENABLE : COMP_IGNORE);
4470 }
4471
4472 void append_nocomp_macro()
4473 {
4474 do_define_macro(DEFINE_APPEND, CALLING_NORMAL, COMP_DISABLE);
4475 }
4476
4477 void append_indirect_macro()
4478 {
4479 do_define_macro(DEFINE_APPEND, CALLING_INDIRECT,
4480 compatible_flag ? COMP_ENABLE : COMP_IGNORE);
4481 }
4482
4483 void append_indirect_nocomp_macro()
4484 {
4485 do_define_macro(DEFINE_APPEND, CALLING_INDIRECT, COMP_DISABLE);
4486 }
4487
4488 void ignore()
4489 {
4490 ignoring = 1;
4491 do_define_macro(DEFINE_IGNORE, CALLING_NORMAL, COMP_IGNORE);
4492 ignoring = 0;
4493 }
4494
4495 void remove_macro()
4496 {
4497 for (;;) {
4498 symbol s = get_name();
4499 if (s.is_null())
4500 break;
4501 request_dictionary.remove(s);
4502 }
4503 skip_line();
4504 }
4505
4506 void rename_macro()
4507 {
4508 symbol s1 = get_name(1);
4509 if (!s1.is_null()) {
4510 symbol s2 = get_name(1);
4511 if (!s2.is_null())
4512 request_dictionary.rename(s1, s2);
4513 }
4514 skip_line();
4515 }
4516
4517 void alias_macro()
4518 {
4519 symbol s1 = get_name(1);
4520 if (!s1.is_null()) {
4521 symbol s2 = get_name(1);
4522 if (!s2.is_null()) {
4523 if (!request_dictionary.alias(s1, s2))
4524 warning(WARN_MAC, "macro `%1' not defined", s2.contents());
4525 }
4526 }
4527 skip_line();
4528 }
4529
4530 void chop_macro()
4531 {
4532 symbol s = get_name(1);
4533 if (!s.is_null()) {
4534 request_or_macro *p = lookup_request(s);
4535 macro *m = p->to_macro();
4536 if (!m)
4537 error("cannot chop request");
4538 else if (m->empty())
4539 error("cannot chop empty macro");
4540 else {
4541 int have_restore = 0;
4542 // we have to check for additional save/restore pairs which could be
4543 // there due to empty am1 requests.
4544 for (;;) {
4545 if (m->get(m->len - 1) != POP_GROFFCOMP_MODE)
4546 break;
4547 have_restore = 1;
4548 m->len -= 1;
4549 if (m->get(m->len - 1) != PUSH_GROFF_MODE
4550 && m->get(m->len - 1) != PUSH_COMP_MODE)
4551 break;
4552 have_restore = 0;
4553 m->len -= 1;
4554 if (m->len == 0)
4555 break;
4556 }
4557 if (m->len == 0)
4558 error("cannot chop empty macro");
4559 else {
4560 if (have_restore)
4561 m->set(POP_GROFFCOMP_MODE, m->len - 1);
4562 else
4563 m->len -= 1;
4564 }
4565 }
4566 }
4567 skip_line();
4568 }
4569
4570 void substring_request()
4571 {
4572 int start; // 0, 1, ..., n-1 or -1, -2, ...
4573 symbol s = get_name(1);
4574 if (!s.is_null() && get_integer(&start)) {
4575 request_or_macro *p = lookup_request(s);
4576 macro *m = p->to_macro();
4577 if (!m)
4578 error("cannot apply `substring' on a request");
4579 else {
4580 int end = -1;
4581 if (!has_arg() || get_integer(&end)) {
4582 int real_length = 0; // 1, 2, ..., n
4583 string_iterator iter1(*m);
4584 for (int l = 0; l < m->len; l++) {
4585 int c = iter1.get(0);
4586 if (c == PUSH_GROFF_MODE
4587 || c == PUSH_COMP_MODE
4588 || c == POP_GROFFCOMP_MODE)
4589 continue;
4590 if (c == EOF)
4591 break;
4592 real_length++;
4593 }
4594 if (start < 0)
4595 start += real_length;
4596 if (end < 0)
4597 end += real_length;
4598 if (start > end) {
4599 int tem = start;
4600 start = end;
4601 end = tem;
4602 }
4603 if (start >= real_length || end < 0) {
4604 warning(WARN_RANGE,
4605 "start and end index of substring out of range");
4606 m->len = 0;
4607 if (m->p) {
4608 if (--(m->p->count) <= 0)
4609 delete m->p;
4610 m->p = 0;
4611 }
4612 skip_line();
4613 return;
4614 }
4615 if (start < 0) {
4616 warning(WARN_RANGE,
4617 "start index of substring out of range, set to 0");
4618 start = 0;
4619 }
4620 if (end >= real_length) {
4621 warning(WARN_RANGE,
4622 "end index of substring out of range, set to string length");
4623 end = real_length - 1;
4624 }
4625 // now extract the substring
4626 string_iterator iter(*m);
4627 int i;
4628 for (i = 0; i < start; i++) {
4629 int c = iter.get(0);
4630 while (c == PUSH_GROFF_MODE
4631 || c == PUSH_COMP_MODE
4632 || c == POP_GROFFCOMP_MODE)
4633 c = iter.get(0);
4634 if (c == EOF)
4635 break;
4636 }
4637 macro mac;
4638 for (; i <= end; i++) {
4639 node *nd = 0; // pacify compiler
4640 int c = iter.get(&nd);
4641 while (c == PUSH_GROFF_MODE
4642 || c == PUSH_COMP_MODE
4643 || c == POP_GROFFCOMP_MODE)
4644 c = iter.get(0);
4645 if (c == EOF)
4646 break;
4647 if (c == 0)
4648 mac.append(nd);
4649 else
4650 mac.append((unsigned char)c);
4651 }
4652 *m = mac;
4653 }
4654 }
4655 }
4656 skip_line();
4657 }
4658
4659 void length_request()
4660 {
4661 symbol ret;
4662 ret = get_name(1);
4663 if (ret.is_null()) {
4664 skip_line();
4665 return;
4666 }
4667 int c;
4668 node *n;
4669 if (tok.newline())
4670 c = '\n';
4671 else if (tok.tab())
4672 c = '\t';
4673 else if (!tok.space()) {
4674 error("bad string definition");
4675 skip_line();
4676 return;
4677 }
4678 else
4679 c = get_copy(&n);
4680 while (c == ' ')
4681 c = get_copy(&n);
4682 if (c == '"')
4683 c = get_copy(&n);
4684 int len = 0;
4685 while (c != '\n' && c != EOF) {
4686 ++len;
4687 c = get_copy(&n);
4688 }
4689 reg *r = (reg*)number_reg_dictionary.lookup(ret);
4690 if (r)
4691 r->set_value(len);
4692 else
4693 set_number_reg(ret, len);
4694 tok.next();
4695 }
4696
4697 void asciify_macro()
4698 {
4699 symbol s = get_name(1);
4700 if (!s.is_null()) {
4701 request_or_macro *p = lookup_request(s);
4702 macro *m = p->to_macro();
4703 if (!m)
4704 error("cannot asciify request");
4705 else {
4706 macro am;
4707 string_iterator iter(*m);
4708 for (;;) {
4709 node *nd = 0; // pacify compiler
4710 int c = iter.get(&nd);
4711 if (c == EOF)
4712 break;
4713 if (c != 0)
4714 am.append(c);
4715 else
4716 nd->asciify(&am);
4717 }
4718 *m = am;
4719 }
4720 }
4721 skip_line();
4722 }
4723
4724 void unformat_macro()
4725 {
4726 symbol s = get_name(1);
4727 if (!s.is_null()) {
4728 request_or_macro *p = lookup_request(s);
4729 macro *m = p->to_macro();
4730 if (!m)
4731 error("cannot unformat request");
4732 else {
4733 macro am;
4734 string_iterator iter(*m);
4735 for (;;) {
4736 node *nd = 0; // pacify compiler
4737 int c = iter.get(&nd);
4738 if (c == EOF)
4739 break;
4740 if (c != 0)
4741 am.append(c);
4742 else {
4743 if (nd->set_unformat_flag())
4744 am.append(nd);
4745 }
4746 }
4747 *m = am;
4748 }
4749 }
4750 skip_line();
4751 }
4752
4753 static void interpolate_environment_variable(symbol nm)
4754 {
4755 const char *s = getenv(nm.contents());
4756 if (s && *s)
4757 input_stack::push(make_temp_iterator(s));
4758 }
4759
4760 void interpolate_number_reg(symbol nm, int inc)
4761 {
4762 reg *r = lookup_number_reg(nm);
4763 if (inc < 0)
4764 r->decrement();
4765 else if (inc > 0)
4766 r->increment();
4767 input_stack::push(make_temp_iterator(r->get_string()));
4768 }
4769
4770 static void interpolate_number_format(symbol nm)
4771 {
4772 reg *r = (reg *)number_reg_dictionary.lookup(nm);
4773 if (r)
4774 input_stack::push(make_temp_iterator(r->get_format()));
4775 }
4776
4777 static int get_delim_number(units *n, unsigned char si, int prev_value)
4778 {
4779 token start;
4780 start.next();
4781 if (start.delimiter(1)) {
4782 tok.next();
4783 if (get_number(n, si, prev_value)) {
4784 if (start != tok)
4785 warning(WARN_DELIM, "closing delimiter does not match");
4786 return 1;
4787 }
4788 }
4789 return 0;
4790 }
4791
4792 static int get_delim_number(units *n, unsigned char si)
4793 {
4794 token start;
4795 start.next();
4796 if (start.delimiter(1)) {
4797 tok.next();
4798 if (get_number(n, si)) {
4799 if (start != tok)
4800 warning(WARN_DELIM, "closing delimiter does not match");
4801 return 1;
4802 }
4803 }
4804 return 0;
4805 }
4806
4807 static int get_line_arg(units *n, unsigned char si, charinfo **cp)
4808 {
4809 token start;
4810 start.next();
4811 int start_level = input_stack::get_level();
4812 if (!start.delimiter(1))
4813 return 0;
4814 tok.next();
4815 if (get_number(n, si)) {
4816 if (tok.dummy() || tok.transparent_dummy())
4817 tok.next();
4818 if (!(start == tok && input_stack::get_level() == start_level)) {
4819 *cp = tok.get_char(1);
4820 tok.next();
4821 }
4822 if (!(start == tok && input_stack::get_level() == start_level))
4823 warning(WARN_DELIM, "closing delimiter does not match");
4824 return 1;
4825 }
4826 return 0;
4827 }
4828
4829 static int read_size(int *x)
4830 {
4831 tok.next();
4832 int c = tok.ch();
4833 int inc = 0;
4834 if (c == '-') {
4835 inc = -1;
4836 tok.next();
4837 c = tok.ch();
4838 }
4839 else if (c == '+') {
4840 inc = 1;
4841 tok.next();
4842 c = tok.ch();
4843 }
4844 int val = 0; // pacify compiler
4845 int bad = 0;
4846 if (c == '(') {
4847 tok.next();
4848 c = tok.ch();
4849 if (!inc) {
4850 // allow an increment either before or after the left parenthesis
4851 if (c == '-') {
4852 inc = -1;
4853 tok.next();
4854 c = tok.ch();
4855 }
4856 else if (c == '+') {
4857 inc = 1;
4858 tok.next();
4859 c = tok.ch();
4860 }
4861 }
4862 if (!csdigit(c))
4863 bad = 1;
4864 else {
4865 val = c - '0';
4866 tok.next();
4867 c = tok.ch();
4868 if (!csdigit(c))
4869 bad = 1;
4870 else {
4871 val = val*10 + (c - '0');
4872 val *= sizescale;
4873 }
4874 }
4875 }
4876 else if (csdigit(c)) {
4877 val = c - '0';
4878 if (!inc && c != '0' && c < '4') {
4879 tok.next();
4880 c = tok.ch();
4881 if (!csdigit(c))
4882 bad = 1;
4883 else
4884 val = val*10 + (c - '0');
4885 }
4886 val *= sizescale;
4887 }
4888 else if (!tok.delimiter(1))
4889 return 0;
4890 else {
4891 token start(tok);
4892 tok.next();
4893 if (!(inc
4894 ? get_number(&val, 'z')
4895 : get_number(&val, 'z', curenv->get_requested_point_size())))
4896 return 0;
4897 if (!(start.ch() == '[' && tok.ch() == ']') && start != tok) {
4898 if (start.ch() == '[')
4899 error("missing `]'");
4900 else
4901 error("missing closing delimiter");
4902 return 0;
4903 }
4904 }
4905 if (!bad) {
4906 switch (inc) {
4907 case 0:
4908 if (val == 0) {
4909 // special case -- \s[0] and \s0 means to revert to previous size
4910 *x = 0;
4911 return 1;
4912 }
4913 *x = val;
4914 break;
4915 case 1:
4916 *x = curenv->get_requested_point_size() + val;
4917 break;
4918 case -1:
4919 *x = curenv->get_requested_point_size() - val;
4920 break;
4921 default:
4922 assert(0);
4923 }
4924 if (*x <= 0) {
4925 warning(WARN_RANGE,
4926 "\\s request results in non-positive point size; set to 1");
4927 *x = 1;
4928 }
4929 return 1;
4930 }
4931 else {
4932 error("bad digit in point size");
4933 return 0;
4934 }
4935 }
4936
4937 static symbol get_delim_name()
4938 {
4939 token start;
4940 start.next();
4941 if (start.eof()) {
4942 error("end of input at start of delimited name");
4943 return NULL_SYMBOL;
4944 }
4945 if (start.newline()) {
4946 error("can't delimit name with a newline");
4947 return NULL_SYMBOL;
4948 }
4949 int start_level = input_stack::get_level();
4950 char abuf[ABUF_SIZE];
4951 char *buf = abuf;
4952 int buf_size = ABUF_SIZE;
4953 int i = 0;
4954 for (;;) {
4955 if (i + 1 > buf_size) {
4956 if (buf == abuf) {
4957 buf = new char[ABUF_SIZE*2];
4958 memcpy(buf, abuf, buf_size);
4959 buf_size = ABUF_SIZE*2;
4960 }
4961 else {
4962 char *old_buf = buf;
4963 buf = new char[buf_size*2];
4964 memcpy(buf, old_buf, buf_size);
4965 buf_size *= 2;
4966 a_delete old_buf;
4967 }
4968 }
4969 tok.next();
4970 if (tok == start
4971 && (compatible_flag || input_stack::get_level() == start_level))
4972 break;
4973 if ((buf[i] = tok.ch()) == 0) {
4974 error("missing delimiter (got %1)", tok.description());
4975 if (buf != abuf)
4976 a_delete buf;
4977 return NULL_SYMBOL;
4978 }
4979 i++;
4980 }
4981 buf[i] = '\0';
4982 if (buf == abuf) {
4983 if (i == 0) {
4984 error("empty delimited name");
4985 return NULL_SYMBOL;
4986 }
4987 else
4988 return symbol(buf);
4989 }
4990 else {
4991 symbol s(buf);
4992 a_delete buf;
4993 return s;
4994 }
4995 }
4996
4997 // Implement \R
4998
4999 static void do_register()
5000 {
5001 token start;
5002 start.next();
5003 if (!start.delimiter(1))
5004 return;
5005 tok.next();
5006 symbol nm = get_long_name(1);
5007 if (nm.is_null())
5008 return;
5009 while (tok.space())
5010 tok.next();
5011 reg *r = (reg *)number_reg_dictionary.lookup(nm);
5012 int prev_value;
5013 if (!r || !r->get_value(&prev_value))
5014 prev_value = 0;
5015 int val;
5016 if (!get_number(&val, 'u', prev_value))
5017 return;
5018 if (start != tok)
5019 warning(WARN_DELIM, "closing delimiter does not match");
5020 if (r)
5021 r->set_value(val);
5022 else
5023 set_number_reg(nm, val);
5024 }
5025
5026 // this implements the \w escape sequence
5027
5028 static void do_width()
5029 {
5030 token start;
5031 start.next();
5032 int start_level = input_stack::get_level();
5033 environment env(curenv);
5034 environment *oldenv = curenv;
5035 curenv = &env;
5036 for (;;) {
5037 tok.next();
5038 if (tok.eof()) {
5039 warning(WARN_DELIM, "missing closing delimiter");
5040 break;
5041 }
5042 if (tok.newline()) {
5043 warning(WARN_DELIM, "missing closing delimiter");
5044 input_stack::push(make_temp_iterator("\n"));
5045 break;
5046 }
5047 if (tok == start
5048 && (compatible_flag || input_stack::get_level() == start_level))
5049 break;
5050 tok.process();
5051 }
5052 env.wrap_up_tab();
5053 units x = env.get_input_line_position().to_units();
5054 input_stack::push(make_temp_iterator(i_to_a(x)));
5055 env.width_registers();
5056 curenv = oldenv;
5057 have_input = 0;
5058 }
5059
5060 charinfo *page_character;
5061
5062 void set_page_character()
5063 {
5064 page_character = get_optional_char();
5065 skip_line();
5066 }
5067
5068 static const symbol percent_symbol("%");
5069
5070 void read_title_parts(node **part, hunits *part_width)
5071 {
5072 tok.skip();
5073 if (tok.newline() || tok.eof())
5074 return;
5075 token start(tok);
5076 int start_level = input_stack::get_level();
5077 tok.next();
5078 for (int i = 0; i < 3; i++) {
5079 while (!tok.newline() && !tok.eof()) {
5080 if (tok == start
5081 && (compatible_flag || input_stack::get_level() == start_level)) {
5082 tok.next();
5083 break;
5084 }
5085 if (page_character != 0 && tok.get_char() == page_character)
5086 interpolate_number_reg(percent_symbol, 0);
5087 else
5088 tok.process();
5089 tok.next();
5090 }
5091 curenv->wrap_up_tab();
5092 part_width[i] = curenv->get_input_line_position();
5093 part[i] = curenv->extract_output_line();
5094 }
5095 while (!tok.newline() && !tok.eof())
5096 tok.next();
5097 }
5098
5099 class non_interpreted_node : public node {
5100 macro mac;
5101 public:
5102 non_interpreted_node(const macro &);
5103 int interpret(macro *);
5104 node *copy();
5105 int ends_sentence();
5106 int same(node *);
5107 const char *type();
5108 int force_tprint();
5109 int is_tag();
5110 };
5111
5112 non_interpreted_node::non_interpreted_node(const macro &m) : mac(m)
5113 {
5114 }
5115
5116 int non_interpreted_node::ends_sentence()
5117 {
5118 return 2;
5119 }
5120
5121 int non_interpreted_node::same(node *nd)
5122 {
5123 return mac == ((non_interpreted_node *)nd)->mac;
5124 }
5125
5126 const char *non_interpreted_node::type()
5127 {
5128 return "non_interpreted_node";
5129 }
5130
5131 int non_interpreted_node::force_tprint()
5132 {
5133 return 0;
5134 }
5135
5136 int non_interpreted_node::is_tag()
5137 {
5138 return 0;
5139 }
5140
5141 node *non_interpreted_node::copy()
5142 {
5143 return new non_interpreted_node(mac);
5144 }
5145
5146 int non_interpreted_node::interpret(macro *m)
5147 {
5148 string_iterator si(mac);
5149 node *n = 0; // pacify compiler
5150 for (;;) {
5151 int c = si.get(&n);
5152 if (c == EOF)
5153 break;
5154 if (c == 0)
5155 m->append(n);
5156 else
5157 m->append(c);
5158 }
5159 return 1;
5160 }
5161
5162 static node *do_non_interpreted()
5163 {
5164 node *n;
5165 int c;
5166 macro mac;
5167 while ((c = get_copy(&n)) != ESCAPE_QUESTION && c != EOF && c != '\n')
5168 if (c == 0)
5169 mac.append(n);
5170 else
5171 mac.append(c);
5172 if (c == EOF || c == '\n') {
5173 error("missing \\?");
5174 return 0;
5175 }
5176 return new non_interpreted_node(mac);
5177 }
5178
5179 static void encode_char(macro *mac, char c)
5180 {
5181 if (c == '\0') {
5182 if ((font::use_charnames_in_special) && tok.special()) {
5183 charinfo *ci = tok.get_char(1);
5184 const char *s = ci->get_symbol()->contents();
5185 if (s[0] != (char)0) {
5186 mac->append('\\');
5187 mac->append('(');
5188 int i = 0;
5189 while (s[i] != (char)0) {
5190 mac->append(s[i]);
5191 i++;
5192 }
5193 mac->append('\\');
5194 mac->append(')');
5195 }
5196 }
5197 else if (tok.stretchable_space()
5198 || tok.unstretchable_space())
5199 mac->append(' ');
5200 else if (!(tok.hyphen_indicator()
5201 || tok.dummy()
5202 || tok.transparent_dummy()
5203 || tok.zero_width_break()))
5204 error("%1 is invalid within \\X", tok.description());
5205 }
5206 else {
5207 if ((font::use_charnames_in_special) && (c == '\\')) {
5208 /*
5209 * add escape escape sequence
5210 */
5211 mac->append(c);
5212 }
5213 mac->append(c);
5214 }
5215 }
5216
5217 node *do_special()
5218 {
5219 token start;
5220 start.next();
5221 int start_level = input_stack::get_level();
5222 macro mac;
5223 for (tok.next();
5224 tok != start || input_stack::get_level() != start_level;
5225 tok.next()) {
5226 if (tok.eof()) {
5227 warning(WARN_DELIM, "missing closing delimiter");
5228 return 0;
5229 }
5230 if (tok.newline()) {
5231 input_stack::push(make_temp_iterator("\n"));
5232 warning(WARN_DELIM, "missing closing delimiter");
5233 break;
5234 }
5235 unsigned char c;
5236 if (tok.space())
5237 c = ' ';
5238 else if (tok.tab())
5239 c = '\t';
5240 else if (tok.leader())
5241 c = '\001';
5242 else if (tok.backspace())
5243 c = '\b';
5244 else
5245 c = tok.ch();
5246 encode_char(&mac, c);
5247 }
5248 return new special_node(mac);
5249 }
5250
5251 void output_request()
5252 {
5253 if (!tok.newline() && !tok.eof()) {
5254 int c;
5255 for (;;) {
5256 c = get_copy(0);
5257 if (c == '"') {
5258 c = get_copy(0);
5259 break;
5260 }
5261 if (c != ' ' && c != '\t')
5262 break;
5263 }
5264 for (; c != '\n' && c != EOF; c = get_copy(0))
5265 topdiv->transparent_output(c);
5266 topdiv->transparent_output('\n');
5267 }
5268 tok.next();
5269 }
5270
5271 extern int image_no; // from node.cpp
5272
5273 static node *do_suppress(symbol nm)
5274 {
5275 if (nm.is_null() || nm.is_empty()) {
5276 error("expecting an argument to escape \\O");
5277 return 0;
5278 }
5279 const char *s = nm.contents();
5280 switch (*s) {
5281 case '0':
5282 if (begin_level == 0)
5283 // suppress generation of glyphs
5284 return new suppress_node(0, 0);
5285 break;
5286 case '1':
5287 if (begin_level == 0)
5288 // enable generation of glyphs
5289 return new suppress_node(1, 0);
5290 break;
5291 case '2':
5292 if (begin_level == 0)
5293 return new suppress_node(1, 1);
5294 break;
5295 case '3':
5296 begin_level++;
5297 break;
5298 case '4':
5299 begin_level--;
5300 break;
5301 case '5':
5302 {
5303 s++; // move over '5'
5304 char position = *s;
5305 if (*s == (char)0) {
5306 error("missing position and filename in \\O");
5307 return 0;
5308 }
5309 if (!(position == 'l'
5310 || position == 'r'
5311 || position == 'c'
5312 || position == 'i')) {
5313 error("l, r, c, or i position expected (got %1 in \\O)", position);
5314 return 0;
5315 }
5316 s++; // onto image name
5317 if (s == (char *)0) {
5318 error("missing image name for \\O");
5319 return 0;
5320 }
5321 image_no++;
5322 if (begin_level == 0)
5323 return new suppress_node(symbol(s), position, image_no);
5324 }
5325 break;
5326 default:
5327 error("`%1' is an invalid argument to \\O", *s);
5328 }
5329 return 0;
5330 }
5331
5332 void special_node::tprint(troff_output_file *out)
5333 {
5334 tprint_start(out);
5335 string_iterator iter(mac);
5336 for (;;) {
5337 int c = iter.get(0);
5338 if (c == EOF)
5339 break;
5340 for (const char *s = ::asciify(c); *s; s++)
5341 tprint_char(out, *s);
5342 }
5343 tprint_end(out);
5344 }
5345
5346 int get_file_line(const char **filename, int *lineno)
5347 {
5348 return input_stack::get_location(0, filename, lineno);
5349 }
5350
5351 void line_file()
5352 {
5353 int n;
5354 if (get_integer(&n)) {
5355 const char *filename = 0;
5356 if (has_arg()) {
5357 symbol s = get_long_name();
5358 filename = s.contents();
5359 }
5360 (void)input_stack::set_location(filename, n-1);
5361 }
5362 skip_line();
5363 }
5364
5365 static int nroff_mode = 0;
5366
5367 static void nroff_request()
5368 {
5369 nroff_mode = 1;
5370 skip_line();
5371 }
5372
5373 static void troff_request()
5374 {
5375 nroff_mode = 0;
5376 skip_line();
5377 }
5378
5379 static void skip_alternative()
5380 {
5381 int level = 0;
5382 // ensure that ``.if 0\{'' works as expected
5383 if (tok.left_brace())
5384 level++;
5385 int c;
5386 for (;;) {
5387 c = input_stack::get(0);
5388 if (c == EOF)
5389 break;
5390 if (c == ESCAPE_LEFT_BRACE)
5391 ++level;
5392 else if (c == ESCAPE_RIGHT_BRACE)
5393 --level;
5394 else if (c == escape_char && escape_char > 0)
5395 switch(input_stack::get(0)) {
5396 case '{':
5397 ++level;
5398 break;
5399 case '}':
5400 --level;
5401 break;
5402 case '"':
5403 while ((c = input_stack::get(0)) != '\n' && c != EOF)
5404 ;
5405 }
5406 /*
5407 Note that the level can properly be < 0, eg
5408
5409 .if 1 \{\
5410 .if 0 \{\
5411 .\}\}
5412
5413 So don't give an error message in this case.
5414 */
5415 if (level <= 0 && c == '\n')
5416 break;
5417 }
5418 tok.next();
5419 }
5420
5421 static void begin_alternative()
5422 {
5423 while (tok.space() || tok.left_brace())
5424 tok.next();
5425 }
5426
5427 void nop_request()
5428 {
5429 while (tok.space())
5430 tok.next();
5431 }
5432
5433 static int_stack if_else_stack;
5434
5435 int do_if_request()
5436 {
5437 int invert = 0;
5438 while (tok.space())
5439 tok.next();
5440 while (tok.ch() == '!') {
5441 tok.next();
5442 invert = !invert;
5443 }
5444 int result;
5445 unsigned char c = tok.ch();
5446 if (c == 't') {
5447 tok.next();
5448 result = !nroff_mode;
5449 }
5450 else if (c == 'n') {
5451 tok.next();
5452 result = nroff_mode;
5453 }
5454 else if (c == 'v') {
5455 tok.next();
5456 result = 0;
5457 }
5458 else if (c == 'o') {
5459 result = (topdiv->get_page_number() & 1);
5460 tok.next();
5461 }
5462 else if (c == 'e') {
5463 result = !(topdiv->get_page_number() & 1);
5464 tok.next();
5465 }
5466 else if (c == 'd' || c == 'r') {
5467 tok.next();
5468 symbol nm = get_name(1);
5469 if (nm.is_null()) {
5470 skip_alternative();
5471 return 0;
5472 }
5473 result = (c == 'd'
5474 ? request_dictionary.lookup(nm) != 0
5475 : number_reg_dictionary.lookup(nm) != 0);
5476 }
5477 else if (c == 'm') {
5478 tok.next();
5479 symbol nm = get_long_name(1);
5480 if (nm.is_null()) {
5481 skip_alternative();
5482 return 0;
5483 }
5484 result = (nm == default_symbol
5485 || color_dictionary.lookup(nm) != 0);
5486 }
5487 else if (c == 'c') {
5488 tok.next();
5489 tok.skip();
5490 charinfo *ci = tok.get_char(1);
5491 if (ci == 0) {
5492 skip_alternative();
5493 return 0;
5494 }
5495 result = character_exists(ci, curenv);
5496 tok.next();
5497 }
5498 else if (c == 'F') {
5499 tok.next();
5500 symbol nm = get_long_name(1);
5501 if (nm.is_null()) {
5502 skip_alternative();
5503 return 0;
5504 }
5505 result = check_font(curenv->get_family()->nm, nm);
5506 }
5507 else if (c == 'S') {
5508 tok.next();
5509 symbol nm = get_long_name(1);
5510 if (nm.is_null()) {
5511 skip_alternative();
5512 return 0;
5513 }
5514 result = check_style(nm);
5515 }
5516 else if (tok.space())
5517 result = 0;
5518 else if (tok.delimiter()) {
5519 token delim = tok;
5520 int delim_level = input_stack::get_level();
5521 environment env1(curenv);
5522 environment env2(curenv);
5523 environment *oldenv = curenv;
5524 curenv = &env1;
5525 suppress_push = 1;
5526 for (int i = 0; i < 2; i++) {
5527 for (;;) {
5528 tok.next();
5529 if (tok.newline() || tok.eof()) {
5530 warning(WARN_DELIM, "missing closing delimiter");
5531 tok.next();
5532 curenv = oldenv;
5533 return 0;
5534 }
5535 if (tok == delim
5536 && (compatible_flag || input_stack::get_level() == delim_level))
5537 break;
5538 tok.process();
5539 }
5540 curenv = &env2;
5541 }
5542 node *n1 = env1.extract_output_line();
5543 node *n2 = env2.extract_output_line();
5544 result = same_node_list(n1, n2);
5545 delete_node_list(n1);
5546 delete_node_list(n2);
5547 curenv = oldenv;
5548 have_input = 0;
5549 suppress_push = 0;
5550 tok.next();
5551 }
5552 else {
5553 units n;
5554 if (!get_number(&n, 'u')) {
5555 skip_alternative();
5556 return 0;
5557 }
5558 else
5559 result = n > 0;
5560 }
5561 if (invert)
5562 result = !result;
5563 if (result)
5564 begin_alternative();
5565 else
5566 skip_alternative();
5567 return result;
5568 }
5569
5570 void if_else_request()
5571 {
5572 if_else_stack.push(do_if_request());
5573 }
5574
5575 void if_request()
5576 {
5577 do_if_request();
5578 }
5579
5580 void else_request()
5581 {
5582 if (if_else_stack.is_empty()) {
5583 warning(WARN_EL, "unbalanced .el request");
5584 skip_alternative();
5585 }
5586 else {
5587 if (if_else_stack.pop())
5588 skip_alternative();
5589 else
5590 begin_alternative();
5591 }
5592 }
5593
5594 static int while_depth = 0;
5595 static int while_break_flag = 0;
5596
5597 void while_request()
5598 {
5599 macro mac;
5600 int escaped = 0;
5601 int level = 0;
5602 mac.append(new token_node(tok));
5603 for (;;) {
5604 node *n = 0; // pacify compiler
5605 int c = input_stack::get(&n);
5606 if (c == EOF)
5607 break;
5608 if (c == 0) {
5609 escaped = 0;
5610 mac.append(n);
5611 }
5612 else if (escaped) {
5613 if (c == '{')
5614 level += 1;
5615 else if (c == '}')
5616 level -= 1;
5617 escaped = 0;
5618 mac.append(c);
5619 }
5620 else {
5621 if (c == ESCAPE_LEFT_BRACE)
5622 level += 1;
5623 else if (c == ESCAPE_RIGHT_BRACE)
5624 level -= 1;
5625 else if (c == escape_char)
5626 escaped = 1;
5627 mac.append(c);
5628 if (c == '\n' && level <= 0)
5629 break;
5630 }
5631 }
5632 if (level != 0)
5633 error("unbalanced \\{ \\}");
5634 else {
5635 while_depth++;
5636 input_stack::add_boundary();
5637 for (;;) {
5638 input_stack::push(new string_iterator(mac, "while loop"));
5639 tok.next();
5640 if (!do_if_request()) {
5641 while (input_stack::get(0) != EOF)
5642 ;
5643 break;
5644 }
5645 process_input_stack();
5646 if (while_break_flag || input_stack::is_return_boundary()) {
5647 while_break_flag = 0;
5648 break;
5649 }
5650 }
5651 input_stack::remove_boundary();
5652 while_depth--;
5653 }
5654 tok.next();
5655 }
5656
5657 void while_break_request()
5658 {
5659 if (!while_depth) {
5660 error("no while loop");
5661 skip_line();
5662 }
5663 else {
5664 while_break_flag = 1;
5665 while (input_stack::get(0) != EOF)
5666 ;
5667 tok.next();
5668 }
5669 }
5670
5671 void while_continue_request()
5672 {
5673 if (!while_depth) {
5674 error("no while loop");
5675 skip_line();
5676 }
5677 else {
5678 while (input_stack::get(0) != EOF)
5679 ;
5680 tok.next();
5681 }
5682 }
5683
5684 // .so
5685
5686 void source()
5687 {
5688 symbol nm = get_long_name(1);
5689 if (nm.is_null())
5690 skip_line();
5691 else {
5692 while (!tok.newline() && !tok.eof())
5693 tok.next();
5694 errno = 0;
5695 FILE *fp = include_search_path.open_file_cautious(nm.contents());
5696 if (fp)
5697 input_stack::push(new file_iterator(fp, nm.contents()));
5698 else
5699 error("can't open `%1': %2", nm.contents(), strerror(errno));
5700 tok.next();
5701 }
5702 }
5703
5704 // like .so but use popen()
5705
5706 void pipe_source()
5707 {
5708 if (safer_flag) {
5709 error(".pso request not allowed in safer mode");
5710 skip_line();
5711 }
5712 else {
5713 #ifdef POPEN_MISSING
5714 error("pipes not available on this system");
5715 skip_line();
5716 #else /* not POPEN_MISSING */
5717 if (tok.newline() || tok.eof())
5718 error("missing command");
5719 else {
5720 int c;
5721 while ((c = get_copy(0)) == ' ' || c == '\t')
5722 ;
5723 int buf_size = 24;
5724 char *buf = new char[buf_size];
5725 int buf_used = 0;
5726 for (; c != '\n' && c != EOF; c = get_copy(0)) {
5727 const char *s = asciify(c);
5728 int slen = strlen(s);
5729 if (buf_used + slen + 1> buf_size) {
5730 char *old_buf = buf;
5731 int old_buf_size = buf_size;
5732 buf_size *= 2;
5733 buf = new char[buf_size];
5734 memcpy(buf, old_buf, old_buf_size);
5735 a_delete old_buf;
5736 }
5737 strcpy(buf + buf_used, s);
5738 buf_used += slen;
5739 }
5740 buf[buf_used] = '\0';
5741 errno = 0;
5742 FILE *fp = popen(buf, POPEN_RT);
5743 if (fp)
5744 input_stack::push(new file_iterator(fp, symbol(buf).contents(), 1));
5745 else
5746 error("can't open pipe to process `%1': %2", buf, strerror(errno));
5747 a_delete buf;
5748 }
5749 tok.next();
5750 #endif /* not POPEN_MISSING */
5751 }
5752 }
5753
5754 // .psbb
5755
5756 static int llx_reg_contents = 0;
5757 static int lly_reg_contents = 0;
5758 static int urx_reg_contents = 0;
5759 static int ury_reg_contents = 0;
5760
5761 struct bounding_box {
5762 int llx, lly, urx, ury;
5763 };
5764
5765 /* Parse the argument to a %%BoundingBox comment. Return 1 if it
5766 contains 4 numbers, 2 if it contains (atend), 0 otherwise. */
5767
5768 int parse_bounding_box(char *p, bounding_box *bb)
5769 {
5770 if (sscanf(p, "%d %d %d %d",
5771 &bb->llx, &bb->lly, &bb->urx, &bb->ury) == 4)
5772 return 1;
5773 else {
5774 /* The Document Structuring Conventions say that the numbers
5775 should be integers. Unfortunately some broken applications
5776 get this wrong. */
5777 double x1, x2, x3, x4;
5778 if (sscanf(p, "%lf %lf %lf %lf", &x1, &x2, &x3, &x4) == 4) {
5779 bb->llx = (int)x1;
5780 bb->lly = (int)x2;
5781 bb->urx = (int)x3;
5782 bb->ury = (int)x4;
5783 return 1;
5784 }
5785 else {
5786 for (; *p == ' ' || *p == '\t'; p++)
5787 ;
5788 if (strncmp(p, "(atend)", 7) == 0) {
5789 return 2;
5790 }
5791 }
5792 }
5793 bb->llx = bb->lly = bb->urx = bb->ury = 0;
5794 return 0;
5795 }
5796
5797 // This version is taken from psrm.cpp
5798
5799 #define PS_LINE_MAX 255
5800 cset white_space("\n\r \t");
5801
5802 int ps_get_line(char *buf, FILE *fp, const char* filename)
5803 {
5804 int c = getc(fp);
5805 if (c == EOF) {
5806 buf[0] = '\0';
5807 return 0;
5808 }
5809 int i = 0;
5810 int err = 0;
5811 while (c != '\r' && c != '\n' && c != EOF) {
5812 if ((c < 0x1b && !white_space(c)) || c == 0x7f)
5813 error("invalid input character code %1 in `%2'", int(c), filename);
5814 else if (i < PS_LINE_MAX)
5815 buf[i++] = c;
5816 else if (!err) {
5817 err = 1;
5818 error("PostScript file `%1' is non-conforming "
5819 "because length of line exceeds 255", filename);
5820 }
5821 c = getc(fp);
5822 }
5823 buf[i++] = '\n';
5824 buf[i] = '\0';
5825 if (c == '\r') {
5826 c = getc(fp);
5827 if (c != EOF && c != '\n')
5828 ungetc(c, fp);
5829 }
5830 return 1;
5831 }
5832
5833 inline void assign_registers(int llx, int lly, int urx, int ury)
5834 {
5835 llx_reg_contents = llx;
5836 lly_reg_contents = lly;
5837 urx_reg_contents = urx;
5838 ury_reg_contents = ury;
5839 }
5840
5841 void do_ps_file(FILE *fp, const char* filename)
5842 {
5843 bounding_box bb;
5844 int bb_at_end = 0;
5845 char buf[PS_LINE_MAX];
5846 llx_reg_contents = lly_reg_contents =
5847 urx_reg_contents = ury_reg_contents = 0;
5848 if (!ps_get_line(buf, fp, filename)) {
5849 error("`%1' is empty", filename);
5850 return;
5851 }
5852 if (strncmp("%!PS-Adobe-", buf, 11) != 0) {
5853 error("`%1' is not conforming to the Document Structuring Conventions",
5854 filename);
5855 return;
5856 }
5857 while (ps_get_line(buf, fp, filename) != 0) {
5858 if (buf[0] != '%' || buf[1] != '%'
5859 || strncmp(buf + 2, "EndComments", 11) == 0)
5860 break;
5861 if (strncmp(buf + 2, "BoundingBox:", 12) == 0) {
5862 int res = parse_bounding_box(buf + 14, &bb);
5863 if (res == 1) {
5864 assign_registers(bb.llx, bb.lly, bb.urx, bb.ury);
5865 return;
5866 }
5867 else if (res == 2) {
5868 bb_at_end = 1;
5869 break;
5870 }
5871 else {
5872 error("the arguments to the %%%%BoundingBox comment in `%1' are bad",
5873 filename);
5874 return;
5875 }
5876 }
5877 }
5878 if (bb_at_end) {
5879 long offset;
5880 int last_try = 0;
5881 /* in the trailer, the last BoundingBox comment is significant */
5882 for (offset = 512; !last_try; offset *= 2) {
5883 int had_trailer = 0;
5884 int got_bb = 0;
5885 if (offset > 32768 || fseek(fp, -offset, 2) == -1) {
5886 last_try = 1;
5887 if (fseek(fp, 0L, 0) == -1)
5888 break;
5889 }
5890 while (ps_get_line(buf, fp, filename) != 0) {
5891 if (buf[0] == '%' && buf[1] == '%') {
5892 if (!had_trailer) {
5893 if (strncmp(buf + 2, "Trailer", 7) == 0)
5894 had_trailer = 1;
5895 }
5896 else {
5897 if (strncmp(buf + 2, "BoundingBox:", 12) == 0) {
5898 int res = parse_bounding_box(buf + 14, &bb);
5899 if (res == 1)
5900 got_bb = 1;
5901 else if (res == 2) {
5902 error("`(atend)' not allowed in trailer of `%1'", filename);
5903 return;
5904 }
5905 else {
5906 error("the arguments to the %%%%BoundingBox comment in `%1' are bad",
5907 filename);
5908 return;
5909 }
5910 }
5911 }
5912 }
5913 }
5914 if (got_bb) {
5915 assign_registers(bb.llx, bb.lly, bb.urx, bb.ury);
5916 return;
5917 }
5918 }
5919 }
5920 error("%%%%BoundingBox comment not found in `%1'", filename);
5921 }
5922
5923 void ps_bbox_request()
5924 {
5925 symbol nm = get_long_name(1);
5926 if (nm.is_null())
5927 skip_line();
5928 else {
5929 while (!tok.newline() && !tok.eof())
5930 tok.next();
5931 errno = 0;
5932 // PS files might contain non-printable characters, such as ^Z
5933 // and CRs not followed by an LF, so open them in binary mode.
5934 FILE *fp = include_search_path.open_file_cautious(nm.contents(),
5935 0, FOPEN_RB);
5936 if (fp) {
5937 do_ps_file(fp, nm.contents());
5938 fclose(fp);
5939 }
5940 else
5941 error("can't open `%1': %2", nm.contents(), strerror(errno));
5942 tok.next();
5943 }
5944 }
5945
5946 const char *asciify(int c)
5947 {
5948 static char buf[3];
5949 buf[0] = escape_char == '\0' ? '\\' : escape_char;
5950 buf[1] = buf[2] = '\0';
5951 switch (c) {
5952 case ESCAPE_QUESTION:
5953 buf[1] = '?';
5954 break;
5955 case ESCAPE_AMPERSAND:
5956 buf[1] = '&';
5957 break;
5958 case ESCAPE_RIGHT_PARENTHESIS:
5959 buf[1] = ')';
5960 break;
5961 case ESCAPE_UNDERSCORE:
5962 buf[1] = '_';
5963 break;
5964 case ESCAPE_BAR:
5965 buf[1] = '|';
5966 break;
5967 case ESCAPE_CIRCUMFLEX:
5968 buf[1] = '^';
5969 break;
5970 case ESCAPE_LEFT_BRACE:
5971 buf[1] = '{';
5972 break;
5973 case ESCAPE_RIGHT_BRACE:
5974 buf[1] = '}';
5975 break;
5976 case ESCAPE_LEFT_QUOTE:
5977 buf[1] = '`';
5978 break;
5979 case ESCAPE_RIGHT_QUOTE:
5980 buf[1] = '\'';
5981 break;
5982 case ESCAPE_HYPHEN:
5983 buf[1] = '-';
5984 break;
5985 case ESCAPE_BANG:
5986 buf[1] = '!';
5987 break;
5988 case ESCAPE_c:
5989 buf[1] = 'c';
5990 break;
5991 case ESCAPE_e:
5992 buf[1] = 'e';
5993 break;
5994 case ESCAPE_E:
5995 buf[1] = 'E';
5996 break;
5997 case ESCAPE_PERCENT:
5998 buf[1] = '%';
5999 break;
6000 case ESCAPE_SPACE:
6001 buf[1] = ' ';
6002 break;
6003 case ESCAPE_TILDE:
6004 buf[1] = '~';
6005 break;
6006 case ESCAPE_COLON:
6007 buf[1] = ':';
6008 break;
6009 case PUSH_GROFF_MODE:
6010 case PUSH_COMP_MODE:
6011 case POP_GROFFCOMP_MODE:
6012 buf[0] = '\0';
6013 break;
6014 default:
6015 if (invalid_input_char(c))
6016 buf[0] = '\0';
6017 else
6018 buf[0] = c;
6019 break;
6020 }
6021 return buf;
6022 }
6023
6024 const char *input_char_description(int c)
6025 {
6026 switch (c) {
6027 case '\n':
6028 return "a newline character";
6029 case '\b':
6030 return "a backspace character";
6031 case '\001':
6032 return "a leader character";
6033 case '\t':
6034 return "a tab character";
6035 case ' ':
6036 return "a space character";
6037 case '\0':
6038 return "a node";
6039 }
6040 static char buf[sizeof("magic character code ") + 1 + INT_DIGITS];
6041 if (invalid_input_char(c)) {
6042 const char *s = asciify(c);
6043 if (*s) {
6044 buf[0] = '`';
6045 strcpy(buf + 1, s);
6046 strcat(buf, "'");
6047 return buf;
6048 }
6049 sprintf(buf, "magic character code %d", c);
6050 return buf;
6051 }
6052 if (csprint(c)) {
6053 buf[0] = '`';
6054 buf[1] = c;
6055 buf[2] = '\'';
6056 return buf;
6057 }
6058 sprintf(buf, "character code %d", c);
6059 return buf;
6060 }
6061
6062 void tag()
6063 {
6064 if (!tok.newline() && !tok.eof()) {
6065 string s;
6066 int c;
6067 for (;;) {
6068 c = get_copy(0);
6069 if (c == '"') {
6070 c = get_copy(0);
6071 break;
6072 }
6073 if (c != ' ' && c != '\t')
6074 break;
6075 }
6076 s = "x X ";
6077 for (; c != '\n' && c != EOF; c = get_copy(0))
6078 s += (char)c;
6079 s += '\n';
6080 curenv->add_node(new tag_node(s, 0));
6081 }
6082 tok.next();
6083 }
6084
6085 void taga()
6086 {
6087 if (!tok.newline() && !tok.eof()) {
6088 string s;
6089 int c;
6090 for (;;) {
6091 c = get_copy(0);
6092 if (c == '"') {
6093 c = get_copy(0);
6094 break;
6095 }
6096 if (c != ' ' && c != '\t')
6097 break;
6098 }
6099 s = "x X ";
6100 for (; c != '\n' && c != EOF; c = get_copy(0))
6101 s += (char)c;
6102 s += '\n';
6103 curenv->add_node(new tag_node(s, 1));
6104 }
6105 tok.next();
6106 }
6107
6108 // .tm, .tm1, and .tmc
6109
6110 void do_terminal(int newline, int string_like)
6111 {
6112 if (!tok.newline() && !tok.eof()) {
6113 int c;
6114 for (;;) {
6115 c = get_copy(0);
6116 if (string_like && c == '"') {
6117 c = get_copy(0);
6118 break;
6119 }
6120 if (c != ' ' && c != '\t')
6121 break;
6122 }
6123 for (; c != '\n' && c != EOF; c = get_copy(0))
6124 fputs(asciify(c), stderr);
6125 }
6126 if (newline)
6127 fputc('\n', stderr);
6128 fflush(stderr);
6129 tok.next();
6130 }
6131
6132 void terminal()
6133 {
6134 do_terminal(1, 0);
6135 }
6136
6137 void terminal1()
6138 {
6139 do_terminal(1, 1);
6140 }
6141
6142 void terminal_continue()
6143 {
6144 do_terminal(0, 1);
6145 }
6146
6147 dictionary stream_dictionary(20);
6148
6149 void do_open(int append)
6150 {
6151 symbol stream = get_name(1);
6152 if (!stream.is_null()) {
6153 symbol filename = get_long_name(1);
6154 if (!filename.is_null()) {
6155 errno = 0;
6156 FILE *fp = fopen(filename.contents(), append ? "a" : "w");
6157 if (!fp) {
6158 error("can't open `%1' for %2: %3",
6159 filename.contents(),
6160 append ? "appending" : "writing",
6161 strerror(errno));
6162 fp = (FILE *)stream_dictionary.remove(stream);
6163 }
6164 else
6165 fp = (FILE *)stream_dictionary.lookup(stream, fp);
6166 if (fp)
6167 fclose(fp);
6168 }
6169 }
6170 skip_line();
6171 }
6172
6173 void open_request()
6174 {
6175 if (safer_flag) {
6176 error(".open request not allowed in safer mode");
6177 skip_line();
6178 }
6179 else
6180 do_open(0);
6181 }
6182
6183 void opena_request()
6184 {
6185 if (safer_flag) {
6186 error(".opena request not allowed in safer mode");
6187 skip_line();
6188 }
6189 else
6190 do_open(1);
6191 }
6192
6193 void close_request()
6194 {
6195 symbol stream = get_name(1);
6196 if (!stream.is_null()) {
6197 FILE *fp = (FILE *)stream_dictionary.remove(stream);
6198 if (!fp)
6199 error("no stream named `%1'", stream.contents());
6200 else
6201 fclose(fp);
6202 }
6203 skip_line();
6204 }
6205
6206 // .write and .writec
6207
6208 void do_write_request(int newline)
6209 {
6210 symbol stream = get_name(1);
6211 if (stream.is_null()) {
6212 skip_line();
6213 return;
6214 }
6215 FILE *fp = (FILE *)stream_dictionary.lookup(stream);
6216 if (!fp) {
6217 error("no stream named `%1'", stream.contents());
6218 skip_line();
6219 return;
6220 }
6221 int c;
6222 while ((c = get_copy(0)) == ' ')
6223 ;
6224 if (c == '"')
6225 c = get_copy(0);
6226 for (; c != '\n' && c != EOF; c = get_copy(0))
6227 fputs(asciify(c), fp);
6228 if (newline)
6229 fputc('\n', fp);
6230 fflush(fp);
6231 tok.next();
6232 }
6233
6234 void write_request()
6235 {
6236 do_write_request(1);
6237 }
6238
6239 void write_request_continue()
6240 {
6241 do_write_request(0);
6242 }
6243
6244 void write_macro_request()
6245 {
6246 symbol stream = get_name(1);
6247 if (stream.is_null()) {
6248 skip_line();
6249 return;
6250 }
6251 FILE *fp = (FILE *)stream_dictionary.lookup(stream);
6252 if (!fp) {
6253 error("no stream named `%1'", stream.contents());
6254 skip_line();
6255 return;
6256 }
6257 symbol s = get_name(1);
6258 if (s.is_null()) {
6259 skip_line();
6260 return;
6261 }
6262 request_or_macro *p = lookup_request(s);
6263 macro *m = p->to_macro();
6264 if (!m)
6265 error("cannot write request");
6266 else {
6267 string_iterator iter(*m);
6268 for (;;) {
6269 int c = iter.get(0);
6270 if (c == EOF)
6271 break;
6272 fputs(asciify(c), fp);
6273 }
6274 fflush(fp);
6275 }
6276 skip_line();
6277 }
6278
6279 void warnscale_request()
6280 {
6281 if (has_arg()) {
6282 char c = tok.ch();
6283 if (c == 'u')
6284 warn_scale = 1.0;
6285 else if (c == 'i')
6286 warn_scale = (double)units_per_inch;
6287 else if (c == 'c')
6288 warn_scale = (double)units_per_inch / 2.54;
6289 else if (c == 'p')
6290 warn_scale = (double)units_per_inch / 72.0;
6291 else if (c == 'P')
6292 warn_scale = (double)units_per_inch / 6.0;
6293 else {
6294 warning(WARN_SCALE,
6295 "invalid scaling indicator `%1', using `i' instead", c);
6296 c = 'i';
6297 }
6298 warn_scaling_indicator = c;
6299 }
6300 skip_line();
6301 }
6302
6303 void spreadwarn_request()
6304 {
6305 hunits n;
6306 if (has_arg() && get_hunits(&n, 'm')) {
6307 if (n < 0)
6308 n = 0;
6309 hunits em = curenv->get_size();
6310 spread_limit = (double)n.to_units()
6311 / (em.is_zero() ? hresolution : em.to_units());
6312 }
6313 else
6314 spread_limit = -spread_limit - 1; // no arg toggles on/off without
6315 // changing value; we mirror at
6316 // -0.5 to make zero a valid value
6317 skip_line();
6318 }
6319
6320 static void init_charset_table()
6321 {
6322 char buf[16];
6323 strcpy(buf, "char");
6324 for (int i = 0; i < 256; i++) {
6325 strcpy(buf + 4, i_to_a(i));
6326 charset_table[i] = get_charinfo(symbol(buf));
6327 charset_table[i]->set_ascii_code(i);
6328 if (csalpha(i))
6329 charset_table[i]->set_hyphenation_code(cmlower(i));
6330 }
6331 charset_table['.']->set_flags(charinfo::ENDS_SENTENCE);
6332 charset_table['?']->set_flags(charinfo::ENDS_SENTENCE);
6333 charset_table['!']->set_flags(charinfo::ENDS_SENTENCE);
6334 charset_table['-']->set_flags(charinfo::BREAK_AFTER);
6335 charset_table['"']->set_flags(charinfo::TRANSPARENT);
6336 charset_table['\'']->set_flags(charinfo::TRANSPARENT);
6337 charset_table[')']->set_flags(charinfo::TRANSPARENT);
6338 charset_table[']']->set_flags(charinfo::TRANSPARENT);
6339 charset_table['*']->set_flags(charinfo::TRANSPARENT);
6340 get_charinfo(symbol("dg"))->set_flags(charinfo::TRANSPARENT);
6341 get_charinfo(symbol("rq"))->set_flags(charinfo::TRANSPARENT);
6342 get_charinfo(symbol("em"))->set_flags(charinfo::BREAK_AFTER);
6343 get_charinfo(symbol("ul"))->set_flags(charinfo::OVERLAPS_HORIZONTALLY);
6344 get_charinfo(symbol("rn"))->set_flags(charinfo::OVERLAPS_HORIZONTALLY);
6345 get_charinfo(symbol("radicalex"))->set_flags(charinfo::OVERLAPS_HORIZONTALLY);
6346 get_charinfo(symbol("sqrtex"))->set_flags(charinfo::OVERLAPS_HORIZONTALLY);
6347 get_charinfo(symbol("ru"))->set_flags(charinfo::OVERLAPS_HORIZONTALLY);
6348 get_charinfo(symbol("br"))->set_flags(charinfo::OVERLAPS_VERTICALLY);
6349 page_character = charset_table['%'];
6350 }
6351
6352 static void init_hpf_code_table()
6353 {
6354 for (int i = 0; i < 256; i++)
6355 hpf_code_table[i] = i;
6356 }
6357
6358 static void do_translate(int translate_transparent, int translate_input)
6359 {
6360 tok.skip();
6361 while (!tok.newline() && !tok.eof()) {
6362 if (tok.space()) {
6363 // This is a really bizarre troff feature.
6364 tok.next();
6365 translate_space_to_dummy = tok.dummy();
6366 if (tok.newline() || tok.eof())
6367 break;
6368 tok.next();
6369 continue;
6370 }
6371 charinfo *ci1 = tok.get_char(1);
6372 if (ci1 == 0)
6373 break;
6374 tok.next();
6375 if (tok.newline() || tok.eof()) {
6376 ci1->set_special_translation(charinfo::TRANSLATE_SPACE,
6377 translate_transparent);
6378 break;
6379 }
6380 if (tok.space())
6381 ci1->set_special_translation(charinfo::TRANSLATE_SPACE,
6382 translate_transparent);
6383 else if (tok.stretchable_space())
6384 ci1->set_special_translation(charinfo::TRANSLATE_STRETCHABLE_SPACE,
6385 translate_transparent);
6386 else if (tok.dummy())
6387 ci1->set_special_translation(charinfo::TRANSLATE_DUMMY,
6388 translate_transparent);
6389 else if (tok.hyphen_indicator())
6390 ci1->set_special_translation(charinfo::TRANSLATE_HYPHEN_INDICATOR,
6391 translate_transparent);
6392 else {
6393 charinfo *ci2 = tok.get_char(1);
6394 if (ci2 == 0)
6395 break;
6396 if (ci1 == ci2)
6397 ci1->set_translation(0, translate_transparent, translate_input);
6398 else
6399 ci1->set_translation(ci2, translate_transparent, translate_input);
6400 }
6401 tok.next();
6402 }
6403 skip_line();
6404 }
6405
6406 void translate()
6407 {
6408 do_translate(1, 0);
6409 }
6410
6411 void translate_no_transparent()
6412 {
6413 do_translate(0, 0);
6414 }
6415
6416 void translate_input()
6417 {
6418 do_translate(1, 1);
6419 }
6420
6421 void char_flags()
6422 {
6423 int flags;
6424 if (get_integer(&flags))
6425 while (has_arg()) {
6426 charinfo *ci = tok.get_char(1);
6427 if (ci) {
6428 charinfo *tem = ci->get_translation();
6429 if (tem)
6430 ci = tem;
6431 ci->set_flags(flags);
6432 }
6433 tok.next();
6434 }
6435 skip_line();
6436 }
6437
6438 void hyphenation_code()
6439 {
6440 tok.skip();
6441 while (!tok.newline() && !tok.eof()) {
6442 charinfo *ci = tok.get_char(1);
6443 if (ci == 0)
6444 break;
6445 tok.next();
6446 tok.skip();
6447 unsigned char c = tok.ch();
6448 if (c == 0) {
6449 error("hyphenation code must be ordinary character");
6450 break;
6451 }
6452 if (csdigit(c)) {
6453 error("hyphenation code cannot be digit");
6454 break;
6455 }
6456 ci->set_hyphenation_code(c);
6457 if (ci->get_translation()
6458 && ci->get_translation()->get_translation_input())
6459 ci->get_translation()->set_hyphenation_code(c);
6460 tok.next();
6461 tok.skip();
6462 }
6463 skip_line();
6464 }
6465
6466 void hyphenation_patterns_file_code()
6467 {
6468 tok.skip();
6469 while (!tok.newline() && !tok.eof()) {
6470 int n1, n2;
6471 if (get_integer(&n1) && (0 <= n1 && n1 <= 255)) {
6472 if (!has_arg()) {
6473 error("missing output hyphenation code");
6474 break;
6475 }
6476 if (get_integer(&n2) && (0 <= n2 && n2 <= 255)) {
6477 hpf_code_table[n1] = n2;
6478 tok.skip();
6479 }
6480 else {
6481 error("output hyphenation code must be integer in the range 0..255");
6482 break;
6483 }
6484 }
6485 else {
6486 error("input hyphenation code must be integer in the range 0..255");
6487 break;
6488 }
6489 }
6490 skip_line();
6491 }
6492
6493 charinfo *token::get_char(int required)
6494 {
6495 if (type == TOKEN_CHAR)
6496 return charset_table[c];
6497 if (type == TOKEN_SPECIAL)
6498 return get_charinfo(nm);
6499 if (type == TOKEN_NUMBERED_CHAR)
6500 return get_charinfo_by_number(val);
6501 if (type == TOKEN_ESCAPE) {
6502 if (escape_char != 0)
6503 return charset_table[escape_char];
6504 else {
6505 error("`\\e' used while no current escape character");
6506 return 0;
6507 }
6508 }
6509 if (required) {
6510 if (type == TOKEN_EOF || type == TOKEN_NEWLINE)
6511 warning(WARN_MISSING, "missing normal or special character");
6512 else
6513 error("normal or special character expected (got %1)", description());
6514 }
6515 return 0;
6516 }
6517
6518 charinfo *get_optional_char()
6519 {
6520 while (tok.space())
6521 tok.next();
6522 charinfo *ci = tok.get_char();
6523 if (!ci)
6524 check_missing_character();
6525 else
6526 tok.next();
6527 return ci;
6528 }
6529
6530 void check_missing_character()
6531 {
6532 if (!tok.newline() && !tok.eof() && !tok.right_brace() && !tok.tab())
6533 error("normal or special character expected (got %1): "
6534 "treated as missing",
6535 tok.description());
6536 }
6537
6538 // this is for \Z
6539
6540 int token::add_to_node_list(node **pp)
6541 {
6542 hunits w;
6543 int s;
6544 node *n = 0;
6545 switch (type) {
6546 case TOKEN_CHAR:
6547 *pp = (*pp)->add_char(charset_table[c], curenv, &w, &s);
6548 break;
6549 case TOKEN_DUMMY:
6550 n = new dummy_node;
6551 break;
6552 case TOKEN_ESCAPE:
6553 if (escape_char != 0)
6554 *pp = (*pp)->add_char(charset_table[escape_char], curenv, &w, &s);
6555 break;
6556 case TOKEN_HYPHEN_INDICATOR:
6557 *pp = (*pp)->add_discretionary_hyphen();
6558 break;
6559 case TOKEN_ITALIC_CORRECTION:
6560 *pp = (*pp)->add_italic_correction(&w);
6561 break;
6562 case TOKEN_LEFT_BRACE:
6563 break;
6564 case TOKEN_MARK_INPUT:
6565 set_number_reg(nm, curenv->get_input_line_position().to_units());
6566 break;
6567 case TOKEN_NODE:
6568 n = nd;
6569 nd = 0;
6570 break;
6571 case TOKEN_NUMBERED_CHAR:
6572 *pp = (*pp)->add_char(get_charinfo_by_number(val), curenv, &w, &s);
6573 break;
6574 case TOKEN_RIGHT_BRACE:
6575 break;
6576 case TOKEN_SPACE:
6577 n = new hmotion_node(curenv->get_space_width(),
6578 curenv->get_fill_color());
6579 break;
6580 case TOKEN_SPECIAL:
6581 *pp = (*pp)->add_char(get_charinfo(nm), curenv, &w, &s);
6582 break;
6583 case TOKEN_STRETCHABLE_SPACE:
6584 n = new unbreakable_space_node(curenv->get_space_width(),
6585 curenv->get_fill_color());
6586 break;
6587 case TOKEN_UNSTRETCHABLE_SPACE:
6588 n = new space_char_hmotion_node(curenv->get_space_width(),
6589 curenv->get_fill_color());
6590 break;
6591 case TOKEN_TRANSPARENT_DUMMY:
6592 n = new transparent_dummy_node;
6593 break;
6594 case TOKEN_ZERO_WIDTH_BREAK:
6595 n = new space_node(H0, curenv->get_fill_color());
6596 n->freeze_space();
6597 n->is_escape_colon();
6598 break;
6599 default:
6600 return 0;
6601 }
6602 if (n) {
6603 n->next = *pp;
6604 *pp = n;
6605 }
6606 return 1;
6607 }
6608
6609 void token::process()
6610 {
6611 if (possibly_handle_first_page_transition())
6612 return;
6613 switch (type) {
6614 case TOKEN_BACKSPACE:
6615 curenv->add_node(new hmotion_node(-curenv->get_space_width(),
6616 curenv->get_fill_color()));
6617 break;
6618 case TOKEN_CHAR:
6619 curenv->add_char(charset_table[c]);
6620 break;
6621 case TOKEN_DUMMY:
6622 curenv->add_node(new dummy_node);
6623 break;
6624 case TOKEN_EMPTY:
6625 assert(0);
6626 break;
6627 case TOKEN_EOF:
6628 assert(0);
6629 break;
6630 case TOKEN_ESCAPE:
6631 if (escape_char != 0)
6632 curenv->add_char(charset_table[escape_char]);
6633 break;
6634 case TOKEN_BEGIN_TRAP:
6635 case TOKEN_END_TRAP:
6636 case TOKEN_PAGE_EJECTOR:
6637 // these are all handled in process_input_stack()
6638 break;
6639 case TOKEN_HYPHEN_INDICATOR:
6640 curenv->add_hyphen_indicator();
6641 break;
6642 case TOKEN_INTERRUPT:
6643 curenv->interrupt();
6644 break;
6645 case TOKEN_ITALIC_CORRECTION:
6646 curenv->add_italic_correction();
6647 break;
6648 case TOKEN_LEADER:
6649 curenv->handle_tab(1);
6650 break;
6651 case TOKEN_LEFT_BRACE:
6652 break;
6653 case TOKEN_MARK_INPUT:
6654 set_number_reg(nm, curenv->get_input_line_position().to_units());
6655 break;
6656 case TOKEN_NEWLINE:
6657 curenv->newline();
6658 break;
6659 case TOKEN_NODE:
6660 curenv->add_node(nd);
6661 nd = 0;
6662 break;
6663 case TOKEN_NUMBERED_CHAR:
6664 curenv->add_char(get_charinfo_by_number(val));
6665 break;
6666 case TOKEN_REQUEST:
6667 // handled in process_input_stack()
6668 break;
6669 case TOKEN_RIGHT_BRACE:
6670 break;
6671 case TOKEN_SPACE:
6672 curenv->space();
6673 break;
6674 case TOKEN_SPECIAL:
6675 curenv->add_char(get_charinfo(nm));
6676 break;
6677 case TOKEN_SPREAD:
6678 curenv->spread();
6679 break;
6680 case TOKEN_STRETCHABLE_SPACE:
6681 curenv->add_node(new unbreakable_space_node(curenv->get_space_width(),
6682 curenv->get_fill_color()));
6683 break;
6684 case TOKEN_UNSTRETCHABLE_SPACE:
6685 curenv->add_node(new space_char_hmotion_node(curenv->get_space_width(),
6686 curenv->get_fill_color()));
6687 break;
6688 case TOKEN_TAB:
6689 curenv->handle_tab(0);
6690 break;
6691 case TOKEN_TRANSPARENT:
6692 break;
6693 case TOKEN_TRANSPARENT_DUMMY:
6694 curenv->add_node(new transparent_dummy_node);
6695 break;
6696 case TOKEN_ZERO_WIDTH_BREAK:
6697 {
6698 node *tmp = new space_node(H0, curenv->get_fill_color());
6699 tmp->freeze_space();
6700 tmp->is_escape_colon();
6701 curenv->add_node(tmp);
6702 break;
6703 }
6704 default:
6705 assert(0);
6706 }
6707 }
6708
6709 class nargs_reg : public reg {
6710 public:
6711 const char *get_string();
6712 };
6713
6714 const char *nargs_reg::get_string()
6715 {
6716 return i_to_a(input_stack::nargs());
6717 }
6718
6719 class lineno_reg : public reg {
6720 public:
6721 const char *get_string();
6722 };
6723
6724 const char *lineno_reg::get_string()
6725 {
6726 int line;
6727 const char *file;
6728 if (!input_stack::get_location(0, &file, &line))
6729 line = 0;
6730 return i_to_a(line);
6731 }
6732
6733 class writable_lineno_reg : public general_reg {
6734 public:
6735 writable_lineno_reg();
6736 void set_value(units);
6737 int get_value(units *);
6738 };
6739
6740 writable_lineno_reg::writable_lineno_reg()
6741 {
6742 }
6743
6744 int writable_lineno_reg::get_value(units *res)
6745 {
6746 int line;
6747 const char *file;
6748 if (!input_stack::get_location(0, &file, &line))
6749 return 0;
6750 *res = line;
6751 return 1;
6752 }
6753
6754 void writable_lineno_reg::set_value(units n)
6755 {
6756 input_stack::set_location(0, n);
6757 }
6758
6759 class filename_reg : public reg {
6760 public:
6761 const char *get_string();
6762 };
6763
6764 const char *filename_reg::get_string()
6765 {
6766 int line;
6767 const char *file;
6768 if (input_stack::get_location(0, &file, &line))
6769 return file;
6770 else
6771 return 0;
6772 }
6773
6774 class constant_reg : public reg {
6775 const char *s;
6776 public:
6777 constant_reg(const char *);
6778 const char *get_string();
6779 };
6780
6781 constant_reg::constant_reg(const char *p) : s(p)
6782 {
6783 }
6784
6785 const char *constant_reg::get_string()
6786 {
6787 return s;
6788 }
6789
6790 constant_int_reg::constant_int_reg(int *q) : p(q)
6791 {
6792 }
6793
6794 const char *constant_int_reg::get_string()
6795 {
6796 return i_to_a(*p);
6797 }
6798
6799 void abort_request()
6800 {
6801 int c;
6802 if (tok.eof())
6803 c = EOF;
6804 else if (tok.newline())
6805 c = '\n';
6806 else {
6807 while ((c = get_copy(0)) == ' ')
6808 ;
6809 }
6810 if (c == EOF || c == '\n')
6811 fputs("User Abort.", stderr);
6812 else {
6813 for (; c != '\n' && c != EOF; c = get_copy(0))
6814 fputs(asciify(c), stderr);
6815 }
6816 fputc('\n', stderr);
6817 cleanup_and_exit(1);
6818 }
6819
6820 char *read_string()
6821 {
6822 int len = 256;
6823 char *s = new char[len];
6824 int c;
6825 while ((c = get_copy(0)) == ' ')
6826 ;
6827 int i = 0;
6828 while (c != '\n' && c != EOF) {
6829 if (!invalid_input_char(c)) {
6830 if (i + 2 > len) {
6831 char *tem = s;
6832 s = new char[len*2];
6833 memcpy(s, tem, len);
6834 len *= 2;
6835 a_delete tem;
6836 }
6837 s[i++] = c;
6838 }
6839 c = get_copy(0);
6840 }
6841 s[i] = '\0';
6842 tok.next();
6843 if (i == 0) {
6844 a_delete s;
6845 return 0;
6846 }
6847 return s;
6848 }
6849
6850 void pipe_output()
6851 {
6852 if (safer_flag) {
6853 error(".pi request not allowed in safer mode");
6854 skip_line();
6855 }
6856 else {
6857 #ifdef POPEN_MISSING
6858 error("pipes not available on this system");
6859 skip_line();
6860 #else /* not POPEN_MISSING */
6861 if (the_output) {
6862 error("can't pipe: output already started");
6863 skip_line();
6864 }
6865 else {
6866 char *pc;
6867 if ((pc = read_string()) == 0)
6868 error("can't pipe to empty command");
6869 if (pipe_command) {
6870 char *s = new char[strlen(pipe_command) + strlen(pc) + 1 + 1];
6871 strcpy(s, pipe_command);
6872 strcat(s, "|");
6873 strcat(s, pc);
6874 a_delete pipe_command;
6875 a_delete pc;
6876 pipe_command = s;
6877 }
6878 else
6879 pipe_command = pc;
6880 }
6881 #endif /* not POPEN_MISSING */
6882 }
6883 }
6884
6885 static int system_status;
6886
6887 void system_request()
6888 {
6889 if (safer_flag) {
6890 error(".sy request not allowed in safer mode");
6891 skip_line();
6892 }
6893 else {
6894 char *command = read_string();
6895 if (!command)
6896 error("empty command");
6897 else {
6898 system_status = system(command);
6899 a_delete command;
6900 }
6901 }
6902 }
6903
6904 void copy_file()
6905 {
6906 if (curdiv == topdiv && topdiv->before_first_page) {
6907 handle_initial_request(COPY_FILE_REQUEST);
6908 return;
6909 }
6910 symbol filename = get_long_name(1);
6911 while (!tok.newline() && !tok.eof())
6912 tok.next();
6913 if (break_flag)
6914 curenv->do_break();
6915 if (!filename.is_null())
6916 curdiv->copy_file(filename.contents());
6917 tok.next();
6918 }
6919
6920 #ifdef COLUMN
6921
6922 void vjustify()
6923 {
6924 if (curdiv == topdiv && topdiv->before_first_page) {
6925 handle_initial_request(VJUSTIFY_REQUEST);
6926 return;
6927 }
6928 symbol type = get_long_name(1);
6929 if (!type.is_null())
6930 curdiv->vjustify(type);
6931 skip_line();
6932 }
6933
6934 #endif /* COLUMN */
6935
6936 void transparent_file()
6937 {
6938 if (curdiv == topdiv && topdiv->before_first_page) {
6939 handle_initial_request(TRANSPARENT_FILE_REQUEST);
6940 return;
6941 }
6942 symbol filename = get_long_name(1);
6943 while (!tok.newline() && !tok.eof())
6944 tok.next();
6945 if (break_flag)
6946 curenv->do_break();
6947 if (!filename.is_null()) {
6948 errno = 0;
6949 FILE *fp = include_search_path.open_file_cautious(filename.contents());
6950 if (!fp)
6951 error("can't open `%1': %2", filename.contents(), strerror(errno));
6952 else {
6953 int bol = 1;
6954 for (;;) {
6955 int c = getc(fp);
6956 if (c == EOF)
6957 break;
6958 if (invalid_input_char(c))
6959 warning(WARN_INPUT, "invalid input character code %1", int(c));
6960 else {
6961 curdiv->transparent_output(c);
6962 bol = c == '\n';
6963 }
6964 }
6965 if (!bol)
6966 curdiv->transparent_output('\n');
6967 fclose(fp);
6968 }
6969 }
6970 tok.next();
6971 }
6972
6973 class page_range {
6974 int first;
6975 int last;
6976 public:
6977 page_range *next;
6978 page_range(int, int, page_range *);
6979 int contains(int n);
6980 };
6981
6982 page_range::page_range(int i, int j, page_range *p)
6983 : first(i), last(j), next(p)
6984 {
6985 }
6986
6987 int page_range::contains(int n)
6988 {
6989 return n >= first && (last <= 0 || n <= last);
6990 }
6991
6992 page_range *output_page_list = 0;
6993
6994 int in_output_page_list(int n)
6995 {
6996 if (!output_page_list)
6997 return 1;
6998 for (page_range *p = output_page_list; p; p = p->next)
6999 if (p->contains(n))
7000 return 1;
7001 return 0;
7002 }
7003
7004 static void parse_output_page_list(char *p)
7005 {
7006 for (;;) {
7007 int i;
7008 if (*p == '-')
7009 i = 1;
7010 else if (csdigit(*p)) {
7011 i = 0;
7012 do
7013 i = i*10 + *p++ - '0';
7014 while (csdigit(*p));
7015 }
7016 else
7017 break;
7018 int j;
7019 if (*p == '-') {
7020 p++;
7021 j = 0;
7022 if (csdigit(*p)) {
7023 do
7024 j = j*10 + *p++ - '0';
7025 while (csdigit(*p));
7026 }
7027 }
7028 else
7029 j = i;
7030 if (j == 0)
7031 last_page_number = -1;
7032 else if (last_page_number >= 0 && j > last_page_number)
7033 last_page_number = j;
7034 output_page_list = new page_range(i, j, output_page_list);
7035 if (*p != ',')
7036 break;
7037 ++p;
7038 }
7039 if (*p != '\0') {
7040 error("bad output page list");
7041 output_page_list = 0;
7042 }
7043 }
7044
7045 static FILE *open_mac_file(const char *mac, char **path)
7046 {
7047 // Try first FOOBAR.tmac, then tmac.FOOBAR
7048 char *s1 = new char[strlen(mac)+strlen(MACRO_POSTFIX)+1];
7049 strcpy(s1, mac);
7050 strcat(s1, MACRO_POSTFIX);
7051 FILE *fp = mac_path->open_file(s1, path);
7052 a_delete s1;
7053 if (!fp) {
7054 char *s2 = new char[strlen(mac)+strlen(MACRO_PREFIX)+1];
7055 strcpy(s2, MACRO_PREFIX);
7056 strcat(s2, mac);
7057 fp = mac_path->open_file(s2, path);
7058 a_delete s2;
7059 }
7060 return fp;
7061 }
7062
7063 static void process_macro_file(const char *mac)
7064 {
7065 char *path;
7066 FILE *fp = open_mac_file(mac, &path);
7067 if (!fp)
7068 fatal("can't find macro file %1", mac);
7069 const char *s = symbol(path).contents();
7070 a_delete path;
7071 input_stack::push(new file_iterator(fp, s));
7072 tok.next();
7073 process_input_stack();
7074 }
7075
7076 static void process_startup_file(const char *filename)
7077 {
7078 char *path;
7079 search_path *orig_mac_path = mac_path;
7080 mac_path = &config_macro_path;
7081 FILE *fp = mac_path->open_file(filename, &path);
7082 if (fp) {
7083 input_stack::push(new file_iterator(fp, symbol(path).contents()));
7084 a_delete path;
7085 tok.next();
7086 process_input_stack();
7087 }
7088 mac_path = orig_mac_path;
7089 }
7090
7091 void macro_source()
7092 {
7093 symbol nm = get_long_name(1);
7094 if (nm.is_null())
7095 skip_line();
7096 else {
7097 while (!tok.newline() && !tok.eof())
7098 tok.next();
7099 char *path;
7100 FILE *fp = mac_path->open_file(nm.contents(), &path);
7101 // .mso doesn't (and cannot) go through open_mac_file, so we
7102 // need to do it here manually: If we have tmac.FOOBAR, try
7103 // FOOBAR.tmac and vice versa
7104 if (!fp) {
7105 const char *fn = nm.contents();
7106 if (strncasecmp(fn, MACRO_PREFIX, sizeof(MACRO_PREFIX) - 1) == 0) {
7107 char *s = new char[strlen(fn) + sizeof(MACRO_POSTFIX)];
7108 strcpy(s, fn + sizeof(MACRO_PREFIX) - 1);
7109 strcat(s, MACRO_POSTFIX);
7110 fp = mac_path->open_file(s, &path);
7111 a_delete s;
7112 }
7113 if (!fp) {
7114 if (strncasecmp(fn + strlen(fn) - sizeof(MACRO_POSTFIX) + 1,
7115 MACRO_POSTFIX, sizeof(MACRO_POSTFIX) - 1) == 0) {
7116 char *s = new char[strlen(fn) + sizeof(MACRO_PREFIX)];
7117 strcpy(s, MACRO_PREFIX);
7118 strncat(s, fn, strlen(fn) - sizeof(MACRO_POSTFIX) + 1);
7119 fp = mac_path->open_file(s, &path);
7120 a_delete s;
7121 }
7122 }
7123 }
7124 if (fp) {
7125 input_stack::push(new file_iterator(fp, symbol(path).contents()));
7126 a_delete path;
7127 }
7128 else
7129 error("can't find macro file `%1'", nm.contents());
7130 tok.next();
7131 }
7132 }
7133
7134 static void process_input_file(const char *name)
7135 {
7136 FILE *fp;
7137 if (strcmp(name, "-") == 0) {
7138 clearerr(stdin);
7139 fp = stdin;
7140 }
7141 else {
7142 errno = 0;
7143 fp = include_search_path.open_file_cautious(name);
7144 if (!fp)
7145 fatal("can't open `%1': %2", name, strerror(errno));
7146 }
7147 input_stack::push(new file_iterator(fp, name));
7148 tok.next();
7149 process_input_stack();
7150 }
7151
7152 // make sure the_input is empty before calling this
7153
7154 static int evaluate_expression(const char *expr, units *res)
7155 {
7156 input_stack::push(make_temp_iterator(expr));
7157 tok.next();
7158 int success = get_number(res, 'u');
7159 while (input_stack::get(0) != EOF)
7160 ;
7161 return success;
7162 }
7163
7164 static void do_register_assignment(const char *s)
7165 {
7166 const char *p = strchr(s, '=');
7167 if (!p) {
7168 char buf[2];
7169 buf[0] = s[0];
7170 buf[1] = 0;
7171 units n;
7172 if (evaluate_expression(s + 1, &n))
7173 set_number_reg(buf, n);
7174 }
7175 else {
7176 char *buf = new char[p - s + 1];
7177 memcpy(buf, s, p - s);
7178 buf[p - s] = 0;
7179 units n;
7180 if (evaluate_expression(p + 1, &n))
7181 set_number_reg(buf, n);
7182 a_delete buf;
7183 }
7184 }
7185
7186 static void set_string(const char *name, const char *value)
7187 {
7188 macro *m = new macro;
7189 for (const char *p = value; *p; p++)
7190 if (!invalid_input_char((unsigned char)*p))
7191 m->append(*p);
7192 request_dictionary.define(name, m);
7193 }
7194
7195 static void do_string_assignment(const char *s)
7196 {
7197 const char *p = strchr(s, '=');
7198 if (!p) {
7199 char buf[2];
7200 buf[0] = s[0];
7201 buf[1] = 0;
7202 set_string(buf, s + 1);
7203 }
7204 else {
7205 char *buf = new char[p - s + 1];
7206 memcpy(buf, s, p - s);
7207 buf[p - s] = 0;
7208 set_string(buf, p + 1);
7209 a_delete buf;
7210 }
7211 }
7212
7213 struct string_list {
7214 const char *s;
7215 string_list *next;
7216 string_list(const char *ss) : s(ss), next(0) {}
7217 };
7218
7219 #if 0
7220 static void prepend_string(const char *s, string_list **p)
7221 {
7222 string_list *l = new string_list(s);
7223 l->next = *p;
7224 *p = l;
7225 }
7226 #endif
7227
7228 static void add_string(const char *s, string_list **p)
7229 {
7230 while (*p)
7231 p = &((*p)->next);
7232 *p = new string_list(s);
7233 }
7234
7235 void usage(FILE *stream, const char *prog)
7236 {
7237 fprintf(stream,
7238 "usage: %s -abcivzCERU -wname -Wname -dcs -ffam -mname -nnum -olist\n"
7239 " -rcn -Tname -Fdir -Idir -Mdir [files...]\n",
7240 prog);
7241 }
7242
7243 int main(int argc, char **argv)
7244 {
7245 program_name = argv[0];
7246 static char stderr_buf[BUFSIZ];
7247 setbuf(stderr, stderr_buf);
7248 int c;
7249 string_list *macros = 0;
7250 string_list *register_assignments = 0;
7251 string_list *string_assignments = 0;
7252 int iflag = 0;
7253 int tflag = 0;
7254 int fflag = 0;
7255 int nflag = 0;
7256 int no_rc = 0; // don't process troffrc and troffrc-end
7257 int next_page_number = 0; // pacify compiler
7258 opterr = 0;
7259 hresolution = vresolution = 1;
7260 // restore $PATH if called from groff
7261 char* groff_path = getenv("GROFF_PATH__");
7262 if (groff_path) {
7263 string e = "PATH";
7264 e += '=';
7265 if (*groff_path)
7266 e += groff_path;
7267 e += '\0';
7268 if (putenv(strsave(e.contents())))
7269 fatal("putenv failed");
7270 }
7271 static const struct option long_options[] = {
7272 { "help", no_argument, 0, CHAR_MAX + 1 },
7273 { "version", no_argument, 0, 'v' },
7274 { 0, 0, 0, 0 }
7275 };
7276 #if defined(DEBUGGING)
7277 #define DEBUG_OPTION "D"
7278 #endif
7279 while ((c = getopt_long(argc, argv,
7280 "abciI:vw:W:zCEf:m:n:o:r:d:F:M:T:tqs:RU"
7281 DEBUG_OPTION, long_options, 0))
7282 != EOF)
7283 switch(c) {
7284 case 'v':
7285 {
7286 printf("GNU troff (groff) version %s\n", Version_string);
7287 exit(0);
7288 break;
7289 }
7290 case 'I':
7291 // Search path for .psbb files
7292 // and most other non-system input files.
7293 include_search_path.command_line_dir(optarg);
7294 break;
7295 case 'T':
7296 device = optarg;
7297 tflag = 1;
7298 is_html = (strcmp(device, "html") == 0);
7299 break;
7300 case 'C':
7301 compatible_flag = 1;
7302 // fall through
7303 case 'c':
7304 color_flag = 0;
7305 break;
7306 case 'M':
7307 macro_path.command_line_dir(optarg);
7308 safer_macro_path.command_line_dir(optarg);
7309 config_macro_path.command_line_dir(optarg);
7310 break;
7311 case 'F':
7312 font::command_line_font_dir(optarg);
7313 break;
7314 case 'm':
7315 add_string(optarg, &macros);
7316 break;
7317 case 'E':
7318 inhibit_errors = 1;
7319 break;
7320 case 'R':
7321 no_rc = 1;
7322 break;
7323 case 'w':
7324 enable_warning(optarg);
7325 break;
7326 case 'W':
7327 disable_warning(optarg);
7328 break;
7329 case 'i':
7330 iflag = 1;
7331 break;
7332 case 'b':
7333 backtrace_flag = 1;
7334 break;
7335 case 'a':
7336 ascii_output_flag = 1;
7337 break;
7338 case 'z':
7339 suppress_output_flag = 1;
7340 break;
7341 case 'n':
7342 if (sscanf(optarg, "%d", &next_page_number) == 1)
7343 nflag++;
7344 else
7345 error("bad page number");
7346 break;
7347 case 'o':
7348 parse_output_page_list(optarg);
7349 break;
7350 case 'd':
7351 if (*optarg == '\0')
7352 error("`-d' requires non-empty argument");
7353 else
7354 add_string(optarg, &string_assignments);
7355 break;
7356 case 'r':
7357 if (*optarg == '\0')
7358 error("`-r' requires non-empty argument");
7359 else
7360 add_string(optarg, &register_assignments);
7361 break;
7362 case 'f':
7363 default_family = symbol(optarg);
7364 fflag = 1;
7365 break;
7366 case 'q':
7367 case 's':
7368 case 't':
7369 // silently ignore these
7370 break;
7371 case 'U':
7372 safer_flag = 0; // unsafe behaviour
7373 break;
7374 #if defined(DEBUGGING)
7375 case 'D':
7376 debug_state = 1;
7377 break;
7378 #endif
7379 case CHAR_MAX + 1: // --help
7380 usage(stdout, argv[0]);
7381 exit(0);
7382 break;
7383 case '?':
7384 usage(stderr, argv[0]);
7385 exit(1);
7386 break; // never reached
7387 default:
7388 assert(0);
7389 }
7390 if (!safer_flag)
7391 mac_path = &macro_path;
7392 set_string(".T", device);
7393 init_charset_table();
7394 init_hpf_code_table();
7395 if (!font::load_desc())
7396 fatal("sorry, I can't continue");
7397 units_per_inch = font::res;
7398 hresolution = font::hor;
7399 vresolution = font::vert;
7400 sizescale = font::sizescale;
7401 tcommand_flag = font::tcommand;
7402 warn_scale = (double)units_per_inch;
7403 warn_scaling_indicator = 'i';
7404 if (!fflag && font::family != 0 && *font::family != '\0')
7405 default_family = symbol(font::family);
7406 font_size::init_size_table(font::sizes);
7407 int i;
7408 int j = 1;
7409 if (font::style_table) {
7410 for (i = 0; font::style_table[i]; i++)
7411 mount_style(j++, symbol(font::style_table[i]));
7412 }
7413 for (i = 0; font::font_name_table[i]; i++, j++)
7414 // In the DESC file a font name of 0 (zero) means leave this
7415 // position empty.
7416 if (strcmp(font::font_name_table[i], "0") != 0)
7417 mount_font(j, symbol(font::font_name_table[i]));
7418 curdiv = topdiv = new top_level_diversion;
7419 if (nflag)
7420 topdiv->set_next_page_number(next_page_number);
7421 init_input_requests();
7422 init_env_requests();
7423 init_div_requests();
7424 #ifdef COLUMN
7425 init_column_requests();
7426 #endif /* COLUMN */
7427 init_node_requests();
7428 number_reg_dictionary.define(".T", new constant_reg(tflag ? "1" : "0"));
7429 init_registers();
7430 init_reg_requests();
7431 init_hyphen_requests();
7432 init_environments();
7433 while (string_assignments) {
7434 do_string_assignment(string_assignments->s);
7435 string_list *tem = string_assignments;
7436 string_assignments = string_assignments->next;
7437 delete tem;
7438 }
7439 while (register_assignments) {
7440 do_register_assignment(register_assignments->s);
7441 string_list *tem = register_assignments;
7442 register_assignments = register_assignments->next;
7443 delete tem;
7444 }
7445 if (!no_rc)
7446 process_startup_file(INITIAL_STARTUP_FILE);
7447 while (macros) {
7448 process_macro_file(macros->s);
7449 string_list *tem = macros;
7450 macros = macros->next;
7451 delete tem;
7452 }
7453 if (!no_rc)
7454 process_startup_file(FINAL_STARTUP_FILE);
7455 for (i = optind; i < argc; i++)
7456 process_input_file(argv[i]);
7457 if (optind >= argc || iflag)
7458 process_input_file("-");
7459 exit_troff();
7460 return 0; // not reached
7461 }
7462
7463 void warn_request()
7464 {
7465 int n;
7466 if (has_arg() && get_integer(&n)) {
7467 if (n & ~WARN_TOTAL) {
7468 warning(WARN_RANGE, "warning mask must be between 0 and %1", WARN_TOTAL);
7469 n &= WARN_TOTAL;
7470 }
7471 warning_mask = n;
7472 }
7473 else
7474 warning_mask = WARN_TOTAL;
7475 skip_line();
7476 }
7477
7478 static void init_registers()
7479 {
7480 #ifdef LONG_FOR_TIME_T
7481 long
7482 #else /* not LONG_FOR_TIME_T */
7483 time_t
7484 #endif /* not LONG_FOR_TIME_T */
7485 t = time(0);
7486 // Use struct here to work around misfeature in old versions of g++.
7487 struct tm *tt = localtime(&t);
7488 set_number_reg("seconds", int(tt->tm_sec));
7489 set_number_reg("minutes", int(tt->tm_min));
7490 set_number_reg("hours", int(tt->tm_hour));
7491 set_number_reg("dw", int(tt->tm_wday + 1));
7492 set_number_reg("dy", int(tt->tm_mday));
7493 set_number_reg("mo", int(tt->tm_mon + 1));
7494 set_number_reg("year", int(1900 + tt->tm_year));
7495 set_number_reg("yr", int(tt->tm_year));
7496 set_number_reg("$$", getpid());
7497 number_reg_dictionary.define(".A",
7498 new constant_reg(ascii_output_flag
7499 ? "1"
7500 : "0"));
7501 }
7502
7503 /*
7504 * registers associated with \O
7505 */
7506
7507 static int output_reg_minx_contents = -1;
7508 static int output_reg_miny_contents = -1;
7509 static int output_reg_maxx_contents = -1;
7510 static int output_reg_maxy_contents = -1;
7511
7512 void check_output_limits(int x, int y)
7513 {
7514 if ((output_reg_minx_contents == -1) || (x < output_reg_minx_contents))
7515 output_reg_minx_contents = x;
7516 if (x > output_reg_maxx_contents)
7517 output_reg_maxx_contents = x;
7518 if ((output_reg_miny_contents == -1) || (y < output_reg_miny_contents))
7519 output_reg_miny_contents = y;
7520 if (y > output_reg_maxy_contents)
7521 output_reg_maxy_contents = y;
7522 }
7523
7524 void reset_output_registers()
7525 {
7526 output_reg_minx_contents = -1;
7527 output_reg_miny_contents = -1;
7528 output_reg_maxx_contents = -1;
7529 output_reg_maxy_contents = -1;
7530 }
7531
7532 void get_output_registers(int *minx, int *miny, int *maxx, int *maxy)
7533 {
7534 *minx = output_reg_minx_contents;
7535 *miny = output_reg_miny_contents;
7536 *maxx = output_reg_maxx_contents;
7537 *maxy = output_reg_maxy_contents;
7538 }
7539
7540 void init_input_requests()
7541 {
7542 init_request("ab", abort_request);
7543 init_request("als", alias_macro);
7544 init_request("am", append_macro);
7545 init_request("am1", append_nocomp_macro);
7546 init_request("ami", append_indirect_macro);
7547 init_request("ami1", append_indirect_nocomp_macro);
7548 init_request("as", append_string);
7549 init_request("as1", append_nocomp_string);
7550 init_request("asciify", asciify_macro);
7551 init_request("backtrace", backtrace_request);
7552 init_request("blm", blank_line_macro);
7553 init_request("break", while_break_request);
7554 init_request("cf", copy_file);
7555 init_request("cflags", char_flags);
7556 init_request("char", define_character);
7557 init_request("chop", chop_macro);
7558 init_request("close", close_request);
7559 init_request("color", activate_color);
7560 init_request("composite", composite_request);
7561 init_request("continue", while_continue_request);
7562 init_request("cp", compatible);
7563 init_request("de", define_macro);
7564 init_request("de1", define_nocomp_macro);
7565 init_request("defcolor", define_color);
7566 init_request("dei", define_indirect_macro);
7567 init_request("dei1", define_indirect_nocomp_macro);
7568 init_request("do", do_request);
7569 init_request("ds", define_string);
7570 init_request("ds1", define_nocomp_string);
7571 init_request("ec", set_escape_char);
7572 init_request("ecr", restore_escape_char);
7573 init_request("ecs", save_escape_char);
7574 init_request("el", else_request);
7575 init_request("em", end_macro);
7576 init_request("eo", escape_off);
7577 init_request("ex", exit_request);
7578 init_request("fchar", define_fallback_character);
7579 #ifdef WIDOW_CONTROL
7580 init_request("fpl", flush_pending_lines);
7581 #endif /* WIDOW_CONTROL */
7582 init_request("hcode", hyphenation_code);
7583 init_request("hpfcode", hyphenation_patterns_file_code);
7584 init_request("ie", if_else_request);
7585 init_request("if", if_request);
7586 init_request("ig", ignore);
7587 init_request("length", length_request);
7588 init_request("lf", line_file);
7589 init_request("mso", macro_source);
7590 init_request("nop", nop_request);
7591 init_request("nroff", nroff_request);
7592 init_request("nx", next_file);
7593 init_request("open", open_request);
7594 init_request("opena", opena_request);
7595 init_request("output", output_request);
7596 init_request("pc", set_page_character);
7597 init_request("pi", pipe_output);
7598 init_request("pm", print_macros);
7599 init_request("psbb", ps_bbox_request);
7600 #ifndef POPEN_MISSING
7601 init_request("pso", pipe_source);
7602 #endif /* not POPEN_MISSING */
7603 init_request("rchar", remove_character);
7604 init_request("rd", read_request);
7605 init_request("return", return_macro_request);
7606 init_request("rm", remove_macro);
7607 init_request("rn", rename_macro);
7608 init_request("schar", define_special_character);
7609 init_request("shift", shift);
7610 init_request("so", source);
7611 init_request("spreadwarn", spreadwarn_request);
7612 init_request("substring", substring_request);
7613 init_request("sy", system_request);
7614 init_request("tag", tag);
7615 init_request("taga", taga);
7616 init_request("tm", terminal);
7617 init_request("tm1", terminal1);
7618 init_request("tmc", terminal_continue);
7619 init_request("tr", translate);
7620 init_request("trf", transparent_file);
7621 init_request("trin", translate_input);
7622 init_request("trnt", translate_no_transparent);
7623 init_request("troff", troff_request);
7624 init_request("unformat", unformat_macro);
7625 #ifdef COLUMN
7626 init_request("vj", vjustify);
7627 #endif /* COLUMN */
7628 init_request("warn", warn_request);
7629 init_request("warnscale", warnscale_request);
7630 init_request("while", while_request);
7631 init_request("write", write_request);
7632 init_request("writec", write_request_continue);
7633 init_request("writem", write_macro_request);
7634 number_reg_dictionary.define(".$", new nargs_reg);
7635 number_reg_dictionary.define(".C", new constant_int_reg(&compatible_flag));
7636 number_reg_dictionary.define(".c", new lineno_reg);
7637 number_reg_dictionary.define(".color", new constant_int_reg(&color_flag));
7638 number_reg_dictionary.define(".F", new filename_reg);
7639 number_reg_dictionary.define(".g", new constant_reg("1"));
7640 number_reg_dictionary.define(".H", new constant_int_reg(&hresolution));
7641 number_reg_dictionary.define(".R", new constant_reg("10000"));
7642 number_reg_dictionary.define(".U", new constant_int_reg(&safer_flag));
7643 number_reg_dictionary.define(".V", new constant_int_reg(&vresolution));
7644 number_reg_dictionary.define(".warn", new constant_int_reg(&warning_mask));
7645 extern const char *major_version;
7646 number_reg_dictionary.define(".x", new constant_reg(major_version));
7647 extern const char *revision;
7648 number_reg_dictionary.define(".Y", new constant_reg(revision));
7649 extern const char *minor_version;
7650 number_reg_dictionary.define(".y", new constant_reg(minor_version));
7651 number_reg_dictionary.define("c.", new writable_lineno_reg);
7652 number_reg_dictionary.define("llx", new variable_reg(&llx_reg_contents));
7653 number_reg_dictionary.define("lly", new variable_reg(&lly_reg_contents));
7654 number_reg_dictionary.define("opmaxx",
7655 new variable_reg(&output_reg_maxx_contents));
7656 number_reg_dictionary.define("opmaxy",
7657 new variable_reg(&output_reg_maxy_contents));
7658 number_reg_dictionary.define("opminx",
7659 new variable_reg(&output_reg_minx_contents));
7660 number_reg_dictionary.define("opminy",
7661 new variable_reg(&output_reg_miny_contents));
7662 number_reg_dictionary.define("slimit",
7663 new variable_reg(&input_stack::limit));
7664 number_reg_dictionary.define("systat", new variable_reg(&system_status));
7665 number_reg_dictionary.define("urx", new variable_reg(&urx_reg_contents));
7666 number_reg_dictionary.define("ury", new variable_reg(&ury_reg_contents));
7667 }
7668
7669 object_dictionary request_dictionary(501);
7670
7671 void init_request(const char *s, REQUEST_FUNCP f)
7672 {
7673 request_dictionary.define(s, new request(f));
7674 }
7675
7676 static request_or_macro *lookup_request(symbol nm)
7677 {
7678 assert(!nm.is_null());
7679 request_or_macro *p = (request_or_macro *)request_dictionary.lookup(nm);
7680 if (p == 0) {
7681 warning(WARN_MAC, "macro `%1' not defined", nm.contents());
7682 p = new macro;
7683 request_dictionary.define(nm, p);
7684 }
7685 return p;
7686 }
7687
7688 node *charinfo_to_node_list(charinfo *ci, const environment *envp)
7689 {
7690 // Don't interpret character definitions in compatible mode.
7691 int old_compatible_flag = compatible_flag;
7692 compatible_flag = 0;
7693 int old_escape_char = escape_char;
7694 escape_char = '\\';
7695 macro *mac = ci->set_macro(0);
7696 assert(mac != 0);
7697 environment *oldenv = curenv;
7698 environment env(envp);
7699 curenv = &env;
7700 curenv->set_composite();
7701 token old_tok = tok;
7702 input_stack::add_boundary();
7703 string_iterator *si =
7704 new string_iterator(*mac, "composite character", ci->nm);
7705 input_stack::push(si);
7706 // we don't use process_input_stack, because we don't want to recognise
7707 // requests
7708 for (;;) {
7709 tok.next();
7710 if (tok.eof())
7711 break;
7712 if (tok.newline()) {
7713 error("composite character mustn't contain newline");
7714 while (!tok.eof())
7715 tok.next();
7716 break;
7717 }
7718 else
7719 tok.process();
7720 }
7721 node *n = curenv->extract_output_line();
7722 input_stack::remove_boundary();
7723 ci->set_macro(mac);
7724 tok = old_tok;
7725 curenv = oldenv;
7726 compatible_flag = old_compatible_flag;
7727 escape_char = old_escape_char;
7728 have_input = 0;
7729 return n;
7730 }
7731
7732 static node *read_draw_node()
7733 {
7734 token start;
7735 start.next();
7736 if (!start.delimiter(1)){
7737 do {
7738 tok.next();
7739 } while (tok != start && !tok.newline() && !tok.eof());
7740 }
7741 else {
7742 tok.next();
7743 if (tok == start)
7744 error("missing argument");
7745 else {
7746 unsigned char type = tok.ch();
7747 if (type == 'F') {
7748 read_color_draw_node(start);
7749 return 0;
7750 }
7751 tok.next();
7752 int maxpoints = 10;
7753 hvpair *point = new hvpair[maxpoints];
7754 int npoints = 0;
7755 int no_last_v = 0;
7756 int err = 0;
7757 int i;
7758 for (i = 0; tok != start; i++) {
7759 if (i == maxpoints) {
7760 hvpair *oldpoint = point;
7761 point = new hvpair[maxpoints*2];
7762 for (int j = 0; j < maxpoints; j++)
7763 point[j] = oldpoint[j];
7764 maxpoints *= 2;
7765 a_delete oldpoint;
7766 }
7767 if (!get_hunits(&point[i].h,
7768 type == 'f' || type == 't' ? 'u' : 'm')) {
7769 err = 1;
7770 break;
7771 }
7772 ++npoints;
7773 tok.skip();
7774 point[i].v = V0;
7775 if (tok == start) {
7776 no_last_v = 1;
7777 break;
7778 }
7779 if (!get_vunits(&point[i].v, 'v')) {
7780 err = 1;
7781 break;
7782 }
7783 tok.skip();
7784 }
7785 while (tok != start && !tok.newline() && !tok.eof())
7786 tok.next();
7787 if (!err) {
7788 switch (type) {
7789 case 'l':
7790 if (npoints != 1 || no_last_v) {
7791 error("two arguments needed for line");
7792 npoints = 1;
7793 }
7794 break;
7795 case 'c':
7796 if (npoints != 1 || !no_last_v) {
7797 error("one argument needed for circle");
7798 npoints = 1;
7799 point[0].v = V0;
7800 }
7801 break;
7802 case 'e':
7803 if (npoints != 1 || no_last_v) {
7804 error("two arguments needed for ellipse");
7805 npoints = 1;
7806 }
7807 break;
7808 case 'a':
7809 if (npoints != 2 || no_last_v) {
7810 error("four arguments needed for arc");
7811 npoints = 2;
7812 }
7813 break;
7814 case '~':
7815 if (no_last_v)
7816 error("even number of arguments needed for spline");
7817 break;
7818 case 'f':
7819 if (npoints != 1 || !no_last_v) {
7820 error("one argument needed for gray shade");
7821 npoints = 1;
7822 point[0].v = V0;
7823 }
7824 default:
7825 // silently pass it through
7826 break;
7827 }
7828 draw_node *dn = new draw_node(type, point, npoints,
7829 curenv->get_font_size(),
7830 curenv->get_glyph_color(),
7831 curenv->get_fill_color());
7832 a_delete point;
7833 return dn;
7834 }
7835 else {
7836 a_delete point;
7837 }
7838 }
7839 }
7840 return 0;
7841 }
7842
7843 static void read_color_draw_node(token &start)
7844 {
7845 tok.next();
7846 if (tok == start) {
7847 error("missing color scheme");
7848 return;
7849 }
7850 unsigned char scheme = tok.ch();
7851 tok.next();
7852 color *col = 0;
7853 char end = start.ch();
7854 switch (scheme) {
7855 case 'c':
7856 col = read_cmy(end);
7857 break;
7858 case 'd':
7859 col = &default_color;
7860 break;
7861 case 'g':
7862 col = read_gray(end);
7863 break;
7864 case 'k':
7865 col = read_cmyk(end);
7866 break;
7867 case 'r':
7868 col = read_rgb(end);
7869 break;
7870 }
7871 if (col)
7872 curenv->set_fill_color(col);
7873 while (tok != start) {
7874 if (tok.newline() || tok.eof()) {
7875 warning(WARN_DELIM, "missing closing delimiter");
7876 input_stack::push(make_temp_iterator("\n"));
7877 break;
7878 }
7879 tok.next();
7880 }
7881 have_input = 1;
7882 }
7883
7884 static struct {
7885 const char *name;
7886 int mask;
7887 } warning_table[] = {
7888 { "char", WARN_CHAR },
7889 { "range", WARN_RANGE },
7890 { "break", WARN_BREAK },
7891 { "delim", WARN_DELIM },
7892 { "el", WARN_EL },
7893 { "scale", WARN_SCALE },
7894 { "number", WARN_NUMBER },
7895 { "syntax", WARN_SYNTAX },
7896 { "tab", WARN_TAB },
7897 { "right-brace", WARN_RIGHT_BRACE },
7898 { "missing", WARN_MISSING },
7899 { "input", WARN_INPUT },
7900 { "escape", WARN_ESCAPE },
7901 { "space", WARN_SPACE },
7902 { "font", WARN_FONT },
7903 { "di", WARN_DI },
7904 { "mac", WARN_MAC },
7905 { "reg", WARN_REG },
7906 { "ig", WARN_IG },
7907 { "color", WARN_COLOR },
7908 { "all", WARN_TOTAL & ~(WARN_DI | WARN_MAC | WARN_REG) },
7909 { "w", WARN_TOTAL },
7910 { "default", DEFAULT_WARNING_MASK },
7911 };
7912
7913 static int lookup_warning(const char *name)
7914 {
7915 for (unsigned int i = 0;
7916 i < sizeof(warning_table)/sizeof(warning_table[0]);
7917 i++)
7918 if (strcmp(name, warning_table[i].name) == 0)
7919 return warning_table[i].mask;
7920 return 0;
7921 }
7922
7923 static void enable_warning(const char *name)
7924 {
7925 int mask = lookup_warning(name);
7926 if (mask)
7927 warning_mask |= mask;
7928 else
7929 error("unknown warning `%1'", name);
7930 }
7931
7932 static void disable_warning(const char *name)
7933 {
7934 int mask = lookup_warning(name);
7935 if (mask)
7936 warning_mask &= ~mask;
7937 else
7938 error("unknown warning `%1'", name);
7939 }
7940
7941 static void copy_mode_error(const char *format,
7942 const errarg &arg1,
7943 const errarg &arg2,
7944 const errarg &arg3)
7945 {
7946 if (ignoring) {
7947 static const char prefix[] = "(in ignored input) ";
7948 char *s = new char[sizeof(prefix) + strlen(format)];
7949 strcpy(s, prefix);
7950 strcat(s, format);
7951 warning(WARN_IG, s, arg1, arg2, arg3);
7952 a_delete s;
7953 }
7954 else
7955 error(format, arg1, arg2, arg3);
7956 }
7957
7958 enum error_type { WARNING, OUTPUT_WARNING, ERROR, FATAL };
7959
7960 static void do_error(error_type type,
7961 const char *format,
7962 const errarg &arg1,
7963 const errarg &arg2,
7964 const errarg &arg3)
7965 {
7966 const char *filename;
7967 int lineno;
7968 if (inhibit_errors && type < FATAL)
7969 return;
7970 if (backtrace_flag)
7971 input_stack::backtrace();
7972 if (!get_file_line(&filename, &lineno))
7973 filename = 0;
7974 if (filename)
7975 errprint("%1:%2: ", filename, lineno);
7976 else if (program_name)
7977 fprintf(stderr, "%s: ", program_name);
7978 switch (type) {
7979 case FATAL:
7980 fputs("fatal error: ", stderr);
7981 break;
7982 case ERROR:
7983 break;
7984 case WARNING:
7985 fputs("warning: ", stderr);
7986 break;
7987 case OUTPUT_WARNING:
7988 double fromtop = topdiv->get_vertical_position().to_units() / warn_scale;
7989 fprintf(stderr, "warning [p %d, %.1f%c",
7990 topdiv->get_page_number(), fromtop, warn_scaling_indicator);
7991 if (topdiv != curdiv) {
7992 double fromtop1 = curdiv->get_vertical_position().to_units()
7993 / warn_scale;
7994 fprintf(stderr, ", div `%s', %.1f%c",
7995 curdiv->get_diversion_name(), fromtop1, warn_scaling_indicator);
7996 }
7997 fprintf(stderr, "]: ");
7998 break;
7999 }
8000 errprint(format, arg1, arg2, arg3);
8001 fputc('\n', stderr);
8002 fflush(stderr);
8003 if (type == FATAL)
8004 cleanup_and_exit(1);
8005 }
8006
8007 int warning(warning_type t,
8008 const char *format,
8009 const errarg &arg1,
8010 const errarg &arg2,
8011 const errarg &arg3)
8012 {
8013 if ((t & warning_mask) != 0) {
8014 do_error(WARNING, format, arg1, arg2, arg3);
8015 return 1;
8016 }
8017 else
8018 return 0;
8019 }
8020
8021 int output_warning(warning_type t,
8022 const char *format,
8023 const errarg &arg1,
8024 const errarg &arg2,
8025 const errarg &arg3)
8026 {
8027 if ((t & warning_mask) != 0) {
8028 do_error(OUTPUT_WARNING, format, arg1, arg2, arg3);
8029 return 1;
8030 }
8031 else
8032 return 0;
8033 }
8034
8035 void error(const char *format,
8036 const errarg &arg1,
8037 const errarg &arg2,
8038 const errarg &arg3)
8039 {
8040 do_error(ERROR, format, arg1, arg2, arg3);
8041 }
8042
8043 void fatal(const char *format,
8044 const errarg &arg1,
8045 const errarg &arg2,
8046 const errarg &arg3)
8047 {
8048 do_error(FATAL, format, arg1, arg2, arg3);
8049 }
8050
8051 void fatal_with_file_and_line(const char *filename, int lineno,
8052 const char *format,
8053 const errarg &arg1,
8054 const errarg &arg2,
8055 const errarg &arg3)
8056 {
8057 fprintf(stderr, "%s:%d: fatal error: ", filename, lineno);
8058 errprint(format, arg1, arg2, arg3);
8059 fputc('\n', stderr);
8060 fflush(stderr);
8061 cleanup_and_exit(1);
8062 }
8063
8064 void error_with_file_and_line(const char *filename, int lineno,
8065 const char *format,
8066 const errarg &arg1,
8067 const errarg &arg2,
8068 const errarg &arg3)
8069 {
8070 fprintf(stderr, "%s:%d: error: ", filename, lineno);
8071 errprint(format, arg1, arg2, arg3);
8072 fputc('\n', stderr);
8073 fflush(stderr);
8074 }
8075
8076 dictionary charinfo_dictionary(501);
8077
8078 charinfo *get_charinfo(symbol nm)
8079 {
8080 void *p = charinfo_dictionary.lookup(nm);
8081 if (p != 0)
8082 return (charinfo *)p;
8083 charinfo *cp = new charinfo(nm);
8084 (void)charinfo_dictionary.lookup(nm, cp);
8085 return cp;
8086 }
8087
8088 int charinfo::next_index = 0;
8089
8090 charinfo::charinfo(symbol s)
8091 : translation(0), mac(0), special_translation(TRANSLATE_NONE),
8092 hyphenation_code(0), flags(0), ascii_code(0), asciify_code(0),
8093 not_found(0), transparent_translate(1), translate_input(0),
8094 mode(CHAR_NORMAL), nm(s)
8095 {
8096 index = next_index++;
8097 }
8098
8099 void charinfo::set_hyphenation_code(unsigned char c)
8100 {
8101 hyphenation_code = c;
8102 }
8103
8104 void charinfo::set_translation(charinfo *ci, int tt, int ti)
8105 {
8106 translation = ci;
8107 if (ci && ti) {
8108 if (hyphenation_code != 0)
8109 ci->set_hyphenation_code(hyphenation_code);
8110 if (asciify_code != 0)
8111 ci->set_asciify_code(asciify_code);
8112 else if (ascii_code != 0)
8113 ci->set_asciify_code(ascii_code);
8114 ci->set_translation_input();
8115 }
8116 special_translation = TRANSLATE_NONE;
8117 transparent_translate = tt;
8118 }
8119
8120 void charinfo::set_special_translation(int c, int tt)
8121 {
8122 special_translation = c;
8123 translation = 0;
8124 transparent_translate = tt;
8125 }
8126
8127 void charinfo::set_ascii_code(unsigned char c)
8128 {
8129 ascii_code = c;
8130 }
8131
8132 void charinfo::set_asciify_code(unsigned char c)
8133 {
8134 asciify_code = c;
8135 }
8136
8137 macro *charinfo::set_macro(macro *m)
8138 {
8139 macro *tem = mac;
8140 mac = m;
8141 return tem;
8142 }
8143
8144 macro *charinfo::setx_macro(macro *m, char_mode cm)
8145 {
8146 macro *tem = mac;
8147 mac = m;
8148 mode = cm;
8149 return tem;
8150 }
8151
8152 void charinfo::set_number(int n)
8153 {
8154 number = n;
8155 flags |= NUMBERED;
8156 }
8157
8158 int charinfo::get_number()
8159 {
8160 assert(flags & NUMBERED);
8161 return number;
8162 }
8163
8164 symbol UNNAMED_SYMBOL("---");
8165
8166 // For numbered characters not between 0 and 255, we make a symbol out
8167 // of the number and store them in this dictionary.
8168
8169 dictionary numbered_charinfo_dictionary(11);
8170
8171 charinfo *get_charinfo_by_number(int n)
8172 {
8173 static charinfo *number_table[256];
8174
8175 if (n >= 0 && n < 256) {
8176 charinfo *ci = number_table[n];
8177 if (!ci) {
8178 ci = new charinfo(UNNAMED_SYMBOL);
8179 ci->set_number(n);
8180 number_table[n] = ci;
8181 }
8182 return ci;
8183 }
8184 else {
8185 symbol ns(i_to_a(n));
8186 charinfo *ci = (charinfo *)numbered_charinfo_dictionary.lookup(ns);
8187 if (!ci) {
8188 ci = new charinfo(UNNAMED_SYMBOL);
8189 ci->set_number(n);
8190 (void)numbered_charinfo_dictionary.lookup(ns, ci);
8191 }
8192 return ci;
8193 }
8194 }
8195
8196 int font::name_to_index(const char *nm)
8197 {
8198 charinfo *ci;
8199 if (nm[1] == 0)
8200 ci = charset_table[nm[0] & 0xff];
8201 else if (nm[0] == '\\' && nm[2] == 0)
8202 ci = get_charinfo(symbol(nm + 1));
8203 else
8204 ci = get_charinfo(symbol(nm));
8205 if (ci == 0)
8206 return -1;
8207 else
8208 return ci->get_index();
8209 }
8210
8211 int font::number_to_index(int n)
8212 {
8213 return get_charinfo_by_number(n)->get_index();
8214 }
A text processor that formats text