1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright (c) 1996-1997 by Sun Microsystems, Inc. 24 * All rights reserved. 25 */ 26 27 /* Copyright (c) 1988 AT&T */ 28 /* All Rights Reserved */ 29 30 31 #pragma ident "%Z%%M% %I% %E% SMI" 32 33 /* Copyright (c) 1979 Regents of the University of California */ 34 35 /*LINTLIBRARY*/ 36 37 #include "curses_inc.h" 38 #include "curshdr.h" 39 #include "term.h" 40 #include <string.h> 41 #include <setjmp.h> 42 #include <stdlib.h> 43 #include <stdio.h> 44 45 #ifndef _CHCTRL 46 #define _CHCTRL(c) ((c) & 037) 47 #endif /* _CHCTRL */ 48 49 char *_branchto(char *, char); 50 51 /* 52 * Routine to perform parameter substitution. 53 * instring is a string containing printf type escapes. 54 * The whole thing uses a stack, much like an HP 35. 55 * The following escapes are defined for substituting row/column: 56 * 57 * %[:[-+ #0]][0-9][.][0-9][dsoxX] 58 * print pop() as in printf(3), as defined in the local 59 * sprintf(3), except that a leading + or - must be preceded 60 * with a colon (:) to distinguish from the plus/minus operators. 61 * 62 * %c print pop() like %c in printf(3) 63 * %l pop() a string address and push its length. 64 * %P[a-z] set dynamic variable a-z 65 * %g[a-z] get dynamic variable a-z 66 * %P[A-Z] set static variable A-Z 67 * %g[A-Z] get static variable A-Z 68 * 69 * %p[1-0] push ith parm 70 * %'c' char constant c 71 * %{nn} integer constant nn 72 * 73 * %+ %- %* %/ %m arithmetic (%m is mod): push(pop() op pop()) 74 * %& %| %^ bit operations: push(pop() op pop()) 75 * %= %> %< logical operations: push(pop() op pop()) 76 * %A %O logical AND, OR push(pop() op pop()) 77 * %! %~ unary operations push(op pop()) 78 * %% output % 79 * %? expr %t thenpart %e elsepart %; 80 * if-then-else, %e elsepart is optional. 81 * else-if's are possible ala Algol 68: 82 * %? c1 %t %e c2 %t %e c3 %t %e c4 %t %e %; 83 * % followed by anything else 84 * is not defined, it may output the character, 85 * and it may not. This is done so that further 86 * enhancements to the format capabilities may 87 * be made without worrying about being upwardly 88 * compatible from buggy code. 89 * 90 * all other characters are ``self-inserting''. %% gets % output. 91 * 92 * The stack structure used here is based on an idea by Joseph Yao. 93 */ 94 95 #define MAX 10 96 #define MEM_ALLOC_FAIL 1 97 #define STACK_UNDERFLOW 2 98 99 typedef struct { 100 long top; 101 int stacksize; 102 long *stack; 103 104 }STACK; 105 106 static jmp_buf env; 107 108 static long 109 tops(STACK *st) 110 { 111 112 if (st->top < 0) { 113 longjmp(env, STACK_UNDERFLOW); 114 } 115 return (st->stack[st->top]); 116 } 117 118 static void 119 push(STACK *st, long i) 120 { 121 if (st->top >= (st->stacksize - 1)) { 122 st->stacksize += MAX; 123 if ((st->stack = (void *)realloc(st->stack, 124 (st->stacksize * sizeof (long)))) == NULL) { 125 longjmp(env, MEM_ALLOC_FAIL); 126 } 127 } 128 st->stack[++st->top] = (i); 129 } 130 131 static long 132 pop(STACK *st) 133 { 134 if (st->top < 0) { 135 longjmp(env, STACK_UNDERFLOW); 136 } 137 return (st->stack[st->top--]); 138 } 139 140 /* The following routine was added to make lint shut up about converting from 141 * a long to a char *. It is identical to the pop routine, except for the 142 * cast on the return statement. 143 */ 144 static char * 145 pop_char_p(STACK *st) 146 { 147 if (st->top < 0) { 148 longjmp(env, STACK_UNDERFLOW); 149 } 150 return ((char *)(st->stack[st->top--])); 151 } 152 153 static void 154 init_stack(STACK *st) 155 { 156 st->top = -1; 157 st->stacksize = MAX; 158 if ((st->stack = (void *)malloc(MAX * sizeof (long))) == NULL) { 159 longjmp(env, MEM_ALLOC_FAIL); 160 } 161 } 162 163 static void 164 free_stack(STACK *st) 165 { 166 free(st->stack); 167 } 168 169 170 char * 171 tparm_p0(char *instring) 172 { 173 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 174 175 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 176 p[7], p[8])); 177 } 178 179 char * 180 tparm_p1(char *instring, long l1) 181 { 182 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 183 184 p[0] = l1; 185 186 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 187 p[7], p[8])); 188 } 189 190 char * 191 tparm_p2(char *instring, long l1, long l2) 192 { 193 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 194 195 p[0] = l1; 196 p[1] = l2; 197 198 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 199 p[7], p[8])); 200 } 201 202 char * 203 tparm_p3(char *instring, long l1, long l2, long l3) 204 { 205 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 206 207 p[0] = l1; 208 p[1] = l2; 209 p[2] = l3; 210 211 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 212 p[7], p[8])); 213 } 214 215 char * 216 tparm_p4(char *instring, long l1, long l2, long l3, long l4) 217 { 218 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 219 220 p[0] = l1; 221 p[1] = l2; 222 p[2] = l3; 223 p[3] = l4; 224 225 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 226 p[7], p[8])); 227 } 228 229 char * 230 tparm_p7(char *instring, long l1, long l2, long l3, long l4, long l5, long l6, 231 long l7) 232 { 233 long p[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 234 235 p[0] = l1; 236 p[1] = l2; 237 p[2] = l3; 238 p[3] = l4; 239 p[4] = l5; 240 p[5] = l6; 241 p[6] = l7; 242 243 return (tparm(instring, p[0], p[1], p[2], p[3], p[4], p[5], p[6], 244 p[7], p[8])); 245 } 246 247 /* VARARGS */ 248 char * 249 tparm(char *instring, long fp1, long fp2, long p3, long p4, 250 long p5, long p6, long p7, long p8, long p9) 251 { 252 static char result[512]; 253 static char added[100]; 254 long vars[26]; 255 STACK stk; 256 char *cp = instring; 257 char *outp = result; 258 char c; 259 long op; 260 long op2; 261 int sign; 262 int onrow = 0; 263 long p1 = fp1, p2 = fp2; /* copy in case < 2 actual parms */ 264 char *xp; 265 char formatbuffer[100]; 266 char *format; 267 int looping; 268 short *regs = cur_term->_regs; 269 int val; 270 271 272 if ((val = setjmp(env)) != 0) { 273 #ifdef DEBUG 274 switch (val) { 275 case MEM_ALLOC_FAIL: 276 fprintf(outf, "TPARM: Memory allocation" 277 " failure."); 278 break; 279 case STACK_UNDERFLOW: 280 fprintf(outf, "TPARM: Stack underflow."); 281 break; 282 } 283 #endif /* DEBUG */ 284 285 if (val == STACK_UNDERFLOW) 286 free_stack(&stk); 287 return (NULL); 288 } 289 290 init_stack(&stk); 291 push(&stk, 0); 292 293 if (instring == 0) { 294 #ifdef DEBUG 295 if (outf) 296 fprintf(outf, "TPARM: null arg\n"); 297 #endif /* DEBUG */ 298 free_stack(&stk); 299 return (NULL); 300 } 301 302 added[0] = 0; 303 304 while ((c = *cp++) != 0) { 305 if (c != '%') { 306 *outp++ = c; 307 continue; 308 } 309 op = tops(&stk); 310 switch (c = *cp++) { 311 /* PRINTING CASES */ 312 case ':': 313 case ' ': 314 case '#': 315 case '0': 316 case '1': 317 case '2': 318 case '3': 319 case '4': 320 case '5': 321 case '6': 322 case '7': 323 case '8': 324 case '9': 325 case '.': 326 case 'd': 327 case 's': 328 case 'o': 329 case 'x': 330 case 'X': 331 format = formatbuffer; 332 *format++ = '%'; 333 334 /* leading ':' to allow +/- in format */ 335 if (c == ':') 336 c = *cp++; 337 338 /* take care of flags, width and precision */ 339 looping = 1; 340 while (c && looping) 341 switch (c) { 342 case '-': 343 case '+': 344 case ' ': 345 case '#': 346 case '0': 347 case '1': 348 case '2': 349 case '3': 350 case '4': 351 case '5': 352 case '6': 353 case '7': 354 case '8': 355 case '9': 356 case '.': 357 *format++ = c; 358 c = *cp++; 359 break; 360 default: 361 looping = 0; 362 } 363 364 /* add in the conversion type */ 365 switch (c) { 366 case 'd': 367 case 's': 368 case 'o': 369 case 'x': 370 case 'X': 371 *format++ = c; 372 break; 373 default: 374 #ifdef DEBUG 375 if (outf) 376 fprintf(outf, "TPARM: invalid " 377 "conversion type\n"); 378 #endif /* DEBUG */ 379 free_stack(&stk); 380 return (NULL); 381 } 382 *format = '\0'; 383 384 /* 385 * Pass off the dirty work to sprintf. 386 * It's debatable whether we should just pull in 387 * the appropriate code here. I decided not to for 388 * now. 389 */ 390 if (c == 's') 391 (void) sprintf(outp, formatbuffer, 392 (char *) op); 393 else 394 (void) sprintf(outp, formatbuffer, op); 395 /* 396 * Advance outp past what sprintf just did. 397 * sprintf returns an indication of its length on some 398 * systems, others the first char, and there's 399 * no easy way to tell which. The Sys V on 400 * BSD emulations are particularly confusing. 401 */ 402 while (*outp) 403 outp++; 404 (void) pop(&stk); 405 406 continue; 407 408 case 'c': 409 /* 410 * This code is worth scratching your head at for a 411 * while. The idea is that various weird things can 412 * happen to nulls, EOT's, tabs, and newlines by the 413 * tty driver, arpanet, and so on, so we don't send 414 * them if we can help it. So we instead alter the 415 * place being addessed and then move the cursor 416 * locally using UP or RIGHT. 417 * 418 * This is a kludge, clearly. It loses if the 419 * parameterized string isn't addressing the cursor 420 * (but hopefully that is all that %c terminals do 421 * with parms). Also, since tab and newline happen 422 * to be next to each other in ASCII, if tab were 423 * included a loop would be needed. Finally, note 424 * that lots of other processing is done here, so 425 * this hack won't always work (e.g. the Ann Arbor 426 * 4080, which uses %B and then %c.) 427 */ 428 switch (op) { 429 /* 430 * Null. Problem is that our 431 * output is, by convention, null terminated. 432 */ 433 case 0: 434 op = 0200; /* Parity should */ 435 /* be ignored. */ 436 break; 437 /* 438 * Control D. Problem is that certain very 439 * ancient hardware hangs up on this, so the 440 * current(!) UNIX tty driver doesn't xmit 441 * control D's. 442 */ 443 case _CHCTRL('d'): 444 /* 445 * Newline. Problem is that UNIX will expand 446 * this to CRLF. 447 */ 448 case '\n': 449 xp = (onrow ? cursor_down : 450 cursor_right); 451 if (onrow && xp && op < lines-1 && 452 cursor_up) { 453 op += 2; 454 xp = cursor_up; 455 } 456 if (xp && instring == 457 cursor_address) { 458 (void) strcat(added, xp); 459 op--; 460 } 461 break; 462 /* 463 * Tab used to be in this group too, 464 * because UNIX might expand it to blanks. 465 * We now require that this tab mode be turned 466 * off by any program using this routine, 467 * or using termcap in general, since some 468 * terminals use tab for other stuff, like 469 * nondestructive space. (Filters like ul 470 * or vcrt will lose, since they can't stty.) 471 * Tab was taken out to get the Ann Arbor 472 * 4080 to work. 473 */ 474 } 475 476 /* LINTED */ 477 *outp++ = (char)op; 478 (void) pop(&stk); 479 break; 480 481 case 'l': 482 xp = pop_char_p(&stk); 483 push(&stk, strlen(xp)); 484 break; 485 486 case '%': 487 *outp++ = c; 488 break; 489 490 /* 491 * %i: shorthand for increment first two parms. 492 * Useful for terminals that start numbering from 493 * one instead of zero(like ANSI terminals). 494 */ 495 case 'i': 496 p1++; 497 p2++; 498 break; 499 500 /* %pi: push the ith parameter */ 501 case 'p': 502 switch (c = *cp++) { 503 case '1': 504 push(&stk, p1); 505 break; 506 case '2': 507 push(&stk, p2); 508 break; 509 case '3': 510 push(&stk, p3); 511 break; 512 case '4': 513 push(&stk, p4); 514 break; 515 case '5': 516 push(&stk, p5); 517 break; 518 case '6': 519 push(&stk, p6); 520 break; 521 case '7': 522 push(&stk, p7); 523 break; 524 case '8': 525 push(&stk, p8); 526 break; 527 case '9': 528 push(&stk, p9); 529 break; 530 default: 531 #ifdef DEBUG 532 if (outf) 533 fprintf(outf, "TPARM:" 534 " bad parm" 535 " number\n"); 536 #endif /* DEBUG */ 537 free_stack(&stk); 538 return (NULL); 539 } 540 onrow = (c == '1'); 541 break; 542 543 /* %Pi: pop from stack into variable i (a-z) */ 544 case 'P': 545 if (*cp >= 'a' && *cp <= 'z') { 546 vars[*cp++ - 'a'] = pop(&stk); 547 } else { 548 if (*cp >= 'A' && *cp <= 'Z') { 549 regs[*cp++ - 'A'] = 550 /* LINTED */ 551 (short) pop(&stk); 552 } 553 #ifdef DEBUG 554 else if (outf) { 555 fprintf(outf, "TPARM: bad" 556 " register name\n"); 557 } 558 #endif /* DEBUG */ 559 } 560 break; 561 562 /* %gi: push variable i (a-z) */ 563 case 'g': 564 if (*cp >= 'a' && *cp <= 'z') { 565 push(&stk, vars[*cp++ - 'a']); 566 } else { 567 if (*cp >= 'A' && *cp <= 'Z') { 568 push(&stk, regs[*cp++ - 'A']); 569 } 570 #ifdef DEBUG 571 else if (outf) { 572 fprintf(outf, "TPARM: bad" 573 " register name\n"); 574 575 } 576 #endif /* DEBUG */ 577 } 578 break; 579 580 /* %'c' : character constant */ 581 case '\'': 582 push(&stk, *cp++); 583 if (*cp++ != '\'') { 584 #ifdef DEBUG 585 if (outf) 586 fprintf(outf, "TPARM: missing" 587 " closing quote\n"); 588 #endif /* DEBUG */ 589 free_stack(&stk); 590 return (NULL); 591 } 592 break; 593 594 /* %{nn} : integer constant. */ 595 case '{': 596 op = 0; 597 sign = 1; 598 if (*cp == '-') { 599 sign = -1; 600 cp++; 601 } else 602 if (*cp == '+') 603 cp++; 604 while ((c = *cp++) >= '0' && c <= '9') { 605 op = 10 * op + c - '0'; 606 } 607 if (c != '}') { 608 #ifdef DEBUG 609 if (outf) 610 fprintf(outf, "TPARM: missing " 611 "closing brace\n"); 612 #endif /* DEBUG */ 613 free_stack(&stk); 614 return (NULL); 615 } 616 push(&stk, (sign * op)); 617 break; 618 619 /* binary operators */ 620 case '+': 621 op2 = pop(&stk); 622 op = pop(&stk); 623 push(&stk, (op + op2)); 624 break; 625 case '-': 626 op2 = pop(&stk); 627 op = pop(&stk); 628 push(&stk, (op - op2)); 629 break; 630 case '*': 631 op2 = pop(&stk); 632 op = pop(&stk); 633 push(&stk, (op * op2)); 634 break; 635 case '/': 636 op2 = pop(&stk); 637 op = pop(&stk); 638 push(&stk, (op / op2)); 639 break; 640 case 'm': 641 op2 = pop(&stk); 642 op = pop(&stk); 643 push(&stk, (op % op2)); 644 break; /* %m: mod */ 645 case '&': 646 op2 = pop(&stk); 647 op = pop(&stk); 648 push(&stk, (op & op2)); 649 break; 650 case '|': 651 op2 = pop(&stk); 652 op = pop(&stk); 653 push(&stk, (op | op2)); 654 break; 655 case '^': 656 op2 = pop(&stk); 657 op = pop(&stk); 658 push(&stk, (op ^ op2)); 659 break; 660 case '=': 661 op2 = pop(&stk); 662 op = pop(&stk); 663 push(&stk, (op == op2)); 664 break; 665 case '>': 666 op2 = pop(&stk); 667 op = pop(&stk); 668 push(&stk, (op > op2)); 669 break; 670 case '<': 671 op2 = pop(&stk); 672 op = pop(&stk); 673 push(&stk, (op < op2)); 674 break; 675 case 'A': 676 op2 = pop(&stk); 677 op = pop(&stk); 678 push(&stk, (op && op2)); 679 break; /* AND */ 680 case 'O': 681 op2 = pop(&stk); 682 op = pop(&stk); 683 push(&stk, (op || op2)); 684 break; /* OR */ 685 686 /* Unary operators. */ 687 case '!': 688 push(&stk, !pop(&stk)); 689 break; 690 case '~': 691 push(&stk, ~pop(&stk)); 692 break; 693 694 /* Sorry, no unary minus, because minus is binary. */ 695 696 /* 697 * If-then-else. Implemented by a low level hack of 698 * skipping forward until the match is found, counting 699 * nested if-then-elses. 700 */ 701 case '?': /* IF - just a marker */ 702 break; 703 704 case 't': /* THEN - branch if false */ 705 if (!pop(&stk)) 706 cp = _branchto(cp, 'e'); 707 break; 708 709 case 'e': /* ELSE - branch to ENDIF */ 710 cp = _branchto(cp, ';'); 711 break; 712 713 case ';': /* ENDIF - just a marker */ 714 break; 715 716 default: 717 #ifdef DEBUG 718 if (outf) 719 fprintf(outf, "TPARM: bad % " 720 "sequence\n"); 721 #endif /* DEBUG */ 722 free_stack(&stk); 723 return (NULL); 724 } 725 } 726 (void) strcpy(outp, added); 727 free_stack(&stk); 728 return (result); 729 } 730 731 char * 732 _branchto(register char *cp, char to) 733 { 734 register int level = 0; 735 register char c; 736 737 while (c = *cp++) { 738 if (c == '%') { 739 if ((c = *cp++) == to || c == ';') { 740 if (level == 0) { 741 return (cp); 742 } 743 } 744 if (c == '?') 745 level++; 746 if (c == ';') 747 level--; 748 } 749 } 750 #ifdef DEBUG 751 if (outf) 752 fprintf(outf, "TPARM: no matching ENDIF"); 753 #endif /* DEBUG */ 754 return (NULL); 755 } 756