1 /* GNU m4 -- A simple macro processor
3 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GNU M4.
8 GNU M4 is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU M4 is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 /* Handling of different input sources, and lexical analysis. */
26 /* Unread input can be either files, that should be read (eg. included
27 files), strings, which should be rescanned (eg. macro expansion text),
28 or quoted macro definitions (as returned by the builtin "defn").
29 Unread input are organised in a stack, implemented with an obstack.
30 Each input source is described by a "struct input_block". The obstack
31 is "current_input". The top of the input stack is "isp".
33 The macro "m4wrap" places the text to be saved on another input
34 stack, on the obstack "wrapup_stack", whose top is "wsp". When EOF
35 is seen on normal input (eg, when "current_input" is empty), input is
36 switched over to "wrapup_stack", and the original "current_input" is
37 freed. A new stack is allocated for "wrapup_stack", which will
38 accept any text produced by calls to "m4wrap" from within the
39 wrapped text. This process of shuffling "wrapup_stack" to
40 "current_input" can continue indefinitely, even generating infinite
41 loops (e.g. "define(`f',`m4wrap(`f')')f"), without memory leaks.
43 Pushing new input on the input stack is done by push_file (),
44 push_string (), push_wrapup () (for wrapup text), and push_macro ()
45 (for macro definitions). Because macro expansion needs direct access
46 to the current input obstack (for optimisation), push_string () are
47 split in two functions, push_string_init (), which returns a pointer
48 to the current input stack, and push_string_finish (), which return a
49 pointer to the final text. The input_block *next is used to manage
50 the coordination between the different push routines.
52 The current file and line number are stored in two global
53 variables, for use by the error handling functions in m4.c. Macro
54 expansion wants to report the line where a macro name was detected,
55 rather than where it finished collecting arguments. This also
56 applies to text resulting from macro expansions. So each input
57 block maintains its own notion of the current file and line, and
58 swapping between input blocks updates the global variables
61 #ifdef ENABLE_CHANGEWORD
67 INPUT_STRING
, /* String resulting from macro expansion. */
68 INPUT_FILE
, /* File from command line or include. */
69 INPUT_MACRO
/* Builtin resulting from defn. */
72 typedef enum input_type input_type
;
76 struct input_block
*prev
; /* previous input_block on the input stack */
77 input_type type
; /* see enum values */
78 const char *file
; /* file where this input is from */
79 int line
; /* line where this input is from */
84 char *string
; /* remaining string value */
86 u_s
; /* INPUT_STRING */
89 FILE *fp
; /* input file handle */
90 bool_bitfield end
: 1; /* true if peek has seen EOF */
91 bool_bitfield close
: 1; /* true if we should close file on pop */
92 bool_bitfield advance
: 1; /* track previous start_of_input_line */
95 builtin_func
*func
; /* pointer to macro's function */
100 typedef struct input_block input_block
;
103 /* Current input file name. */
104 const char *current_file
;
106 /* Current input line number. */
109 /* Obstack for storing individual tokens. */
110 static struct obstack token_stack
;
112 /* Obstack for storing file names. */
113 static struct obstack file_names
;
115 /* Wrapup input stack. */
116 static struct obstack
*wrapup_stack
;
118 /* Current stack, from input or wrapup. */
119 static struct obstack
*current_input
;
121 /* Bottom of token_stack, for obstack_free. */
122 static void *token_bottom
;
124 /* Pointer to top of current_input. */
125 static input_block
*isp
;
127 /* Pointer to top of wrapup_stack. */
128 static input_block
*wsp
;
130 /* Aux. for handling split push_string (). */
131 static input_block
*next
;
133 /* Flag for next_char () to increment current_line. */
134 static bool start_of_input_line
;
136 /* Flag for next_char () to recognize change in input block. */
137 static bool input_change
;
139 #define CHAR_EOF 256 /* character return on EOF */
140 #define CHAR_MACRO 257 /* character return for MACRO token */
150 #ifdef ENABLE_CHANGEWORD
152 # define DEFAULT_WORD_REGEXP "[_a-zA-Z][_a-zA-Z0-9]*"
154 static char *word_start
;
155 static struct re_pattern_buffer word_regexp
;
156 static int default_word_regexp
;
157 static struct re_registers regs
;
159 #else /* ! ENABLE_CHANGEWORD */
160 # define default_word_regexp 1
161 #endif /* ! ENABLE_CHANGEWORD */
164 static const char *token_type_string (token_type
);
168 /*-------------------------------------------------------------------.
169 | push_file () pushes an input file on the input stack, saving the |
170 | current file name and line number. If next is non-NULL, this push |
171 | invalidates a call to push_string_init (), whose storage is |
172 | consequently released. If CLOSE, then close FP after EOF is |
174 `-------------------------------------------------------------------*/
177 push_file (FILE *fp
, const char *title
, bool close
)
183 obstack_free (current_input
, next
);
187 if (debug_level
& DEBUG_TRACE_INPUT
)
188 DEBUG_MESSAGE1 ("input read from %s", title
);
190 i
= (input_block
*) obstack_alloc (current_input
,
191 sizeof (struct input_block
));
192 i
->type
= INPUT_FILE
;
193 i
->file
= (char *) obstack_copy0 (&file_names
, title
, strlen (title
));
198 i
->u
.u_f
.end
= false;
199 i
->u
.u_f
.close
= close
;
200 i
->u
.u_f
.advance
= start_of_input_line
;
201 output_current_line
= -1;
207 /*---------------------------------------------------------------.
208 | push_macro () pushes a builtin macro's definition on the input |
209 | stack. If next is non-NULL, this push invalidates a call to |
210 | push_string_init (), whose storage is consequently released. |
211 `---------------------------------------------------------------*/
214 push_macro (builtin_func
*func
)
220 obstack_free (current_input
, next
);
224 i
= (input_block
*) obstack_alloc (current_input
,
225 sizeof (struct input_block
));
226 i
->type
= INPUT_MACRO
;
227 i
->file
= current_file
;
228 i
->line
= current_line
;
236 /*------------------------------------------------------------------.
237 | First half of push_string (). The pointer next points to the new |
239 `------------------------------------------------------------------*/
242 push_string_init (void)
246 M4ERROR ((warning_status
, 0,
247 "INTERNAL ERROR: recursive push_string!"));
251 next
= (input_block
*) obstack_alloc (current_input
,
252 sizeof (struct input_block
));
253 next
->type
= INPUT_STRING
;
254 next
->file
= current_file
;
255 next
->line
= current_line
;
257 return current_input
;
260 /*------------------------------------------------------------------------.
261 | Last half of push_string (). If next is now NULL, a call to push_file |
262 | () has invalidated the previous call to push_string_init (), so we just |
263 | give up. If the new object is void, we do not push it. The function |
264 | push_string_finish () returns a pointer to the finished object. This |
265 | pointer is only for temporary use, since reading the next token might |
266 | release the memory used for the object. |
267 `------------------------------------------------------------------------*/
270 push_string_finish (void)
272 const char *ret
= NULL
;
277 if (obstack_object_size (current_input
) > 0)
279 obstack_1grow (current_input
, '\0');
280 next
->u
.u_s
.string
= (char *) obstack_finish (current_input
);
283 ret
= isp
->u
.u_s
.string
; /* for immediate use only */
287 obstack_free (current_input
, next
); /* people might leave garbage on it. */
292 /*------------------------------------------------------------------.
293 | The function push_wrapup () pushes a string on the wrapup stack. |
294 | When the normal input stack gets empty, the wrapup stack will |
295 | become the input stack, and push_string () and push_file () will |
296 | operate on wrapup_stack. Push_wrapup should be done as |
297 | push_string (), but this will suffice, as long as arguments to |
298 | m4_m4wrap () are moderate in size. |
299 `------------------------------------------------------------------*/
302 push_wrapup (const char *s
)
305 i
= (input_block
*) obstack_alloc (wrapup_stack
,
306 sizeof (struct input_block
));
308 i
->type
= INPUT_STRING
;
309 i
->file
= current_file
;
310 i
->line
= current_line
;
311 i
->u
.u_s
.string
= (char *) obstack_copy0 (wrapup_stack
, s
, strlen (s
));
316 /*-------------------------------------------------------------------------.
317 | The function pop_input () pops one level of input sources. If the |
318 | popped input_block is a file, current_file and current_line are reset to |
319 | the saved values before the memory for the input_block are released. |
320 `-------------------------------------------------------------------------*/
325 input_block
*tmp
= isp
->prev
;
334 if (debug_level
& DEBUG_TRACE_INPUT
)
337 DEBUG_MESSAGE2 ("input reverted to %s, line %d",
338 tmp
->file
, tmp
->line
);
340 DEBUG_MESSAGE ("input exhausted");
343 if (ferror (isp
->u
.u_f
.fp
))
345 M4ERROR ((warning_status
, 0, "read error"));
346 if (isp
->u
.u_f
.close
)
347 fclose (isp
->u
.u_f
.fp
);
348 retcode
= EXIT_FAILURE
;
350 else if (isp
->u
.u_f
.close
&& fclose (isp
->u
.u_f
.fp
) == EOF
)
352 M4ERROR ((warning_status
, errno
, "error reading file"));
353 retcode
= EXIT_FAILURE
;
355 start_of_input_line
= isp
->u
.u_f
.advance
;
356 output_current_line
= -1;
360 M4ERROR ((warning_status
, 0,
361 "INTERNAL ERROR: input stack botch in pop_input ()"));
364 obstack_free (current_input
, isp
);
365 next
= NULL
; /* might be set in push_string_init () */
371 /*------------------------------------------------------------------------.
372 | To switch input over to the wrapup stack, main () calls pop_wrapup (). |
373 | Since wrapup text can install new wrapup text, pop_wrapup () returns |
374 | false when there is no wrapup text on the stack, and true otherwise. |
375 `------------------------------------------------------------------------*/
381 obstack_free (current_input
, NULL
);
382 free (current_input
);
386 /* End of the program. Free all memory even though we are about
387 to exit, since it makes leak detection easier. */
388 obstack_free (&token_stack
, NULL
);
389 obstack_free (&file_names
, NULL
);
390 obstack_free (wrapup_stack
, NULL
);
395 current_input
= wrapup_stack
;
396 wrapup_stack
= (struct obstack
*) xmalloc (sizeof (struct obstack
));
397 obstack_init (wrapup_stack
);
406 /*-------------------------------------------------------------------.
407 | When a MACRO token is seen, next_token () uses init_macro_token () |
408 | to retrieve the value of the function pointer. |
409 `-------------------------------------------------------------------*/
412 init_macro_token (token_data
*td
)
414 if (isp
->type
!= INPUT_MACRO
)
416 M4ERROR ((warning_status
, 0,
417 "INTERNAL ERROR: bad call to init_macro_token ()"));
421 TOKEN_DATA_TYPE (td
) = TOKEN_FUNC
;
422 TOKEN_DATA_FUNC (td
) = isp
->u
.func
;
426 /*------------------------------------------------------------------------.
427 | Low level input is done a character at a time. The function peek_input |
428 | () is used to look at the next character in the input stream. At any |
429 | given time, it reads from the input_block on the top of the current |
431 `------------------------------------------------------------------------*/
437 input_block
*block
= isp
;
447 ch
= to_uchar (block
->u
.u_s
.string
[0]);
453 ch
= getc (block
->u
.u_f
.fp
);
456 ungetc (ch
, block
->u
.u_f
.fp
);
459 block
->u
.u_f
.end
= true;
466 M4ERROR ((warning_status
, 0,
467 "INTERNAL ERROR: input stack botch in peek_input ()"));
474 /*-------------------------------------------------------------------------.
475 | The function next_char () is used to read and advance the input to the |
476 | next character. It also manages line numbers for error messages, so |
477 | they do not get wrong, due to lookahead. The token consisting of a |
478 | newline alone is taken as belonging to the line it ends, and the current |
479 | line number is not incremented until the next character is read. |
480 | 99.9% of all calls will read from a string, so factor that out into a |
482 `-------------------------------------------------------------------------*/
484 #define next_char() \
485 (isp && isp->type == INPUT_STRING && isp->u.u_s.string[0] \
487 ? to_uchar (*isp->u.u_s.string++) \
506 current_file
= isp
->file
;
507 current_line
= isp
->line
;
508 input_change
= false;
514 ch
= to_uchar (*isp
->u
.u_s
.string
++);
520 if (start_of_input_line
)
522 start_of_input_line
= false;
523 current_line
= ++isp
->line
;
526 /* If stdin is a terminal, calling getc after peek_input
527 already called it would make the user have to hit ^D
529 ch
= isp
->u
.u_f
.end
? EOF
: getc (isp
->u
.u_f
.fp
);
533 start_of_input_line
= true;
539 pop_input (); /* INPUT_MACRO input sources has only one
544 M4ERROR ((warning_status
, 0,
545 "INTERNAL ERROR: input stack botch in next_char ()"));
549 /* End of input source --- pop one level. */
554 /*------------------------------------------------------------------------.
555 | skip_line () simply discards all immediately following characters, upto |
556 | the first newline. It is only used from m4_dnl (). |
557 `------------------------------------------------------------------------*/
563 const char *file
= current_file
;
564 int line
= current_line
;
566 while ((ch
= next_char ()) != CHAR_EOF
&& ch
!= '\n')
569 /* current_file changed to "" if we see CHAR_EOF, use the
570 previous value we stored earlier. */
571 M4ERROR_AT_LINE ((warning_status
, 0, file
, line
,
572 "Warning: end of file treated as newline"));
573 /* On the rare occasion that dnl crosses include file boundaries
574 (either the input file did not end in a newline, or changeword
575 was used), calling next_char can update current_file and
576 current_line, and that update will be undone as we return to
577 expand_macro. This informs next_char to fix things again. */
578 if (file
!= current_file
|| line
!= current_line
)
583 /*------------------------------------------------------------------.
584 | This function is for matching a string against a prefix of the |
585 | input stream. If the string matches the input and consume is |
586 | true, the input is discarded; otherwise any characters read are |
587 | pushed back again. The function is used only when multicharacter |
588 | quotes or comment delimiters are used. |
589 `------------------------------------------------------------------*/
592 match_input (const char *s
, bool consume
)
594 int n
; /* number of characters matched */
595 int ch
; /* input character */
600 if (ch
!= to_uchar (*s
))
601 return false; /* fail */
607 return true; /* short match */
611 for (n
= 1, t
= s
++; (ch
= peek_input ()) == to_uchar (*s
++); )
615 if (*s
== '\0') /* long match */
624 /* Failed or shouldn't consume, push back input. */
626 struct obstack
*h
= push_string_init ();
628 /* `obstack_grow' may be macro evaluating its arg 1 several times. */
629 obstack_grow (h
, t
, n
);
631 push_string_finish ();
635 /*--------------------------------------------------------------------.
636 | The macro MATCH() is used to match a string S against the input. |
637 | The first character is handled inline, for speed. Hopefully, this |
638 | will not hurt efficiency too much when single character quotes and |
639 | comment delimiters are used. If CONSUME, then CH is the result of |
640 | next_char, and a successful match will discard the matched string. |
641 | Otherwise, CH is the result of peek_char, and the input stream is |
642 | effectively unchanged. |
643 `--------------------------------------------------------------------*/
645 #define MATCH(ch, s, consume) \
646 (to_uchar ((s)[0]) == (ch) \
648 && ((s)[1] == '\0' || (match_input ((s) + (consume), consume))))
651 /*----------------------------------------------------------.
652 | Inititialise input stacks, and quote/comment characters. |
653 `----------------------------------------------------------*/
661 current_input
= (struct obstack
*) xmalloc (sizeof (struct obstack
));
662 obstack_init (current_input
);
663 wrapup_stack
= (struct obstack
*) xmalloc (sizeof (struct obstack
));
664 obstack_init (wrapup_stack
);
666 obstack_init (&file_names
);
668 /* Allocate an object in the current chunk, so that obstack_free
669 will always work even if the first token parsed spills to a new
671 obstack_init (&token_stack
);
672 obstack_alloc (&token_stack
, 1);
673 token_bottom
= obstack_base (&token_stack
);
679 start_of_input_line
= false;
681 lquote
.string
= xstrdup (DEF_LQUOTE
);
682 lquote
.length
= strlen (lquote
.string
);
683 rquote
.string
= xstrdup (DEF_RQUOTE
);
684 rquote
.length
= strlen (rquote
.string
);
685 bcomm
.string
= xstrdup (DEF_BCOMM
);
686 bcomm
.length
= strlen (bcomm
.string
);
687 ecomm
.string
= xstrdup (DEF_ECOMM
);
688 ecomm
.length
= strlen (ecomm
.string
);
690 #ifdef ENABLE_CHANGEWORD
691 set_word_regexp (user_word_regexp
);
696 /*------------------------------------------------------------------.
697 | Functions for setting quotes and comment delimiters. Used by |
698 | m4_changecom () and m4_changequote (). Pass NULL if the argument |
699 | was not present, to distinguish from an explicit empty string. |
700 `------------------------------------------------------------------*/
703 set_quotes (const char *lq
, const char *rq
)
705 free (lquote
.string
);
706 free (rquote
.string
);
708 /* POSIX states that with 0 arguments, the default quotes are used.
709 POSIX XCU ERN 112 states that behavior is implementation-defined
710 if there was only one argument, or if there is an empty string in
711 either position when there are two arguments. We allow an empty
712 left quote to disable quoting, but a non-empty left quote will
713 always create a non-empty right quote. See the texinfo for what
714 some other implementations do. */
720 else if (!rq
|| (*lq
&& !*rq
))
723 lquote
.string
= xstrdup (lq
);
724 lquote
.length
= strlen (lquote
.string
);
725 rquote
.string
= xstrdup (rq
);
726 rquote
.length
= strlen (rquote
.string
);
730 set_comment (const char *bc
, const char *ec
)
735 /* POSIX requires no arguments to disable comments. It requires
736 empty arguments to be used as-is, but this is counter to
737 traditional behavior, because a non-null begin and null end makes
738 it impossible to end a comment. An aardvark has been filed:
739 http://www.opengroup.org/austin/mailarchives/ag-review/msg02168.html
740 This implementation assumes the aardvark will be approved. See
741 the texinfo for what some other implementations do. */
744 else if (!ec
|| (*bc
&& !*ec
))
747 bcomm
.string
= xstrdup (bc
);
748 bcomm
.length
= strlen (bcomm
.string
);
749 ecomm
.string
= xstrdup (ec
);
750 ecomm
.length
= strlen (ecomm
.string
);
753 #ifdef ENABLE_CHANGEWORD
756 set_word_regexp (const char *regexp
)
761 struct re_pattern_buffer new_word_regexp
;
763 if (!*regexp
|| !strcmp (regexp
, DEFAULT_WORD_REGEXP
))
765 default_word_regexp
= true;
769 /* Dry run to see whether the new expression is compilable. */
770 init_pattern_buffer (&new_word_regexp
, NULL
);
771 msg
= re_compile_pattern (regexp
, strlen (regexp
), &new_word_regexp
);
772 regfree (&new_word_regexp
);
776 M4ERROR ((warning_status
, 0,
777 "bad regular expression `%s': %s", regexp
, msg
));
781 /* If compilation worked, retry using the word_regexp struct.
782 Can't rely on struct assigns working, so redo the compilation. */
783 regfree (&word_regexp
);
784 msg
= re_compile_pattern (regexp
, strlen (regexp
), &word_regexp
);
785 re_set_registers (&word_regexp
, ®s
, regs
.num_regs
, regs
.start
, regs
.end
);
789 M4ERROR ((EXIT_FAILURE
, 0,
790 "INTERNAL ERROR: expression recompilation `%s': %s",
794 default_word_regexp
= false;
796 if (word_start
== NULL
)
797 word_start
= (char *) xmalloc (256);
799 word_start
[0] = '\0';
801 for (i
= 1; i
< 256; i
++)
804 word_start
[i
] = re_search (&word_regexp
, test
, 1, 0, 0, NULL
) >= 0;
808 #endif /* ENABLE_CHANGEWORD */
811 /*--------------------------------------------------------------------.
812 | Parse and return a single token from the input stream. A token |
813 | can either be TOKEN_EOF, if the input_stack is empty; it can be |
814 | TOKEN_STRING for a quoted string; TOKEN_WORD for something that is |
815 | a potential macro name; and TOKEN_SIMPLE for any single character |
816 | that is not a part of any of the previous types. If LINE is not |
817 | NULL, set *LINE to the line where the token starts. |
819 | Next_token () return the token type, and passes back a pointer to |
820 | the token data through TD. The token text is collected on the |
821 | obstack token_stack, which never contains more than one token text |
822 | at a time. The storage pointed to by the fields in TD is |
823 | therefore subject to change the next time next_token () is called. |
824 `--------------------------------------------------------------------*/
827 next_token (token_data
*td
, int *line
)
832 #ifdef ENABLE_CHANGEWORD
834 char *orig_text
= NULL
;
839 obstack_free (&token_stack
, token_bottom
);
843 /* Can't consume character until after CHAR_MACRO is handled. */
848 xfprintf (stderr
, "next_token -> EOF\n");
853 if (ch
== CHAR_MACRO
)
855 init_macro_token (td
);
858 xfprintf (stderr
, "next_token -> MACDEF (%s)\n",
859 find_builtin_by_addr (TOKEN_DATA_FUNC (td
))->name
);
864 next_char (); /* Consume character we already peeked at. */
866 *line
= current_line
;
867 if (MATCH (ch
, bcomm
.string
, true))
869 obstack_grow (&token_stack
, bcomm
.string
, bcomm
.length
);
870 while ((ch
= next_char ()) != CHAR_EOF
871 && !MATCH (ch
, ecomm
.string
, true))
872 obstack_1grow (&token_stack
, ch
);
874 obstack_grow (&token_stack
, ecomm
.string
, ecomm
.length
);
876 /* current_file changed to "" if we see CHAR_EOF, use the
877 previous value we stored earlier. */
878 M4ERROR_AT_LINE ((EXIT_FAILURE
, 0, file
, *line
,
879 "ERROR: end of file in comment"));
883 else if (default_word_regexp
&& (isalpha (ch
) || ch
== '_'))
885 obstack_1grow (&token_stack
, ch
);
886 while ((ch
= peek_input ()) != CHAR_EOF
&& (isalnum (ch
) || ch
== '_'))
888 obstack_1grow (&token_stack
, ch
);
894 #ifdef ENABLE_CHANGEWORD
896 else if (!default_word_regexp
&& word_start
[ch
])
898 obstack_1grow (&token_stack
, ch
);
904 obstack_1grow (&token_stack
, ch
);
905 startpos
= re_search (&word_regexp
,
906 (char *) obstack_base (&token_stack
),
907 obstack_object_size (&token_stack
), 0, 0,
910 regs
.end
[0] != obstack_object_size (&token_stack
))
912 *(((char *) obstack_base (&token_stack
)
913 + obstack_object_size (&token_stack
)) - 1) = '\0';
919 obstack_1grow (&token_stack
, '\0');
920 orig_text
= (char *) obstack_finish (&token_stack
);
922 if (regs
.start
[1] != -1)
923 obstack_grow (&token_stack
,orig_text
+ regs
.start
[1],
924 regs
.end
[1] - regs
.start
[1]);
926 obstack_grow (&token_stack
, orig_text
,regs
.end
[0]);
931 #endif /* ENABLE_CHANGEWORD */
933 else if (!MATCH (ch
, lquote
.string
, true))
950 obstack_1grow (&token_stack
, ch
);
959 /* current_file changed to "" if we see CHAR_EOF, use
960 the previous value we stored earlier. */
961 M4ERROR_AT_LINE ((EXIT_FAILURE
, 0, file
, *line
,
962 "ERROR: end of file in string"));
964 if (MATCH (ch
, rquote
.string
, true))
966 if (--quote_level
== 0)
968 obstack_grow (&token_stack
, rquote
.string
, rquote
.length
);
970 else if (MATCH (ch
, lquote
.string
, true))
973 obstack_grow (&token_stack
, lquote
.string
, lquote
.length
);
976 obstack_1grow (&token_stack
, ch
);
981 obstack_1grow (&token_stack
, '\0');
983 TOKEN_DATA_TYPE (td
) = TOKEN_TEXT
;
984 TOKEN_DATA_TEXT (td
) = (char *) obstack_finish (&token_stack
);
985 #ifdef ENABLE_CHANGEWORD
986 if (orig_text
== NULL
)
987 orig_text
= TOKEN_DATA_TEXT (td
);
988 TOKEN_DATA_ORIG_TEXT (td
) = orig_text
;
991 xfprintf (stderr
, "next_token -> %s (%s)\n",
992 token_type_string (type
), TOKEN_DATA_TEXT (td
));
997 /*-----------------------------------------------.
998 | Peek at the next token from the input stream. |
999 `-----------------------------------------------*/
1005 int ch
= peek_input ();
1011 else if (ch
== CHAR_MACRO
)
1013 result
= TOKEN_MACDEF
;
1015 else if (MATCH (ch
, bcomm
.string
, false))
1017 result
= TOKEN_STRING
;
1019 else if ((default_word_regexp
&& (isalpha (ch
) || ch
== '_'))
1020 #ifdef ENABLE_CHANGEWORD
1021 || (! default_word_regexp
&& word_start
[ch
])
1022 #endif /* ENABLE_CHANGEWORD */
1025 result
= TOKEN_WORD
;
1027 else if (MATCH (ch
, lquote
.string
, false))
1029 result
= TOKEN_STRING
;
1035 result
= TOKEN_OPEN
;
1038 result
= TOKEN_COMMA
;
1041 result
= TOKEN_CLOSE
;
1044 result
= TOKEN_SIMPLE
;
1048 xfprintf (stderr
, "peek_token -> %s\n", token_type_string (result
));
1049 #endif /* DEBUG_INPUT */
1057 token_type_string (token_type t
)
1083 print_token (const char *s
, token_type t
, token_data
*td
)
1085 xfprintf (stderr
, "%s: ", s
);
1092 xfprintf (stderr
, "char:");
1096 xfprintf (stderr
, "word:");
1100 xfprintf (stderr
, "string:");
1104 xfprintf (stderr
, "macro: %p\n", TOKEN_DATA_FUNC (td
));
1108 xfprintf (stderr
, "eof\n");
1111 xfprintf (stderr
, "\t\"%s\"\n", TOKEN_DATA_TEXT (td
));
1114 static void M4_GNUC_UNUSED
1120 while ((t
= next_token (&td
)) != TOKEN_EOF
)
1121 print_token ("lex", t
, &td
);