1 /* Substitution of parameters in strings from terminal descriptions.
2 Copyright (C) 2006-2023 Free Software Foundation, Inc.
3
4 This file is free software: you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as
6 published by the Free Software Foundation, either version 3 of the
7 License, or (at your option) any later version.
8
9 This file is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Originally by Ross Ridge, Public Domain, 92/02/01 07:30:36 */
18
19 #include <config.h>
20
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <string.h>
24
25 #include "attribute.h"
26 #include "c-ctype.h"
27
28 #ifdef USE_SCCS_IDS
29 static const char SCCSid[] = "@(#) mytinfo tparm.c 3.2 92/02/01 public domain, By Ross Ridge";
30 #endif
31
32 #ifndef MAX_PUSHED
33 #define MAX_PUSHED 32
34 #endif
35
36 #define ARG 1
37 #define NUM 2
38
39 #define INTEGER 1
40 #define STRING 2
41
42 #define MAX_LINE 640
43
44 typedef struct stack_str
45 {
46 int type;
47 int argnum;
48 int value;
49 } stack;
50
51 static stack S[MAX_PUSHED];
52 static stack vars['z'-'a'+1];
53 static int pos = 0;
54
55 static
56 struct arg_str
57 {
58 int type;
59 int integer;
60 char *string;
61 } arg_list[10];
62
63 static int argcnt;
64
65 static va_list tparm_args;
66
67 static int
68 pusharg (int arg)
69 {
70 if (pos == MAX_PUSHED)
71 return 1;
72 S[pos].type = ARG;
73 S[pos++].argnum = arg;
74 return 0;
75 }
76
77 static int
78 pushnum (int num)
79 {
80 if (pos == MAX_PUSHED)
81 return 1;
82 S[pos].type = NUM;
83 S[pos++].value = num;
84 return 0;
85 }
86
87 static int
88 getarg (int argnum, int type, void *p)
89 {
90 while (argcnt < argnum)
91 {
92 arg_list[argcnt].type = INTEGER;
93 arg_list[argcnt++].integer = (int) va_arg (tparm_args, int);
94 }
95 if (argcnt > argnum)
96 {
97 if (arg_list[argnum].type != type)
98 return 1;
99 else if (type == STRING)
100 *(char **)p = arg_list[argnum].string;
101 else
102 *(int *)p = arg_list[argnum].integer;
103 }
104 else
105 {
106 arg_list[argcnt].type = type;
107 if (type == STRING)
108 *(char **)p = arg_list[argcnt++].string = (char *) va_arg (tparm_args, char *);
109 else
110 *(int *)p = arg_list[argcnt++].integer = (int) va_arg (tparm_args, int);
111 }
112 return 0;
113 }
114
115 static int
116 popstring (char **str)
117 {
118 if (pos-- == 0)
119 return 1;
120 if (S[pos].type != ARG)
121 return 1;
122 return getarg (S[pos].argnum, STRING, str);
123 }
124
125 static int
126 popnum (int *num)
127 {
128 if (pos-- == 0)
129 return 1;
130 switch (S[pos].type)
131 {
132 case ARG:
133 return getarg (S[pos].argnum, INTEGER, num);
134 case NUM:
135 *num = S[pos].value;
136 return 0;
137 }
138 return 1;
139 }
140
141 static int
142 cvtchar (const char *sp, char *c)
143 {
144 switch (*sp)
145 {
146 case '\\':
147 switch (*++sp)
148 {
149 case '\'':
150 case '$':
151 case '\\':
152 case '%':
153 *c = *sp;
154 return 2;
155 case '\0':
156 *c = '\\';
157 return 1;
158 case '0':
159 if (sp[1] == '0' && sp[2] == '0')
160 {
161 *c = '\0';
162 return 4;
163 }
164 *c = '\200'; /* '\0' ???? */
165 return 2;
166 default:
167 *c = *sp;
168 return 2;
169 }
170 default:
171 *c = *sp;
172 return 1;
173 }
174 }
175
176 /* sigh... this has got to be the ugliest code I've ever written.
177 Trying to handle everything has its cost, I guess.
178
179 It actually isn't too hard to figure out if a given % code is supposed
180 to be interpreted with its termcap or terminfo meaning since almost
181 all terminfo codes are invalid unless something has been pushed on
182 the stack and termcap strings will never push things on the stack
183 (%p isn't used by termcap). So where we have a choice we make the
184 decision by whether or not something has been pushed on the stack.
185 The static variable termcap keeps track of this; it starts out set
186 to 1 and is incremented for each argument processed for a termcap % code,
187 however if something is pushed on the stack it's set to 0 and the
188 rest of the % codes are interpreted as terminfo % codes. Another way
189 of putting it is that if termcap equals one we haven't decided either
190 way yet, if it equals zero we're looking for terminfo codes, and if
191 its greater than 1 we're looking for termcap codes.
192
193 Terminfo % codes:
194
195 %% output a '%'
196 %[[:][-+# ][width][.precision]][doxXs]
197 output pop according to the printf format
198 %c output pop as a char
199 %'c' push character constant c.
200 %{n} push decimal constant n.
201 %p[1-9] push parameter [1-9]
202 %g[a-z] push variable [a-z]
203 %P[a-z] put pop in variable [a-z]
204 %l push the length of pop (a string)
205 %+ add pop to pop and push the result
206 %- subtract pop from pop and push the result
207 %* multiply pop and pop and push the result
208 %& bitwise and pop and pop and push the result
209 %| bitwise or pop and pop and push the result
210 %^ bitwise xor pop and pop and push the result
211 %~ push the bitwise not of pop
212 %= compare if pop and pop are equal and push the result
213 %> compare if pop is less than pop and push the result
214 %< compare if pop is greater than pop and push the result
215 %A logical and pop and pop and push the result
216 %O logical or pop and pop and push the result
217 %! push the logical not of pop
218 %? condition %t if_true [%e if_false] %;
219 if condition evaluates as true then evaluate if_true,
220 else evaluate if_false. elseif's can be done:
221 %? cond %t true [%e cond2 %t true2] ... [%e condN %t trueN] [%e false] %;
222 %i add one to parameters 1 and 2. (ANSI)
223
224 Termcap Codes:
225
226 %% output a %
227 %. output parameter as a character
228 %d output parameter as a decimal number
229 %2 output parameter in printf format %02d
230 %3 output parameter in printf format %03d
231 %+x add the character x to parameter and output it as a character
232 (UW) %-x subtract parameter FROM the character x and output it as a char
233 (UW) %ax add the character x to parameter
234 (GNU) %a[+*-/=][cp]x
235 GNU arithmetic.
236 (UW) %sx subtract parameter FROM the character x
237 %>xy if parameter > character x then add character y to parameter
238 %B convert to BCD (parameter = (parameter/10)*16 + parameter%16)
239 %D Delta Data encode (parameter = parameter - 2*(parameter%16))
240 %i increment the first two parameters by one
241 %n xor the first two parameters by 0140
242 (GNU) %m xor the first two parameters by 0177
243 %r swap the first two parameters
244 (GNU) %b backup to previous parameter
245 (GNU) %f skip this parameter
246
247 Note the two definitions of %a, the GNU definition is used if the characters
248 after the 'a' are valid, otherwise the UW definition is used.
249
250 (GNU) used by GNU Emacs termcap libraries
251 (UW) used by the University of Waterloo (MFCF) termcap libraries
252
253 */
254
255 char *
256 tparm (const char *str, ...)
257 {
258 static int termcap;
259 static char OOPS[] = "OOPS";
260 static char buf[MAX_LINE];
261 const char *sp;
262 char *dp;
263 const char *fmt;
264 char scan_for;
265 int scan_depth;
266 int if_depth;
267 char fmt_buf[MAX_LINE];
268 char sbuf[MAX_LINE];
269
270 va_start (tparm_args, str);
271
272 sp = str;
273 dp = buf;
274 scan_for = 0;
275 scan_depth = 0;
276 if_depth = 0;
277 argcnt = 0;
278 pos = 0;
279 termcap = 1;
280 while (*sp != '\0')
281 {
282 switch (*sp)
283 {
284 case '\\':
285 if (scan_for)
286 {
287 if (*++sp != '\0')
288 sp++;
289 break;
290 }
291 *dp++ = *sp++;
292 if (*sp != '\0')
293 *dp++ = *sp++;
294 break;
295 case '%':
296 sp++;
297 if (scan_for)
298 {
299 if (*sp == scan_for && if_depth == scan_depth)
300 {
301 if (scan_for == ';')
302 if_depth--;
303 scan_for = 0;
304 }
305 else if (*sp == '?')
306 if_depth++;
307 else if (*sp == ';')
308 {
309 if (if_depth == 0)
310 return OOPS;
311 else
312 if_depth--;
313 }
314 sp++;
315 break;
316 }
317 fmt = NULL;
318 switch (*sp)
319 {
320 case '%':
321 *dp++ = *sp++;
322 break;
323 case '+':
324 if (!termcap)
325 {
326 int i, j;
327 if (popnum (&j) || popnum (&i))
328 return OOPS;
329 i += j;
330 if (pushnum (i))
331 return OOPS;
332 sp++;
333 break;
334 }
335 FALLTHROUGH;
336 case 'C':
337 if (*sp == 'C')
338 {
339 int i;
340 if (getarg (termcap - 1, INTEGER, &i))
341 return OOPS;
342 if (i >= 96)
343 {
344 i /= 96;
345 if (i == '$')
346 *dp++ = '\\';
347 *dp++ = i;
348 }
349 }
350 fmt = "%c";
351 FALLTHROUGH;
352 case 'a':
353 if (!termcap)
354 return OOPS;
355 {
356 int i;
357 if (getarg (termcap - 1, INTEGER, &i))
358 return OOPS;
359 if (*++sp == '\0')
360 return OOPS;
361 if ((sp[1] == 'p' || sp[1] == 'c')
362 && sp[2] != '\0' && fmt == NULL)
363 {
364 /* GNU arithmetic parameter, what they really need is
365 terminfo. */
366 int val;
367 int lc;
368 if (sp[1] == 'p'
369 && getarg (termcap - 1 + sp[2] - '@', INTEGER, &val))
370 return OOPS;
371 if (sp[1] == 'c')
372 {
373 char c;
374 lc = cvtchar (sp + 2, &c) + 2;
375 /* Mask out 8th bit so \200 can be used for \0 as per
376 GNU docs. */
377 val = c & 0177;
378 }
379 else
380 lc = 2;
381 switch (sp[0])
382 {
383 case '=':
384 break;
385 case '+':
386 val = i + val;
387 break;
388 case '-':
389 val = i - val;
390 break;
391 case '*':
392 val = i * val;
393 break;
394 case '/':
395 val = i / val;
396 break;
397 default:
398 /* Not really GNU's %a after all... */
399 {
400 char c;
401 lc = cvtchar (sp, &c);
402 val = c + i;
403 }
404 break;
405 }
406 arg_list[termcap - 1].integer = val;
407 sp += lc;
408 break;
409 }
410 {
411 char c;
412 sp += cvtchar (sp, &c);
413 arg_list[termcap - 1].integer = c + i;
414 }
415 }
416 if (fmt == NULL)
417 break;
418 sp--;
419 FALLTHROUGH;
420 case '-':
421 if (!termcap)
422 {
423 int i, j;
424 if (popnum (&j) || popnum (&i))
425 return OOPS;
426 i -= j;
427 if (pushnum (i))
428 return OOPS;
429 sp++;
430 break;
431 }
432 fmt = "%c";
433 FALLTHROUGH;
434 case 's':
435 if (termcap && (fmt == NULL || *sp == '-'))
436 {
437 int i;
438 if (getarg (termcap - 1, INTEGER, &i))
439 return OOPS;
440 if (*++sp == '\0')
441 return OOPS;
442 {
443 char c;
444 sp += cvtchar (sp, &c);
445 arg_list[termcap - 1].integer = c - i;
446 }
447 if (fmt == NULL)
448 break;
449 sp--;
450 }
451 if (!termcap)
452 return OOPS;
453 FALLTHROUGH;
454 case '.':
455 if (termcap && fmt == NULL)
456 fmt = "%c";
457 FALLTHROUGH;
458 case 'd':
459 if (termcap && fmt == NULL)
460 fmt = "%d";
461 FALLTHROUGH;
462 case '2':
463 if (termcap && fmt == NULL)
464 fmt = "%02d";
465 FALLTHROUGH;
466 case '3':
467 if (termcap && fmt == NULL)
468 fmt = "%03d";
469 FALLTHROUGH;
470 case ':': case ' ': case '#': case 'u':
471 case 'x': case 'X': case 'o': case 'c':
472 case '0': case '1': case '4': case '5':
473 case '6': case '7': case '8': case '9':
474 if (fmt == NULL)
475 {
476 char *fmtp;
477 if (termcap)
478 return OOPS;
479 if (*sp == ':')
480 sp++;
481 fmtp = fmt_buf;
482 *fmtp++ = '%';
483 while (*sp != 's' && *sp != 'x' && *sp != 'X' && *sp != 'd'
484 && *sp != 'o' && *sp != 'c' && *sp != 'u')
485 {
486 if (*sp == '\0')
487 return OOPS;
488 *fmtp++ = *sp++;
489 }
490 *fmtp++ = *sp;
491 *fmtp = '\0';
492 fmt = fmt_buf;
493 }
494 {
495 char conv_char = fmt[strlen (fmt) - 1];
496 if (conv_char == 's')
497 {
498 char *s;
499 if (popstring (&s))
500 return OOPS;
501 sprintf (sbuf, fmt, s);
502 }
503 else
504 {
505 int i;
506 if (termcap)
507 {
508 if (getarg (termcap++ - 1, INTEGER, &i))
509 return OOPS;
510 }
511 else
512 if (popnum (&i))
513 return OOPS;
514 if (i == 0 && conv_char == 'c')
515 strcpy (sbuf, "\000");
516 else
517 sprintf (sbuf, fmt, i);
518 }
519 }
520 sp++;
521 fmt = sbuf;
522 while (*fmt != '\0')
523 {
524 if (*fmt == '$')
525 *dp++ = '\\';
526 *dp++ = *fmt++;
527 }
528 break;
529 case 'r':
530 {
531 int i;
532 if (!termcap || getarg (1, INTEGER, &i))
533 return OOPS;
534 arg_list[1].integer = arg_list[0].integer;
535 arg_list[0].integer = i;
536 }
537 sp++;
538 break;
539 case 'i':
540 {
541 int i;
542 if (getarg (1, INTEGER, &i) || arg_list[0].type != INTEGER)
543 return OOPS;
544 }
545 arg_list[1].integer++;
546 arg_list[0].integer++;
547 sp++;
548 break;
549 case 'n':
550 {
551 int i;
552 if (!termcap || getarg (1, INTEGER, &i))
553 return OOPS;
554 }
555 arg_list[0].integer ^= 0140;
556 arg_list[1].integer ^= 0140;
557 sp++;
558 break;
559 case '>':
560 if (!termcap)
561 {
562 int i, j;
563 if (popnum (&j) || popnum (&i))
564 return OOPS;
565 i = (i > j);
566 if (pushnum (i))
567 return OOPS;
568 sp++;
569 break;
570 }
571 {
572 int i;
573 if (getarg (termcap-1, INTEGER, &i))
574 return OOPS;
575 {
576 char c;
577 sp += cvtchar (sp, &c);
578 if (i > c)
579 {
580 sp += cvtchar (sp, &c);
581 arg_list[termcap-1].integer += c;
582 }
583 else
584 sp += cvtchar (sp, &c);
585 }
586 }
587 sp++;
588 break;
589 case 'B':
590 {
591 int i;
592 if (!termcap || getarg (termcap-1, INTEGER, &i))
593 return OOPS;
594 arg_list[termcap-1].integer = 16 * (i / 10) + i % 10;
595 }
596 sp++;
597 break;
598 case 'D':
599 {
600 int i;
601 if (!termcap || getarg (termcap-1, INTEGER, &i))
602 return OOPS;
603 arg_list[termcap-1].integer = i - 2 * (i % 16);
604 }
605 sp++;
606 break;
607 case 'p':
608 if (termcap > 1)
609 return OOPS;
610 if (*++sp == '\0')
611 return OOPS;
612 {
613 int i = (*sp == '0' ? 9 : *sp - '1');
614 if (i < 0 || i > 9)
615 return OOPS;
616 if (pusharg (i))
617 return OOPS;
618 }
619 termcap = 0;
620 sp++;
621 break;
622 case 'P':
623 if (termcap || *++sp == '\0')
624 return OOPS;
625 {
626 int i = *sp++ - 'a';
627 if (i < 0 || i > 25)
628 return OOPS;
629 if (pos-- == 0)
630 return OOPS;
631 switch (vars[i].type = S[pos].type)
632 {
633 case ARG:
634 vars[i].argnum = S[pos].argnum;
635 break;
636 case NUM:
637 vars[i].value = S[pos].value;
638 break;
639 }
640 }
641 break;
642 case 'g':
643 if (termcap || *++sp == '\0')
644 return OOPS;
645 {
646 int i = *sp++ - 'a';
647 if (i < 0 || i > 25)
648 return OOPS;
649 switch (vars[i].type)
650 {
651 case ARG:
652 if (pusharg (vars[i].argnum))
653 return OOPS;
654 break;
655 case NUM:
656 if (pushnum (vars[i].value))
657 return OOPS;
658 break;
659 }
660 }
661 break;
662 case '\'':
663 if (termcap > 1)
664 return OOPS;
665 if (*++sp == '\0')
666 return OOPS;
667 {
668 char c;
669 sp += cvtchar (sp, &c);
670 if (pushnum (c) || *sp++ != '\'')
671 return OOPS;
672 }
673 termcap = 0;
674 break;
675 case '{':
676 if (termcap > 1)
677 return OOPS;
678 {
679 int i;
680 i = 0;
681 sp++;
682 while (c_isdigit (*sp))
683 i = 10 * i + *sp++ - '0';
684 if (*sp++ != '}' || pushnum (i))
685 return OOPS;
686 }
687 termcap = 0;
688 break;
689 case 'l':
690 {
691 int i;
692 char *s;
693 if (termcap || popstring (&s))
694 return OOPS;
695 i = strlen (s);
696 if (pushnum (i))
697 return OOPS;
698 }
699 sp++;
700 break;
701 case '*':
702 {
703 int i, j;
704 if (termcap || popnum (&j) || popnum (&i))
705 return OOPS;
706 i *= j;
707 if (pushnum (i))
708 return OOPS;
709 }
710 sp++;
711 break;
712 case '/':
713 {
714 int i, j;
715 if (termcap || popnum (&j) || popnum (&i))
716 return OOPS;
717 i /= j;
718 if (pushnum (i))
719 return OOPS;
720 }
721 sp++;
722 break;
723 case 'm':
724 if (termcap)
725 {
726 int i;
727 if (getarg (1, INTEGER, &i))
728 return OOPS;
729 arg_list[0].integer ^= 0177;
730 arg_list[1].integer ^= 0177;
731 sp++;
732 break;
733 }
734 {
735 int i, j;
736 if (popnum (&j) || popnum (&i))
737 return OOPS;
738 i %= j;
739 if (pushnum (i))
740 return OOPS;
741 }
742 sp++;
743 break;
744 case '&':
745 {
746 int i, j;
747 if (popnum (&j) || popnum (&i))
748 return OOPS;
749 i &= j;
750 if (pushnum (i))
751 return OOPS;
752 }
753 sp++;
754 break;
755 case '|':
756 {
757 int i, j;
758 if (popnum (&j) || popnum (&i))
759 return OOPS;
760 i |= j;
761 if (pushnum (i))
762 return OOPS;
763 }
764 sp++;
765 break;
766 case '^':
767 {
768 int i, j;
769 if (popnum (&j) || popnum (&i))
770 return OOPS;
771 i ^= j;
772 if (pushnum (i))
773 return OOPS;
774 }
775 sp++;
776 break;
777 case '=':
778 {
779 int i, j;
780 if (popnum (&j) || popnum (&i))
781 return OOPS;
782 i = (i == j);
783 if (pushnum (i))
784 return OOPS;
785 }
786 sp++;
787 break;
788 case '<':
789 {
790 int i, j;
791 if (popnum (&j) || popnum (&i))
792 return OOPS;
793 i = (i < j);
794 if (pushnum (i))
795 return OOPS;
796 }
797 sp++;
798 break;
799 case 'A':
800 {
801 int i, j;
802 if (popnum (&j) || popnum (&i))
803 return OOPS;
804 i = (i && j);
805 if (pushnum (i))
806 return OOPS;
807 }
808 sp++;
809 break;
810 case 'O':
811 {
812 int i, j;
813 if (popnum (&j) || popnum (&i))
814 return OOPS;
815 i = (i || j);
816 if (pushnum (i))
817 return OOPS;
818 }
819 sp++;
820 break;
821 case '!':
822 {
823 int i;
824 if (popnum (&i))
825 return OOPS;
826 i = !i;
827 if (pushnum (i))
828 return OOPS;
829 }
830 sp++;
831 break;
832 case '~':
833 {
834 int i;
835 if (popnum (&i))
836 return OOPS;
837 i = ~i;
838 if (pushnum (i))
839 return OOPS;
840 }
841 sp++;
842 break;
843 case '?':
844 if (termcap > 1)
845 return OOPS;
846 termcap = 0;
847 if_depth++;
848 sp++;
849 break;
850 case 't':
851 {
852 int i;
853 if (popnum (&i) || if_depth == 0)
854 return OOPS;
855 if (!i)
856 {
857 scan_for = 'e';
858 scan_depth = if_depth;
859 }
860 }
861 sp++;
862 break;
863 case 'e':
864 if (if_depth == 0)
865 return OOPS;
866 scan_for = ';';
867 scan_depth = if_depth;
868 sp++;
869 break;
870 case ';':
871 if (if_depth-- == 0)
872 return OOPS;
873 sp++;
874 break;
875 case 'b':
876 if (--termcap < 1)
877 return OOPS;
878 sp++;
879 break;
880 case 'f':
881 if (!termcap++)
882 return OOPS;
883 sp++;
884 break;
885 }
886 break;
887 default:
888 if (scan_for)
889 sp++;
890 else
891 *dp++ = *sp++;
892 break;
893 }
894 }
895 va_end (tparm_args);
896 *dp = '\0';
897 return buf;
898 }