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