]> ncurses.scripts.mit.edu Git - ncurses.git/blob - ncurses/tinfo/comp_scan.c
ncurses 6.3 - patch 20220806
[ncurses.git] / ncurses / tinfo / comp_scan.c
1 /****************************************************************************
2 ,* Copyright 2020-2021,2022 Thomas E. Dickey                                *
3  * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29
30 /****************************************************************************
31  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
32  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
33  *     and: Thomas E. Dickey                        1996 on                 *
34  ****************************************************************************/
35
36 /*
37  *      comp_scan.c --- Lexical scanner for terminfo compiler.
38  *
39  *      _nc_reset_input()
40  *      _nc_get_token()
41  *      _nc_panic_mode()
42  *      int _nc_syntax;
43  *      int _nc_curr_line;
44  *      long _nc_curr_file_pos;
45  *      long _nc_comment_start;
46  *      long _nc_comment_end;
47  */
48
49 #include <curses.priv.h>
50
51 #include <ctype.h>
52 #include <tic.h>
53
54 MODULE_ID("$Id: comp_scan.c,v 1.116 2022/05/08 00:11:44 tom Exp $")
55
56 /*
57  * Maximum length of string capability we'll accept before raising an error.
58  * Yes, there is a real capability in /etc/termcap this long, an "is".
59  */
60 #define MAXCAPLEN       600
61
62 #define iswhite(ch)     (ch == ' '  ||  ch == '\t')
63
64 NCURSES_EXPORT_VAR (int) _nc_syntax = 0;         /* termcap or terminfo? */
65 NCURSES_EXPORT_VAR (int) _nc_strict_bsd = 1;  /* ncurses extended termcap? */
66 NCURSES_EXPORT_VAR (long) _nc_curr_file_pos = 0; /* file offset of current line */
67 NCURSES_EXPORT_VAR (long) _nc_comment_start = 0; /* start of comment range before name */
68 NCURSES_EXPORT_VAR (long) _nc_comment_end = 0;   /* end of comment range before name */
69 NCURSES_EXPORT_VAR (long) _nc_start_line = 0;    /* start line of current entry */
70
71 NCURSES_EXPORT_VAR (struct token) _nc_curr_token =
72 {
73     0, 0, 0
74 };
75
76 /*****************************************************************************
77  *
78  * Token-grabbing machinery
79  *
80  *****************************************************************************/
81
82 static bool first_column;       /* See 'next_char()' below */
83 static bool had_newline;
84 static char separator;          /* capability separator */
85 static int pushtype;            /* type of pushback token */
86 static char *pushname;
87
88 #if NCURSES_EXT_FUNCS
89 NCURSES_EXPORT_VAR (bool) _nc_disable_period = FALSE; /* used by tic -a option */
90 #endif
91
92 /*****************************************************************************
93  *
94  * Character-stream handling
95  *
96  *****************************************************************************/
97
98 #define LEXBUFSIZ       1024
99
100 static char *bufptr;            /* otherwise, the input buffer pointer */
101 static char *bufstart;          /* start of buffer so we can compute offsets */
102 static FILE *yyin;              /* scanner's input file descriptor */
103
104 /*
105  *      _nc_reset_input()
106  *
107  *      Resets the input-reading routines.  Used on initialization,
108  *      or after a seek has been done.  Exactly one argument must be
109  *      non-null.
110  */
111
112 NCURSES_EXPORT(void)
113 _nc_reset_input(FILE *fp, char *buf)
114 {
115     TR(TRACE_DATABASE,
116        (T_CALLED("_nc_reset_input(fp=%p, buf=%p)"), (void *) fp, buf));
117
118     pushtype = NO_PUSHBACK;
119     if (pushname != 0)
120         pushname[0] = '\0';
121     yyin = fp;
122     bufstart = bufptr = buf;
123     _nc_curr_file_pos = 0L;
124     if (fp != 0)
125         _nc_curr_line = 0;
126     _nc_curr_col = 0;
127
128     returnVoidDB;
129 }
130
131 /*
132  *      int last_char()
133  *
134  *      Returns the final nonblank character on the current input buffer
135  */
136 static int
137 last_char(int from_end)
138 {
139     size_t len = strlen(bufptr);
140     int result = 0;
141
142     while (len--) {
143         if (!isspace(UChar(bufptr[len]))) {
144             if (from_end <= (int) len)
145                 result = bufptr[(int) len - from_end];
146             break;
147         }
148     }
149     return result;
150 }
151
152 /*
153  *      int next_char()
154  *
155  *      Returns the next character in the input stream.  Comments and leading
156  *      white space are stripped.
157  *
158  *      The global state variable 'firstcolumn' is set TRUE if the character
159  *      returned is from the first column of the input line.
160  *
161  *      The global variable _nc_curr_line is incremented for each new line.
162  *      The global variable _nc_curr_file_pos is set to the file offset of the
163  *      beginning of each line.
164  */
165
166 static int
167 next_char(void)
168 {
169     static char *result;
170     static size_t allocated;
171     int the_char;
172
173     if (!yyin) {
174         if (result != 0) {
175             FreeAndNull(result);
176             FreeAndNull(pushname);
177             bufptr = 0;
178             bufstart = 0;
179             allocated = 0;
180         }
181         /*
182          * An string with an embedded null will truncate the input.  This is
183          * intentional (we don't read binary files here).
184          */
185         if (bufptr == 0 || *bufptr == '\0')
186             return (EOF);
187         if (*bufptr == '\n') {
188             _nc_curr_line++;
189             _nc_curr_col = 0;
190         } else if (*bufptr == '\t') {
191             _nc_curr_col = (_nc_curr_col | 7);
192         }
193     } else if (!bufptr || !*bufptr) {
194         /*
195          * In theory this could be recoded to do its I/O one character at a
196          * time, saving the buffer space.  In practice, this turns out to be
197          * quite hard to get completely right.  Try it and see.  If you
198          * succeed, don't forget to hack push_back() correspondingly.
199          */
200         size_t len;
201
202         do {
203             size_t used = 0;
204             bufstart = 0;
205             do {
206                 if (used + (LEXBUFSIZ / 4) >= allocated) {
207                     allocated += (allocated + LEXBUFSIZ);
208                     result = typeRealloc(char, allocated, result);
209                     if (result == 0)
210                         return (EOF);
211                     if (bufstart)
212                         bufstart = result;
213                 }
214                 if (used == 0)
215                     _nc_curr_file_pos = ftell(yyin);
216
217                 if (fgets(result + used, (int) (allocated - used), yyin) != 0) {
218                     bufstart = result;
219                     if (used == 0) {
220                         if (_nc_curr_line == 0
221                             && IS_TIC_MAGIC(result)) {
222                             _nc_err_abort("This is a compiled terminal description, not a source");
223                         }
224                         _nc_curr_line++;
225                         _nc_curr_col = 0;
226                     }
227                 } else {
228                     if (used != 0)
229                         _nc_STRCAT(result, "\n", allocated);
230                 }
231                 if ((bufptr = bufstart) != 0) {
232                     used = strlen(bufptr);
233                     if (used == 0)
234                         return (EOF);
235                     while (iswhite(*bufptr)) {
236                         if (*bufptr == '\t') {
237                             _nc_curr_col = (_nc_curr_col | 7) + 1;
238                         } else {
239                             _nc_curr_col++;
240                         }
241                         bufptr++;
242                     }
243
244                     /*
245                      * Treat a trailing <cr><lf> the same as a <newline> so we
246                      * can read files on OS/2, etc.
247                      */
248                     if ((len = strlen(bufptr)) > 1) {
249                         if (bufptr[len - 1] == '\n'
250                             && bufptr[len - 2] == '\r') {
251                             len--;
252                             bufptr[len - 1] = '\n';
253                             bufptr[len] = '\0';
254                         }
255                     }
256                 } else {
257                     return (EOF);
258                 }
259             } while (bufptr[len - 1] != '\n');  /* complete a line */
260         } while (result[0] == '#');     /* ignore comments */
261     } else if (*bufptr == '\t') {
262         _nc_curr_col = (_nc_curr_col | 7);
263     }
264
265     first_column = (bufptr == bufstart);
266     if (first_column)
267         had_newline = FALSE;
268
269     _nc_curr_col++;
270     the_char = *bufptr++;
271     return UChar(the_char);
272 }
273
274 static void
275 push_back(int c)
276 /* push a character back onto the input stream */
277 {
278     if (bufptr == bufstart)
279         _nc_syserr_abort("Can't backspace off beginning of line");
280     *--bufptr = (char) c;
281     _nc_curr_col--;
282 }
283
284 static long
285 stream_pos(void)
286 /* return our current character position in the input stream */
287 {
288     return (yyin ? ftell(yyin) : (bufptr ? bufptr - bufstart : 0));
289 }
290
291 static bool
292 end_of_stream(void)
293 /* are we at end of input? */
294 {
295     return ((yyin ? feof(yyin) : (bufptr && *bufptr == '\0'))
296             ? TRUE : FALSE);
297 }
298
299 /* Assume we may be looking at a termcap-style continuation */
300 static NCURSES_INLINE int
301 eat_escaped_newline(int ch)
302 {
303     if (ch == '\\')
304         while ((ch = next_char()) == '\n' || iswhite(ch))
305             continue;
306     return ch;
307 }
308
309 #define TOK_BUF_SIZE MAX_ENTRY_SIZE
310
311 #define OkToAdd() \
312         ((tok_ptr - tok_buf) < (TOK_BUF_SIZE - 2))
313
314 #define AddCh(ch) \
315         *tok_ptr++ = (char) ch; \
316         *tok_ptr = '\0'
317
318 static char *tok_buf;
319
320 /*
321  *      int
322  *      get_token()
323  *
324  *      Scans the input for the next token, storing the specifics in the
325  *      global structure 'curr_token' and returning one of the following:
326  *
327  *              NAMES           A line beginning in column 1.  'name'
328  *                              will be set to point to everything up to but
329  *                              not including the first separator on the line.
330  *              BOOLEAN         An entry consisting of a name followed by
331  *                              a separator.  'name' will be set to point to
332  *                              the name of the capability.
333  *              NUMBER          An entry of the form
334  *                                      name#digits,
335  *                              'name' will be set to point to the capability
336  *                              name and 'valnumber' to the number given.
337  *              STRING          An entry of the form
338  *                                      name=characters,
339  *                              'name' is set to the capability name and
340  *                              'valstring' to the string of characters, with
341  *                              input translations done.
342  *              CANCEL          An entry of the form
343  *                                      name@,
344  *                              'name' is set to the capability name and
345  *                              'valnumber' to -1.
346  *              EOF             The end of the file has been reached.
347  *
348  *      A `separator' is either a comma or a semicolon, depending on whether
349  *      we are in termcap or terminfo mode.
350  *
351  */
352
353 NCURSES_EXPORT(int)
354 _nc_get_token(bool silent)
355 {
356     static const char terminfo_punct[] = "@%&*!#";
357
358     char *after_name;           /* after primary name */
359     char *after_list;           /* after primary and alias list */
360     char *numchk;
361     char *tok_ptr;
362     char *s;
363     char numbuf[80];
364     int ch, c0, c1;
365     int dot_flag = FALSE;
366     int type;
367     long number;
368     long token_start;
369     unsigned found;
370 #ifdef TRACE
371     int old_line;
372     int old_col;
373 #endif
374
375     DEBUG(3, (T_CALLED("_nc_get_token(silent=%d)"), silent));
376
377     if (pushtype != NO_PUSHBACK) {
378         int retval = pushtype;
379
380         _nc_set_type(pushname != 0 ? pushname : "");
381         DEBUG(3, ("pushed-back token: `%s', class %d",
382                   _nc_curr_token.tk_name, pushtype));
383
384         pushtype = NO_PUSHBACK;
385         if (pushname != 0)
386             pushname[0] = '\0';
387
388         /* currtok wasn't altered by _nc_push_token() */
389         DEBUG(3, (T_RETURN("%d"), retval));
390         return (retval);
391     }
392
393     if (end_of_stream()) {
394         yyin = 0;
395         (void) next_char();     /* frees its allocated memory */
396         if (tok_buf != 0) {
397             if (_nc_curr_token.tk_name == tok_buf)
398                 _nc_curr_token.tk_name = 0;
399         }
400         DEBUG(3, (T_RETURN("%d"), EOF));
401         return (EOF);
402     }
403
404   start_token:
405     token_start = stream_pos();
406     while ((ch = next_char()) == '\n' || iswhite(ch)) {
407         if (ch == '\n')
408             had_newline = TRUE;
409         continue;
410     }
411
412     ch = eat_escaped_newline(ch);
413     _nc_curr_token.tk_valstring = 0;
414
415 #ifdef TRACE
416     old_line = _nc_curr_line;
417     old_col = _nc_curr_col;
418 #endif
419     if (ch == EOF)
420         type = EOF;
421     else {
422         /* if this is a termcap entry, skip a leading separator */
423         if (separator == ':' && ch == ':')
424             ch = next_char();
425
426         if (ch == '.'
427 #if NCURSES_EXT_FUNCS
428             && !_nc_disable_period
429 #endif
430             ) {
431             dot_flag = TRUE;
432             DEBUG(8, ("dot-flag set"));
433
434             while ((ch = next_char()) == '.' || iswhite(ch))
435                 continue;
436         }
437
438         if (ch == EOF) {
439             type = EOF;
440             goto end_of_token;
441         }
442
443         /* have to make some punctuation chars legal for terminfo */
444         if (!isalnum(UChar(ch))
445 #if NCURSES_EXT_FUNCS
446             && !(ch == '.' && _nc_disable_period)
447 #endif
448             && ((strchr) (terminfo_punct, (char) ch) == 0)) {
449             if (!silent)
450                 _nc_warning("Illegal character (expected alphanumeric or %s) - '%s'",
451                             terminfo_punct, unctrl(UChar(ch)));
452             _nc_panic_mode(separator);
453             goto start_token;
454         }
455
456         if (tok_buf == 0)
457             tok_buf = typeMalloc(char, TOK_BUF_SIZE);
458
459 #ifdef TRACE
460         old_line = _nc_curr_line;
461         old_col = _nc_curr_col;
462 #endif
463         tok_ptr = tok_buf;
464         AddCh(ch);
465
466         if (first_column) {
467             _nc_comment_start = token_start;
468             _nc_comment_end = _nc_curr_file_pos;
469             _nc_start_line = _nc_curr_line;
470
471             _nc_syntax = ERR;
472             after_name = 0;
473             after_list = 0;
474             while ((ch = next_char()) != '\n') {
475                 if (ch == EOF) {
476                     _nc_err_abort(MSG_NO_INPUTS);
477                 } else if (ch == '|') {
478                     after_list = tok_ptr;
479                     if (after_name == 0)
480                         after_name = tok_ptr;
481                 } else if (ch == ':' && last_char(0) != ',') {
482                     _nc_syntax = SYN_TERMCAP;
483                     separator = ':';
484                     break;
485                 } else if (ch == ',') {
486                     _nc_syntax = SYN_TERMINFO;
487                     separator = ',';
488                     /*
489                      * If we did not see a '|', then we found a name with no
490                      * aliases or description.
491                      */
492                     if (after_name == 0)
493                         break;
494                     /*
495                      * We saw a comma, but are not entirely sure this is
496                      * terminfo format, since we can still be parsing the
497                      * description field (for either syntax).
498                      *
499                      * A properly formatted termcap line ends with either a
500                      * colon, or a backslash after a colon.  It is possible
501                      * to have a backslash in the middle of a capability, but
502                      * then there would be no leading whitespace on the next
503                      * line - something we want to discourage.
504                      */
505                     c0 = last_char(0);
506                     c1 = last_char(1);
507                     if (c1 != ':' && c0 != '\\' && c0 != ':') {
508                         bool capability = FALSE;
509
510                         /*
511                          * Since it is not termcap, assume the line is terminfo
512                          * format.  However, the comma can be embedded in a
513                          * description field.  It also can be a separator
514                          * between a description field and a capability.
515                          *
516                          * Improve the guess by checking if the next word after
517                          * the comma does not look like a capability.  In that
518                          * case, extend the description past the comma.
519                          */
520                         for (s = bufptr; isspace(UChar(*s)); ++s) {
521                             ;
522                         }
523                         if (islower(UChar(*s))) {
524                             char *name = s;
525                             while (isalnum(UChar(*s))) {
526                                 ++s;
527                             }
528                             if (*s == '#' || *s == '=' || *s == '@') {
529                                 /*
530                                  * Checking solely with syntax allows us to
531                                  * support extended capabilities with string
532                                  * values.
533                                  */
534                                 capability = TRUE;
535                             } else if (*s == ',') {
536                                 c0 = *s;
537                                 *s = '\0';
538                                 /*
539                                  * Otherwise, we can handle predefined boolean
540                                  * capabilities, still aided by syntax.
541                                  */
542                                 if (_nc_find_entry(name,
543                                                    _nc_get_hash_table(FALSE))) {
544                                     capability = TRUE;
545                                 }
546                                 *s = (char) c0;
547                             }
548                         }
549                         if (capability) {
550                             break;
551                         }
552                     }
553                 } else
554                     ch = eat_escaped_newline(ch);
555
556                 if (OkToAdd()) {
557                     AddCh(ch);
558                 } else {
559                     break;
560                 }
561             }
562             *tok_ptr = '\0';
563             if (_nc_syntax == ERR) {
564                 /*
565                  * Grrr...what we ought to do here is barf, complaining that
566                  * the entry is malformed.  But because a couple of name fields
567                  * in the 8.2 termcap file end with |\, we just have to assume
568                  * it is termcap syntax.
569                  */
570                 _nc_syntax = SYN_TERMCAP;
571                 separator = ':';
572             } else if (_nc_syntax == SYN_TERMINFO) {
573                 /* throw away trailing /, *$/ */
574                 for (--tok_ptr;
575                      iswhite(*tok_ptr) || *tok_ptr == ',';
576                      tok_ptr--)
577                     continue;
578                 tok_ptr[1] = '\0';
579             }
580
581             /*
582              * This is the soonest we have the terminal name fetched.  Set up
583              * for following warning messages.  If there's no '|', then there
584              * is no description.
585              */
586             if (after_name != 0) {
587                 ch = *after_name;
588                 *after_name = '\0';
589                 _nc_set_type(tok_buf);
590                 *after_name = (char) ch;
591             }
592
593             /*
594              * Compute the boundary between the aliases and the description
595              * field for syntax-checking purposes.
596              */
597             if (after_list != 0) {
598                 if (!silent) {
599                     if (*after_list == '\0' || strchr("|", after_list[1]) != NULL) {
600                         _nc_warning("empty longname field");
601                     } else if (strchr(after_list, ' ') == 0) {
602                         _nc_warning("older tic versions may treat the description field as an alias");
603                     }
604                 }
605             } else {
606                 after_list = tok_buf + strlen(tok_buf);
607                 DEBUG(2, ("missing description"));
608             }
609
610             /*
611              * Whitespace in a name field other than the long name can confuse
612              * rdist and some termcap tools.  Slashes are a no-no.  Other
613              * special characters can be dangerous due to shell expansion.
614              */
615             for (s = tok_buf; s < after_list; ++s) {
616                 if (isspace(UChar(*s))) {
617                     if (!silent)
618                         _nc_warning("whitespace in name or alias field");
619                     break;
620                 } else if (*s == '/') {
621                     if (!silent)
622                         _nc_warning("slashes aren't allowed in names or aliases");
623                     break;
624                 } else if (strchr("$[]!*?", *s)) {
625                     if (!silent)
626                         _nc_warning("dubious character `%c' in name or alias field", *s);
627                     break;
628                 }
629             }
630
631             _nc_curr_token.tk_name = tok_buf;
632             type = NAMES;
633         } else {
634             if (had_newline && _nc_syntax == SYN_TERMCAP) {
635                 _nc_warning("Missing backslash before newline");
636                 had_newline = FALSE;
637             }
638             while ((ch = next_char()) != EOF) {
639                 if (!isalnum(UChar(ch))) {
640                     if (_nc_syntax == SYN_TERMINFO) {
641                         if (ch != '_')
642                             break;
643                     } else {    /* allow ';' for "k;" */
644                         if (ch != ';')
645                             break;
646                     }
647                 }
648                 if (OkToAdd()) {
649                     AddCh(ch);
650                 } else {
651                     ch = EOF;
652                     break;
653                 }
654             }
655
656             *tok_ptr++ = '\0';  /* separate name/value in buffer */
657             switch (ch) {
658             case ',':
659             case ':':
660                 if (ch != separator)
661                     _nc_err_abort("Separator inconsistent with syntax");
662                 _nc_curr_token.tk_name = tok_buf;
663                 type = BOOLEAN;
664                 break;
665             case '@':
666                 if ((ch = next_char()) != separator && !silent)
667                     _nc_warning("Missing separator after `%s', have %s",
668                                 tok_buf, unctrl(UChar(ch)));
669                 _nc_curr_token.tk_name = tok_buf;
670                 type = CANCEL;
671                 break;
672
673             case '#':
674                 found = 0;
675                 while (isalnum(ch = next_char())) {
676                     numbuf[found++] = (char) ch;
677                     if (found >= sizeof(numbuf) - 1)
678                         break;
679                 }
680                 numbuf[found] = '\0';
681                 number = strtol(numbuf, &numchk, 0);
682                 if (!silent) {
683                     if (numchk == numbuf)
684                         _nc_warning("no value given for `%s'", tok_buf);
685                     if ((*numchk != '\0') || (ch != separator))
686                         _nc_warning("Missing separator for `%s'", tok_buf);
687                     if (number < 0)
688                         _nc_warning("value of `%s' cannot be negative", tok_buf);
689                     if (number > MAX_OF_TYPE(NCURSES_INT2)) {
690                         _nc_warning("limiting value of `%s' from %#lx to %#x",
691                                     tok_buf,
692                                     number, MAX_OF_TYPE(NCURSES_INT2));
693                         number = MAX_OF_TYPE(NCURSES_INT2);
694                     }
695                 }
696                 _nc_curr_token.tk_name = tok_buf;
697                 _nc_curr_token.tk_valnumber = (int) number;
698                 type = NUMBER;
699                 break;
700
701             case '=':
702                 ch = _nc_trans_string(tok_ptr, tok_buf + TOK_BUF_SIZE);
703                 if (!silent && ch != separator)
704                     _nc_warning("Missing separator");
705                 _nc_curr_token.tk_name = tok_buf;
706                 _nc_curr_token.tk_valstring = tok_ptr;
707                 type = STRING;
708                 break;
709
710             case EOF:
711                 type = EOF;
712                 break;
713             default:
714                 /* just to get rid of the compiler warning */
715                 type = UNDEF;
716                 if (!silent)
717                     _nc_warning("Illegal character - '%s'", unctrl(UChar(ch)));
718             }
719         }                       /* end else (first_column == FALSE) */
720     }                           /* end else (ch != EOF) */
721
722   end_of_token:
723
724 #ifdef TRACE
725     if (dot_flag == TRUE)
726         DEBUG(8, ("Commented out "));
727
728     if (_nc_tracing >= DEBUG_LEVEL(8)) {
729         _tracef("parsed %d.%d to %d.%d",
730                 old_line, old_col,
731                 _nc_curr_line, _nc_curr_col);
732     }
733     if (_nc_tracing >= DEBUG_LEVEL(7)) {
734         switch (type) {
735         case BOOLEAN:
736             _tracef("Token: Boolean; name='%s'",
737                     _nc_curr_token.tk_name);
738             break;
739
740         case NUMBER:
741             _tracef("Token: Number;  name='%s', value=%d",
742                     _nc_curr_token.tk_name,
743                     _nc_curr_token.tk_valnumber);
744             break;
745
746         case STRING:
747             _tracef("Token: String;  name='%s', value=%s",
748                     _nc_curr_token.tk_name,
749                     _nc_visbuf(_nc_curr_token.tk_valstring));
750             break;
751
752         case CANCEL:
753             _tracef("Token: Cancel; name='%s'",
754                     _nc_curr_token.tk_name);
755             break;
756
757         case NAMES:
758
759             _tracef("Token: Names; value='%s'",
760                     _nc_curr_token.tk_name);
761             break;
762
763         case EOF:
764             _tracef("Token: End of file");
765             break;
766
767         default:
768             _nc_warning("Bad token type");
769         }
770     }
771 #endif
772
773     if (dot_flag == TRUE)       /* if commented out, use the next one */
774         type = _nc_get_token(silent);
775
776     DEBUG(3, ("token: `%s', class %d",
777               ((_nc_curr_token.tk_name != 0)
778                ? _nc_curr_token.tk_name
779                : "<null>"),
780               type));
781
782     DEBUG(3, (T_RETURN("%d"), type));
783     return (type);
784 }
785
786 /*
787  *      char
788  *      trans_string(ptr)
789  *
790  *      Reads characters using next_char() until encountering a separator, nl,
791  *      or end-of-file.  The returned value is the character which caused
792  *      reading to stop.  The following translations are done on the input:
793  *
794  *              ^X  goes to  ctrl-X (i.e. X & 037)
795  *              {\E,\n,\r,\b,\t,\f}  go to
796  *                      {ESCAPE,newline,carriage-return,backspace,tab,formfeed}
797  *              {\^,\\}  go to  {carat,backslash}
798  *              \ddd (for ddd = up to three octal digits)  goes to the character ddd
799  *
800  *              \e == \E
801  *              \0 == \200
802  *
803  */
804
805 NCURSES_EXPORT(int)
806 _nc_trans_string(char *ptr, char *last)
807 {
808     int count = 0;
809     int number = 0;
810     int i, c;
811     int last_ch = '\0';
812     bool ignored = FALSE;
813     bool long_warning = FALSE;
814
815     while ((c = next_char()) != separator && c != EOF) {
816         if (ptr >= (last - 1)) {
817             if (c != EOF) {
818                 while ((c = next_char()) != separator && c != EOF) {
819                     ;
820                 }
821             }
822             break;
823         }
824         if ((_nc_syntax == SYN_TERMCAP) && c == '\n')
825             break;
826         if (c == '^' && last_ch != '%') {
827             c = next_char();
828             if (c == EOF)
829                 _nc_err_abort(MSG_NO_INPUTS);
830
831             if (!(is7bits(c) && isprint(c))) {
832                 _nc_warning("Illegal ^ character - '%s'", unctrl(UChar(c)));
833             }
834             if (c == '?' && (_nc_syntax != SYN_TERMCAP)) {
835                 *(ptr++) = '\177';
836             } else {
837                 if ((c &= 037) == 0)
838                     c = 128;
839                 *(ptr++) = (char) (c);
840             }
841         } else if (c == '\\') {
842             bool strict_bsd = ((_nc_syntax == SYN_TERMCAP) && _nc_strict_bsd);
843
844             c = next_char();
845             if (c == EOF)
846                 _nc_err_abort(MSG_NO_INPUTS);
847
848             if (isoctal(c) || (strict_bsd && isdigit(c))) {
849                 number = c - '0';
850                 for (i = 0; i < 2; i++) {
851                     c = next_char();
852                     if (c == EOF)
853                         _nc_err_abort(MSG_NO_INPUTS);
854
855                     if (!isoctal(c)) {
856                         if (isdigit(c)) {
857                             if (!strict_bsd) {
858                                 _nc_warning("Non-octal digit `%c' in \\ sequence", c);
859                                 /* allow the digit; it'll do less harm */
860                             }
861                         } else {
862                             push_back(c);
863                             break;
864                         }
865                     }
866
867                     number = number * 8 + c - '0';
868                 }
869
870                 number = UChar(number);
871                 if (number == 0 && !strict_bsd)
872                     number = 0200;
873                 *(ptr++) = (char) number;
874             } else {
875                 switch (c) {
876                 case 'E':
877                     *(ptr++) = '\033';
878                     break;
879
880                 case 'n':
881                     *(ptr++) = '\n';
882                     break;
883
884                 case 'r':
885                     *(ptr++) = '\r';
886                     break;
887
888                 case 'b':
889                     *(ptr++) = '\010';
890                     break;
891
892                 case 'f':
893                     *(ptr++) = '\014';
894                     break;
895
896                 case 't':
897                     *(ptr++) = '\t';
898                     break;
899
900                 case '\\':
901                     *(ptr++) = '\\';
902                     break;
903
904                 case '^':
905                     *(ptr++) = '^';
906                     break;
907
908                 case ',':
909                     *(ptr++) = ',';
910                     break;
911
912                 case '\n':
913                     continue;
914
915                 default:
916                     if ((_nc_syntax == SYN_TERMINFO) || !_nc_strict_bsd) {
917                         switch (c) {
918                         case 'a':
919                             c = '\007';
920                             break;
921                         case 'e':
922                             c = '\033';
923                             break;
924                         case 'l':
925                             c = '\n';
926                             break;
927                         case 's':
928                             c = ' ';
929                             break;
930                         case ':':
931                             c = ':';
932                             break;
933                         default:
934                             _nc_warning("Illegal character '%s' in \\ sequence",
935                                         unctrl(UChar(c)));
936                             break;
937                         }
938                     }
939                     /* FALLTHRU */
940                 case '|':
941                     *(ptr++) = (char) c;
942                 }               /* endswitch (c) */
943             }                   /* endelse (c < '0' ||  c > '7') */
944         }
945         /* end else if (c == '\\') */
946         else if (c == '\n' && (_nc_syntax == SYN_TERMINFO)) {
947             /*
948              * Newlines embedded in a terminfo string are ignored, provided
949              * that the next line begins with whitespace.
950              */
951             ignored = TRUE;
952         } else {
953             *(ptr++) = (char) c;
954         }
955
956         if (!ignored) {
957             if (_nc_curr_col <= 1) {
958                 push_back(c);
959                 c = '\n';
960                 break;
961             }
962             last_ch = c;
963             count++;
964         }
965         ignored = FALSE;
966
967         if (count > MAXCAPLEN && !long_warning) {
968             _nc_warning("Very long string found.  Missing separator?");
969             long_warning = TRUE;
970         }
971     }                           /* end while */
972
973     *ptr = '\0';
974
975     return (c);
976 }
977
978 /*
979  *      _nc_push_token()
980  *
981  *      Push a token of given type so that it will be reread by the next
982  *      get_token() call.
983  */
984
985 NCURSES_EXPORT(void)
986 _nc_push_token(int tokclass)
987 {
988     /*
989      * This implementation is kind of bogus, it will fail if we ever do more
990      * than one pushback at a time between get_token() calls.  It relies on the
991      * fact that _nc_curr_token is static storage that nothing but
992      * _nc_get_token() touches.
993      */
994     pushtype = tokclass;
995     if (pushname == 0)
996         pushname = typeMalloc(char, MAX_NAME_SIZE + 1);
997     _nc_get_type(pushname);
998
999     DEBUG(3, ("pushing token: `%s', class %d",
1000               ((_nc_curr_token.tk_name != 0)
1001                ? _nc_curr_token.tk_name
1002                : "<null>"),
1003               pushtype));
1004 }
1005
1006 /*
1007  * Panic mode error recovery - skip everything until a "ch" is found.
1008  */
1009 NCURSES_EXPORT(void)
1010 _nc_panic_mode(char ch)
1011 {
1012     for (;;) {
1013         int c = next_char();
1014         if (c == ch)
1015             return;
1016         if (c == EOF)
1017             return;
1018     }
1019 }
1020
1021 #if NO_LEAKS
1022 NCURSES_EXPORT(void)
1023 _nc_comp_scan_leaks(void)
1024 {
1025     if (pushname != 0) {
1026         FreeAndNull(pushname);
1027     }
1028     if (tok_buf != 0) {
1029         FreeAndNull(tok_buf);
1030     }
1031 }
1032 #endif