1 /* $NetBSD: curses_commands.c,v 1.7 2012/09/19 11:51:08 blymn Exp $ */ 2 3 /*- 4 * Copyright 2009 Brett Lymn <blymn@NetBSD.org> 5 * 6 * All rights reserved. 7 * 8 * This code has been donated to The NetBSD Foundation by the Author. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. The name of the author may not be used to endorse or promote products 16 * derived from this software withough specific prior written permission 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * 29 * 30 */ 31 32 #include <curses.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <string.h> 36 #include <termios.h> 37 #include <stdarg.h> 38 39 #include "slave.h" 40 #include "curses_commands.h" 41 42 void 43 cmd_DRAIN(int nargs, char **args) 44 { 45 while (getch() != ERR); 46 report_count(1); 47 report_return(OK); 48 } 49 50 void 51 cmd_addbytes(int nargs, char **args) 52 { 53 int count; 54 55 if (check_arg_count(nargs, 2) == 1) 56 return; 57 58 if (sscanf(args[1], "%d", &count) == 0) { 59 report_count(1); 60 report_error("BAD ARGUMENT"); 61 return; 62 } 63 64 report_count(1); 65 report_return(addbytes(args[0], count)); 66 } 67 68 69 void 70 cmd_addch(int nargs, char **args) 71 { 72 chtype *ch; 73 74 if (check_arg_count(nargs, 1) == 1) 75 return; 76 77 ch = (chtype *) args[0]; 78 report_count(1); 79 report_return(addch(ch[0])); 80 } 81 82 83 void 84 cmd_addchnstr(int nargs, char **args) 85 { 86 int count; 87 88 if (check_arg_count(nargs, 2) == 1) 89 return; 90 91 if (sscanf(args[1], "%d", &count) == 0) { 92 report_count(1); 93 report_error("BAD ARGUMENT"); 94 return; 95 } 96 97 report_count(1); 98 report_return(addchnstr((chtype *) args[0], count)); 99 } 100 101 102 void 103 cmd_addchstr(int nargs, char **args) 104 { 105 if (check_arg_count(nargs, 1) == 1) 106 return; 107 108 report_count(1); 109 report_return(addchstr((chtype *) args[0])); 110 } 111 112 113 void 114 cmd_addnstr(int nargs, char **args) 115 { 116 int count; 117 118 if (check_arg_count(nargs, 2) == 1) 119 return; 120 121 if (sscanf(args[1], "%d", &count) == 0) { 122 report_count(1); 123 report_error("BAD ARGUMENT"); 124 return; 125 } 126 127 report_count(1); 128 report_return(addnstr(args[0], count)); 129 } 130 131 132 void 133 cmd_addstr(int nargs, char **args) 134 { 135 if (check_arg_count(nargs, 1) == 1) 136 return; 137 138 report_count(1); 139 report_return(addstr(args[0])); 140 } 141 142 143 void 144 cmd_attr_get(int nargs, char **args) 145 { 146 attr_t attrs; 147 short colours; 148 int retval; 149 150 if (check_arg_count(nargs, 0) == 1) 151 return; 152 153 retval = attr_get(&attrs, &colours, NULL); 154 155 /* XXXX - call3 */ 156 report_count(3); 157 report_return(retval); 158 report_int(attrs); 159 report_int(colours); 160 } 161 162 163 void 164 cmd_attr_off(int nargs, char **args) 165 { 166 int attrib; 167 168 if (check_arg_count(nargs, 1) == 1) 169 return; 170 171 if (sscanf(args[0], "%d", &attrib) == 0) { 172 report_count(1); 173 report_error("BAD ARGUMENT"); 174 return; 175 } 176 177 report_count(1); 178 report_return(attr_off(attrib, NULL)); 179 } 180 181 182 void 183 cmd_attr_on(int nargs, char **args) 184 { 185 int attrib; 186 187 if (check_arg_count(nargs, 1) == 1) 188 return; 189 190 if (sscanf(args[0], "%d", &attrib) == 0) { 191 report_count(1); 192 report_error("BAD ARGUMENT"); 193 return; 194 } 195 196 report_count(1); 197 report_return(attr_on(attrib, NULL)); 198 } 199 200 201 void 202 cmd_attr_set(int nargs, char **args) 203 { 204 int attrib; 205 short pair; 206 207 if (check_arg_count(nargs, 2) == 1) 208 return; 209 210 if (sscanf(args[0], "%d", &attrib) == 0) { 211 report_count(1); 212 report_error("BAD ARGUMENT"); 213 return; 214 } 215 216 if (sscanf(args[1], "%hd", &pair) == 0) { 217 report_count(1); 218 report_error("BAD ARGUMENT"); 219 return; 220 } 221 222 report_count(1); 223 report_return(attr_set(attrib, pair, NULL)); 224 } 225 226 227 void 228 cmd_attroff(int nargs, char **args) 229 { 230 int attrib; 231 232 if (check_arg_count(nargs, 1) == 1) 233 return; 234 235 if (sscanf(args[0], "%d", &attrib) == 0) { 236 report_count(1); 237 report_error("BAD ARGUMENT"); 238 return; 239 } 240 241 report_count(1); 242 report_return(attroff(attrib)); 243 } 244 245 246 void 247 cmd_attron(int nargs, char **args) 248 { 249 int attrib; 250 251 if (check_arg_count(nargs, 1) == 1) 252 return; 253 254 if (sscanf(args[0], "%d", &attrib) == 0) { 255 report_count(1); 256 report_error("BAD ARGUMENT"); 257 return; 258 } 259 260 report_count(1); 261 report_return(attron(attrib)); 262 } 263 264 265 void 266 cmd_attrset(int nargs, char **args) 267 { 268 int attrib; 269 270 if (check_arg_count(nargs, 1) == 1) 271 return; 272 273 if (sscanf(args[0], "%d", &attrib) == 0) { 274 report_count(1); 275 report_error("BAD ARGUMENT"); 276 return; 277 } 278 279 report_count(1); 280 report_return(attrset(attrib)); 281 } 282 283 284 void 285 cmd_bkgd(int nargs, char **args) 286 { 287 chtype *ch; 288 289 if (check_arg_count(nargs, 1) == 1) 290 return; 291 292 ch = (chtype *) args[0]; 293 report_count(1); 294 report_return(bkgd(ch[0])); 295 } 296 297 298 void 299 cmd_bkgdset(int nargs, char **args) 300 { 301 chtype *ch; 302 303 if (check_arg_count(nargs, 1) == 1) 304 return; 305 306 ch = (chtype *) args[0]; 307 bkgdset(ch[0]); /* returns void */ 308 report_count(1); 309 report_return(OK); 310 } 311 312 313 void 314 cmd_border(int nargs, char **args) 315 { 316 int ls, rs, ts, bs, tl, tr, bl, br; 317 318 if (check_arg_count(nargs, 8) == 1) 319 return; 320 321 if (sscanf(args[0], "%d", &ls) == 0) { 322 report_count(1); 323 report_error("BAD ARGUMENT"); 324 return; 325 } 326 if (sscanf(args[1], "%d", &rs) == 0) { 327 report_count(1); 328 report_error("BAD ARGUMENT"); 329 return; 330 } 331 if (sscanf(args[2], "%d", &ts) == 0) { 332 report_count(1); 333 report_error("BAD ARGUMENT"); 334 return; 335 } 336 if (sscanf(args[3], "%d", &bs) == 0) { 337 report_count(1); 338 report_error("BAD ARGUMENT"); 339 return; 340 } 341 if (sscanf(args[4], "%d", &tl) == 0) { 342 report_count(1); 343 report_error("BAD ARGUMENT"); 344 return; 345 } 346 if (sscanf(args[5], "%d", &tr) == 0) { 347 report_count(1); 348 report_error("BAD ARGUMENT"); 349 return; 350 } 351 if (sscanf(args[6], "%d", &bl) == 0) { 352 report_count(1); 353 report_error("BAD ARGUMENT"); 354 return; 355 } 356 if (sscanf(args[7], "%d", &br) == 0) { 357 report_count(1); 358 report_error("BAD ARGUMENT"); 359 return; 360 } 361 362 report_count(1); 363 report_return(border(ls, rs, ts, bs, tl, tr, bl, br)); 364 } 365 366 367 void 368 cmd_clear(int nargs, char **args) 369 { 370 if (check_arg_count(nargs, 0) == 1) 371 return; 372 373 report_count(1); 374 report_return(clear()); 375 } 376 377 378 void 379 cmd_clrtobot(int nargs, char **args) 380 { 381 if (check_arg_count(nargs, 0) == 1) 382 return; 383 384 report_count(1); 385 report_return(clrtobot()); 386 } 387 388 389 void 390 cmd_clrtoeol(int nargs, char **args) 391 { 392 if (check_arg_count(nargs, 0) == 1) 393 return; 394 395 report_count(1); 396 report_return(clrtoeol()); 397 } 398 399 400 void 401 cmd_color_set(int nargs, char **args) 402 { 403 short colour_pair; 404 405 if (check_arg_count(nargs, 2) == 1) 406 return; 407 408 if (sscanf(args[0], "%hd", &colour_pair) == 0) { 409 report_count(1); 410 report_error("BAD ARGUMENT"); 411 return; 412 } 413 414 report_count(1); 415 report_return(color_set(colour_pair, NULL)); 416 } 417 418 419 void 420 cmd_delch(int nargs, char **args) 421 { 422 if (check_arg_count(nargs, 0) == 1) 423 return; 424 425 report_count(1); 426 report_return(delch()); 427 } 428 429 430 void 431 cmd_deleteln(int nargs, char **args) 432 { 433 if (check_arg_count(nargs, 0) == 1) 434 return; 435 436 report_count(1); 437 report_return(deleteln()); 438 } 439 440 441 void 442 cmd_echochar(int nargs, char **args) 443 { 444 if (check_arg_count(nargs, 1) == 1) 445 return; 446 447 /* XXX causes refresh */ 448 report_count(1); 449 report_return(echochar(args[0][0])); 450 } 451 452 453 void 454 cmd_erase(int nargs, char **args) 455 { 456 if (check_arg_count(nargs, 0) == 1) 457 return; 458 459 report_count(1); 460 report_return(erase()); 461 } 462 463 464 void 465 cmd_getch(int nargs, char **args) 466 { 467 if (check_arg_count(nargs, 0) == 1) 468 return; 469 470 /* XXX causes refresh */ 471 report_count(1); 472 report_int(getch()); 473 } 474 475 476 void 477 cmd_getnstr(int nargs, char **args) 478 { 479 int limit; 480 char *string; 481 482 if (check_arg_count(nargs, 1) == 1) 483 return; 484 485 if (sscanf(args[0], "%d", &limit) == 0) { 486 report_count(1); 487 report_error("BAD ARGUMENT"); 488 return; 489 } 490 491 if ((string = malloc(limit + 1)) == NULL) { 492 report_count(1); 493 report_error("MALLOC_FAILED"); 494 return; 495 } 496 497 /* XXX call2 */ 498 report_count(2); 499 report_return(getnstr(string, limit)); 500 report_status(string); 501 free(string); 502 } 503 504 505 void 506 cmd_getstr(int nargs, char **args) 507 { 508 char string[256]; 509 510 if (check_arg_count(nargs, 0) == 1) 511 return; 512 513 /* XXX call2 */ 514 report_count(2); 515 report_return(getstr(string)); 516 report_status(string); 517 } 518 519 520 void 521 cmd_inch(int nargs, char **args) 522 { 523 if (check_arg_count(nargs, 0) == 1) 524 return; 525 526 527 report_count(1); 528 report_byte(inch()); 529 } 530 531 532 void 533 cmd_inchnstr(int nargs, char **args) 534 { 535 int limit; 536 chtype *string; 537 538 if (check_arg_count(nargs, 1) == 1) 539 return; 540 541 if (sscanf(args[0], "%d", &limit) == 0) { 542 report_count(1); 543 report_error("BAD ARGUMENT"); 544 return; 545 } 546 547 if ((string = malloc((limit + 1) * sizeof(chtype))) == NULL) { 548 report_count(1); 549 report_error("MALLOC_FAILED"); 550 return; 551 } 552 553 /* XXX call2 */ 554 report_count(2); 555 report_return(inchnstr(string, limit)); 556 report_nstr(string); 557 free(string); 558 } 559 560 561 void 562 cmd_inchstr(int nargs, char **args) 563 { 564 chtype string[256]; 565 566 if (check_arg_count(nargs, 0) == 1) 567 return; 568 569 /* XXX call2 */ 570 report_count(2); 571 report_return(inchstr(string)); 572 report_nstr(string); 573 } 574 575 576 void 577 cmd_innstr(int nargs, char **args) 578 { 579 int limit; 580 char *string; 581 582 if (check_arg_count(nargs, 1) == 1) 583 return; 584 585 if (sscanf(args[0], "%d", &limit) == 0) { 586 report_count(1); 587 report_error("BAD ARGUMENT"); 588 return; 589 } 590 591 if ((string = malloc(limit + 1)) == NULL) { 592 report_count(1); 593 report_error("MALLOC_FAILED"); 594 return; 595 } 596 597 /* XXX call2 */ 598 report_count(2); 599 report_int(innstr(string, limit)); 600 report_status(string); 601 free(string); 602 } 603 604 605 void 606 cmd_insch(int nargs, char **args) 607 { 608 if (check_arg_count(nargs, 1) == 1) 609 return; 610 611 report_count(1); 612 report_return(insch(args[0][0])); 613 } 614 615 616 void 617 cmd_insdelln(int nargs, char **args) 618 { 619 int nlines; 620 621 if (check_arg_count(nargs, 1) == 1) 622 return; 623 624 if (sscanf(args[0], "%d", &nlines) == 0) { 625 report_count(1); 626 report_error("BAD ARGUMENT"); 627 return; 628 } 629 630 report_count(1); 631 report_return(insdelln(nlines)); 632 } 633 634 635 void 636 cmd_insertln(int nargs, char **args) 637 { 638 if (check_arg_count(nargs, 0) == 1) 639 return; 640 641 report_count(1); 642 report_return(insertln()); 643 } 644 645 646 void 647 cmd_instr(int nargs, char **args) 648 { 649 char string[256]; 650 651 if (check_arg_count(nargs, 0) == 1) 652 return; 653 654 /* XXX call2 */ 655 report_count(2); 656 report_return(instr(string)); 657 report_status(string); 658 } 659 660 661 void 662 cmd_move(int nargs, char **args) 663 { 664 int y, x; 665 666 if (check_arg_count(nargs, 2) == 1) 667 return; 668 669 if (sscanf(args[0], "%d", &y) == 0) { 670 report_count(1); 671 report_error("BAD ARGUMENT"); 672 return; 673 } 674 675 if (sscanf(args[1], "%d", &x) == 0) { 676 report_count(1); 677 report_error("BAD ARGUMENT"); 678 return; 679 } 680 681 report_count(1); 682 report_return(move(y, x)); 683 } 684 685 686 void 687 cmd_refresh(int nargs, char **args) 688 { 689 if (check_arg_count(nargs, 0) == 1) 690 return; 691 692 report_count(1); 693 report_return(refresh()); 694 } 695 696 697 void 698 cmd_scrl(int nargs, char **args) 699 { 700 int nlines; 701 702 if (check_arg_count(nargs, 1) == 1) 703 return; 704 705 if (sscanf(args[0], "%d", &nlines) == 0) { 706 report_count(1); 707 report_error("BAD ARGUMENT"); 708 return; 709 } 710 711 report_count(1); 712 report_return(scrl(nlines)); 713 } 714 715 716 void 717 cmd_setscrreg(int nargs, char **args) 718 { 719 int top, bottom; 720 721 if (check_arg_count(nargs, 2) == 1) 722 return; 723 724 if (sscanf(args[0], "%d", &top) == 0) { 725 report_count(1); 726 report_error("BAD ARGUMENT"); 727 return; 728 } 729 730 if (sscanf(args[1], "%d", &bottom) == 0) { 731 report_count(1); 732 report_error("BAD ARGUMENT"); 733 return; 734 } 735 736 report_count(1); 737 report_return(setscrreg(top, bottom)); 738 } 739 740 741 void 742 cmd_standend(int nargs, char **args) 743 { 744 if (check_arg_count(nargs, 0) == 1) 745 return; 746 747 report_count(1); 748 report_return(standend()); 749 } 750 751 752 void 753 cmd_standout(int nargs, char **args) 754 { 755 if (check_arg_count(nargs, 0) == 1) 756 return; 757 758 report_count(1); 759 report_return(standout()); 760 } 761 762 763 void 764 cmd_timeout(int nargs, char **args) 765 { 766 int tval; 767 768 if (check_arg_count(nargs, 1) == 1) 769 return; 770 771 if (sscanf(args[0], "%d", &tval) == 0) { 772 report_count(1); 773 report_error("BAD ARGUMENT"); 774 return; 775 } 776 777 timeout(tval); /* void return */ 778 report_count(1); 779 report_return(OK); 780 } 781 782 783 void 784 cmd_underscore(int nargs, char **args) 785 { 786 if (check_arg_count(nargs, 0) == 1) 787 return; 788 789 report_count(1); 790 report_return(underscore()); 791 } 792 793 794 void 795 cmd_underend(int nargs, char **args) 796 { 797 if (check_arg_count(nargs, 0) == 1) 798 return; 799 800 report_count(1); 801 report_return(underend()); 802 } 803 804 805 void 806 cmd_waddbytes(int nargs, char **args) 807 { 808 WINDOW *win; 809 int count; 810 811 if (check_arg_count(nargs, 3) == 1) 812 return; 813 814 if (sscanf(args[0], "%p", &win) == 0) { 815 report_count(1); 816 report_error("BAD ARGUMENT"); 817 return; 818 } 819 820 if (sscanf(args[2], "%d", &count) == 0) { 821 report_count(1); 822 report_error("BAD ARGUMENT"); 823 return; 824 } 825 826 report_count(1); 827 report_return(waddbytes(win, args[1], count)); 828 } 829 830 831 void 832 cmd_waddstr(int nargs, char **args) 833 { 834 WINDOW *win; 835 836 if (check_arg_count(nargs, 2) == 1) 837 return; 838 839 if (sscanf(args[0], "%p", &win) == 0) { 840 report_count(1); 841 report_error("BAD ARGUMENT"); 842 return; 843 } 844 845 report_count(1); 846 report_return(waddstr(win, args[1])); 847 } 848 849 850 void 851 cmd_mvaddbytes(int nargs, char **args) 852 { 853 int y, x, count; 854 855 if (check_arg_count(nargs, 4) == 1) 856 return; 857 858 if (sscanf(args[0], "%d", &y) == 0) { 859 report_count(1); 860 report_error("BAD ARGUMENT"); 861 return; 862 } 863 864 if (sscanf(args[1], "%d", &x) == 0) { 865 report_count(1); 866 report_error("BAD ARGUMENT"); 867 return; 868 } 869 870 if (sscanf(args[3], "%d", &count) == 0) { 871 report_count(1); 872 report_error("BAD ARGUMENT"); 873 return; 874 } 875 876 report_count(1); 877 report_return(mvaddbytes(y, x, args[2], count)); 878 } 879 880 881 void 882 cmd_mvaddch(int nargs, char **args) 883 { 884 int y, x; 885 chtype *ch; 886 887 if (check_arg_count(nargs, 3) == 1) 888 return; 889 890 if (sscanf(args[0], "%d", &y) == 0) { 891 report_count(1); 892 report_error("BAD ARGUMENT"); 893 return; 894 } 895 896 if (sscanf(args[1], "%d", &x) == 0) { 897 report_count(1); 898 report_error("BAD ARGUMENT"); 899 return; 900 } 901 902 ch = (chtype *) args[2]; 903 report_count(1); 904 report_return(mvaddch(y, x, ch[0])); 905 } 906 907 908 void 909 cmd_mvaddchnstr(int nargs, char **args) 910 { 911 int y, x, count; 912 913 if (check_arg_count(nargs, 4) == 1) 914 return; 915 916 if (sscanf(args[0], "%d", &y) == 0) { 917 report_count(1); 918 report_error("BAD ARGUMENT"); 919 return; 920 } 921 922 if (sscanf(args[1], "%d", &x) == 0) { 923 report_count(1); 924 report_error("BAD ARGUMENT"); 925 return; 926 } 927 928 if (sscanf(args[3], "%d", &count) == 0) { 929 report_count(1); 930 report_error("BAD ARGUMENT"); 931 return; 932 } 933 934 report_count(1); 935 report_return(mvaddchnstr(y, x, (chtype *) args[2], count)); 936 } 937 938 939 void 940 cmd_mvaddchstr(int nargs, char **args) 941 { 942 int y, x; 943 944 if (check_arg_count(nargs, 3) == 1) 945 return; 946 947 if (sscanf(args[0], "%d", &y) == 0) { 948 report_count(1); 949 report_error("BAD ARGUMENT"); 950 return; 951 } 952 953 if (sscanf(args[1], "%d", &x) == 0) { 954 report_count(1); 955 report_error("BAD ARGUMENT"); 956 return; 957 } 958 959 report_count(1); 960 report_return(mvaddchstr(y, x, (chtype *) args[2])); 961 } 962 963 964 void 965 cmd_mvaddnstr(int nargs, char **args) 966 { 967 int y, x, count; 968 969 if (check_arg_count(nargs, 4) == 1) 970 return; 971 972 if (sscanf(args[0], "%d", &y) == 0) { 973 report_count(1); 974 report_error("BAD ARGUMENT"); 975 return; 976 } 977 978 if (sscanf(args[1], "%d", &x) == 0) { 979 report_count(1); 980 report_error("BAD ARGUMENT"); 981 return; 982 } 983 984 if (sscanf(args[3], "%d", &count) == 0) { 985 report_count(1); 986 report_error("BAD ARGUMENT"); 987 return; 988 } 989 990 report_count(1); 991 report_return(mvaddnstr(y, x, args[2], count)); 992 } 993 994 995 void 996 cmd_mvaddstr(int nargs, char **args) 997 { 998 int y, x; 999 1000 if (check_arg_count(nargs, 3) == 1) 1001 return; 1002 1003 if (sscanf(args[0], "%d", &y) == 0) { 1004 report_count(1); 1005 report_error("BAD ARGUMENT"); 1006 return; 1007 } 1008 1009 if (sscanf(args[1], "%d", &x) == 0) { 1010 report_count(1); 1011 report_error("BAD ARGUMENT"); 1012 return; 1013 } 1014 1015 report_count(1); 1016 report_return(mvaddstr(y, x, args[2])); 1017 } 1018 1019 1020 void 1021 cmd_mvdelch(int nargs, char **args) 1022 { 1023 int y, x; 1024 1025 if (check_arg_count(nargs, 2) == 1) 1026 return; 1027 1028 if (sscanf(args[0], "%d", &y) == 0) { 1029 report_count(1); 1030 report_error("BAD ARGUMENT"); 1031 return; 1032 } 1033 1034 if (sscanf(args[1], "%d", &x) == 0) { 1035 report_count(1); 1036 report_error("BAD ARGUMENT"); 1037 return; 1038 } 1039 1040 report_count(1); 1041 report_return(mvdelch(y, x)); 1042 } 1043 1044 1045 void 1046 cmd_mvgetch(int nargs, char **args) 1047 { 1048 int y, x; 1049 1050 if (check_arg_count(nargs, 2) == 1) 1051 return; 1052 1053 if (sscanf(args[0], "%d", &y) == 0) { 1054 report_count(1); 1055 report_error("BAD ARGUMENT"); 1056 return; 1057 } 1058 1059 if (sscanf(args[1], "%d", &x) == 0) { 1060 report_count(1); 1061 report_error("BAD ARGUMENT"); 1062 return; 1063 } 1064 1065 report_count(1); 1066 report_int(mvgetch(y, x)); 1067 } 1068 1069 1070 void 1071 cmd_mvgetnstr(int nargs, char **args) 1072 { 1073 int y, x, count; 1074 char *string; 1075 1076 if (check_arg_count(nargs, 3) == 1) 1077 return; 1078 1079 if (sscanf(args[0], "%d", &y) == 0) { 1080 report_count(1); 1081 report_error("BAD ARGUMENT"); 1082 return; 1083 } 1084 1085 if (sscanf(args[1], "%d", &x) == 0) { 1086 report_count(1); 1087 report_error("BAD ARGUMENT"); 1088 return; 1089 } 1090 1091 if (sscanf(args[2], "%d", &count) == 0) { 1092 report_count(1); 1093 report_error("BAD ARGUMENT"); 1094 return; 1095 } 1096 1097 if ((string = malloc(count + 1)) == NULL) { 1098 report_count(1); 1099 report_error("MALLOC_FAILED"); 1100 return; 1101 } 1102 1103 /* XXX call2 */ 1104 report_count(2); 1105 report_return(mvgetnstr(y, x, string, count)); 1106 report_status(string); 1107 free(string); 1108 } 1109 1110 1111 void 1112 cmd_mvgetstr(int nargs, char **args) 1113 { 1114 int y, x; 1115 char string[256]; 1116 1117 if (check_arg_count(nargs, 2) == 1) 1118 return; 1119 1120 if (sscanf(args[0], "%d", &y) == 0) { 1121 report_count(1); 1122 report_error("BAD ARGUMENT"); 1123 return; 1124 } 1125 1126 if (sscanf(args[1], "%d", &x) == 0) { 1127 report_count(1); 1128 report_error("BAD ARGUMENT"); 1129 return; 1130 } 1131 1132 /* XXX call2 */ 1133 report_count(2); 1134 report_return(mvgetstr(y, x, string)); 1135 report_status(string); 1136 } 1137 1138 1139 void 1140 cmd_mvinch(int nargs, char **args) 1141 { 1142 int y, x; 1143 1144 if (check_arg_count(nargs, 2) == 1) 1145 return; 1146 1147 if (sscanf(args[0], "%d", &y) == 0) { 1148 report_count(1); 1149 report_error("BAD ARGUMENT"); 1150 return; 1151 } 1152 1153 if (sscanf(args[1], "%d", &x) == 0) { 1154 report_count(1); 1155 report_error("BAD ARGUMENT"); 1156 return; 1157 } 1158 1159 report_count(1); 1160 report_int(mvinch(y, x)); 1161 } 1162 1163 1164 void 1165 cmd_mvinchnstr(int nargs, char **args) 1166 { 1167 int y, x, count; 1168 chtype *string; 1169 1170 if (check_arg_count(nargs, 3) == 1) 1171 return; 1172 1173 if (sscanf(args[0], "%d", &y) == 0) { 1174 report_count(1); 1175 report_error("BAD ARGUMENT"); 1176 return; 1177 } 1178 1179 if (sscanf(args[1], "%d", &x) == 0) { 1180 report_count(1); 1181 report_error("BAD ARGUMENT"); 1182 return; 1183 } 1184 1185 if (sscanf(args[2], "%d", &count) == 0) { 1186 report_count(1); 1187 report_error("BAD ARGUMENT"); 1188 return; 1189 } 1190 1191 if ((string = malloc((count + 1) * sizeof(chtype))) == NULL) { 1192 report_count(1); 1193 report_error("MALLOC_FAILED"); 1194 return; 1195 } 1196 1197 /* XXX call2 */ 1198 report_count(2); 1199 report_return(mvinchnstr(y, x, string, count)); 1200 report_nstr(string); 1201 free(string); 1202 } 1203 1204 1205 void 1206 cmd_mvinchstr(int nargs, char **args) 1207 { 1208 int y, x; 1209 chtype string[256]; 1210 1211 if (check_arg_count(nargs, 2) == 1) 1212 return; 1213 1214 if (sscanf(args[0], "%d", &y) == 0) { 1215 report_count(1); 1216 report_error("BAD ARGUMENT"); 1217 return; 1218 } 1219 1220 if (sscanf(args[1], "%d", &x) == 0) { 1221 report_count(1); 1222 report_error("BAD ARGUMENT"); 1223 return; 1224 } 1225 1226 /* XXX call2 */ 1227 report_count(2); 1228 report_return(mvinchstr(y, x, string)); 1229 report_nstr(string); 1230 } 1231 1232 1233 void 1234 cmd_mvinnstr(int nargs, char **args) 1235 { 1236 int y, x, count; 1237 char *string; 1238 1239 if (check_arg_count(nargs, 3) == 1) 1240 return; 1241 1242 if (sscanf(args[0], "%d", &y) == 0) { 1243 report_count(1); 1244 report_error("BAD ARGUMENT"); 1245 return; 1246 } 1247 1248 if (sscanf(args[1], "%d", &x) == 0) { 1249 report_count(1); 1250 report_error("BAD ARGUMENT"); 1251 return; 1252 } 1253 1254 if (sscanf(args[2], "%d", &count) == 0) { 1255 report_count(1); 1256 report_error("BAD ARGUMENT"); 1257 return; 1258 } 1259 1260 if ((string = malloc(count + 1)) == NULL) { 1261 report_count(1); 1262 report_error("MALLOC_FAILED"); 1263 return; 1264 } 1265 1266 /* XXX call2 */ 1267 report_count(2); 1268 report_return(mvinnstr(y, x, string, count)); 1269 report_status(string); 1270 free(string); 1271 } 1272 1273 1274 void 1275 cmd_mvinsch(int nargs, char **args) 1276 { 1277 int y, x, ch; 1278 1279 if (check_arg_count(nargs, 3) == 1) 1280 return; 1281 1282 if (sscanf(args[0], "%d", &y) == 0) { 1283 report_count(1); 1284 report_error("BAD ARGUMENT"); 1285 return; 1286 } 1287 1288 if (sscanf(args[1], "%d", &x) == 0) { 1289 report_count(1); 1290 report_error("BAD ARGUMENT"); 1291 return; 1292 } 1293 1294 if (sscanf(args[2], "%d", &ch) == 0) { 1295 report_count(1); 1296 report_error("BAD ARGUMENT"); 1297 return; 1298 } 1299 1300 report_count(1); 1301 report_return(mvinsch(y, x, ch)); 1302 } 1303 1304 1305 void 1306 cmd_mvinstr(int nargs, char **args) 1307 { 1308 int y, x; 1309 1310 if (check_arg_count(nargs, 3) == 1) 1311 return; 1312 1313 if (sscanf(args[0], "%d", &y) == 0) { 1314 report_count(1); 1315 report_error("BAD ARGUMENT"); 1316 return; 1317 } 1318 1319 if (sscanf(args[1], "%d", &x) == 0) { 1320 report_count(1); 1321 report_error("BAD ARGUMENT"); 1322 return; 1323 } 1324 1325 report_count(1); 1326 report_return(mvinstr(y, x, args[2])); 1327 } 1328 1329 1330 1331 void 1332 cmd_mvwaddbytes(int nargs, char **args) 1333 { 1334 int y, x, count; 1335 WINDOW *win; 1336 1337 if (check_arg_count(nargs, 5) == 1) 1338 return; 1339 1340 if (sscanf(args[0], "%p", &win) == 0) { 1341 report_count(1); 1342 report_error("BAD ARGUMENT"); 1343 return; 1344 } 1345 1346 if (sscanf(args[1], "%d", &y) == 0) { 1347 report_count(1); 1348 report_error("BAD ARGUMENT"); 1349 return; 1350 } 1351 1352 if (sscanf(args[2], "%d", &x) == 0) { 1353 report_count(1); 1354 report_error("BAD ARGUMENT"); 1355 return; 1356 } 1357 1358 if (sscanf(args[4], "%d", &count) == 0) { 1359 report_count(1); 1360 report_error("BAD ARGUMENT"); 1361 return; 1362 } 1363 1364 report_count(1); 1365 report_return(mvwaddbytes(win, y, x, args[3], count)); 1366 } 1367 1368 1369 void 1370 cmd_mvwaddch(int nargs, char **args) 1371 { 1372 int y, x; 1373 WINDOW *win; 1374 1375 if (check_arg_count(nargs, 4) == 1) 1376 return; 1377 1378 if (sscanf(args[0], "%p", &win) == 0) { 1379 report_count(1); 1380 report_error("BAD ARGUMENT"); 1381 return; 1382 } 1383 1384 if (sscanf(args[1], "%d", &y) == 0) { 1385 report_count(1); 1386 report_error("BAD ARGUMENT"); 1387 return; 1388 } 1389 1390 if (sscanf(args[2], "%d", &x) == 0) { 1391 report_count(1); 1392 report_error("BAD ARGUMENT"); 1393 return; 1394 } 1395 1396 report_count(1); 1397 report_return(mvwaddch(win, y, x, args[3][0])); 1398 } 1399 1400 1401 void 1402 cmd_mvwaddchnstr(int nargs, char **args) 1403 { 1404 int y, x, count; 1405 WINDOW *win; 1406 1407 if (check_arg_count(nargs, 5) == 1) 1408 return; 1409 1410 if (sscanf(args[0], "%p", &win) == 0) { 1411 report_count(1); 1412 report_error("BAD ARGUMENT"); 1413 return; 1414 } 1415 1416 if (sscanf(args[1], "%d", &y) == 0) { 1417 report_count(1); 1418 report_error("BAD ARGUMENT"); 1419 return; 1420 } 1421 1422 if (sscanf(args[2], "%d", &x) == 0) { 1423 report_count(1); 1424 report_error("BAD ARGUMENT"); 1425 return; 1426 } 1427 1428 if (sscanf(args[4], "%d", &count) == 0) { 1429 report_count(1); 1430 report_error("BAD ARGUMENT"); 1431 return; 1432 } 1433 1434 report_count(1); 1435 report_return(mvwaddchnstr(win, y, x, (chtype *) args[3], count)); 1436 } 1437 1438 1439 void 1440 cmd_mvwaddchstr(int nargs, char **args) 1441 { 1442 int y, x; 1443 WINDOW *win; 1444 1445 if (check_arg_count(nargs, 4) == 1) 1446 return; 1447 1448 if (sscanf(args[0], "%p", &win) == 0) { 1449 report_count(1); 1450 report_error("BAD ARGUMENT"); 1451 return; 1452 } 1453 1454 if (sscanf(args[1], "%d", &y) == 0) { 1455 report_count(1); 1456 report_error("BAD ARGUMENT"); 1457 return; 1458 } 1459 1460 if (sscanf(args[2], "%d", &x) == 0) { 1461 report_count(1); 1462 report_error("BAD ARGUMENT"); 1463 return; 1464 } 1465 1466 report_count(1); 1467 report_return(mvwaddchstr(win, y, x, (chtype *) args[3])); 1468 } 1469 1470 1471 void 1472 cmd_mvwaddnstr(int nargs, char **args) 1473 { 1474 int y, x, count; 1475 WINDOW *win; 1476 1477 if (check_arg_count(nargs, 5) == 1) 1478 return; 1479 1480 if (sscanf(args[0], "%p", &win) == 0) { 1481 report_count(1); 1482 report_error("BAD ARGUMENT"); 1483 return; 1484 } 1485 1486 if (sscanf(args[1], "%d", &y) == 0) { 1487 report_count(1); 1488 report_error("BAD ARGUMENT"); 1489 return; 1490 } 1491 1492 if (sscanf(args[2], "%d", &x) == 0) { 1493 report_count(1); 1494 report_error("BAD ARGUMENT"); 1495 return; 1496 } 1497 1498 if (sscanf(args[4], "%d", &count) == 0) { 1499 report_count(1); 1500 report_error("BAD ARGUMENT"); 1501 return; 1502 } 1503 1504 report_count(1); 1505 report_return(mvwaddnstr(win, y, x, args[3], count)); 1506 } 1507 1508 1509 void 1510 cmd_mvwaddstr(int nargs, char **args) 1511 { 1512 int y, x; 1513 WINDOW *win; 1514 1515 if (check_arg_count(nargs, 4) == 1) 1516 return; 1517 1518 if (sscanf(args[0], "%p", &win) == 0) { 1519 report_count(1); 1520 report_error("BAD ARGUMENT"); 1521 return; 1522 } 1523 1524 if (sscanf(args[1], "%d", &y) == 0) { 1525 report_count(1); 1526 report_error("BAD ARGUMENT"); 1527 return; 1528 } 1529 1530 if (sscanf(args[2], "%d", &x) == 0) { 1531 report_count(1); 1532 report_error("BAD ARGUMENT"); 1533 return; 1534 } 1535 1536 report_count(1); 1537 report_return(mvwaddstr(win, y, x, args[3])); 1538 } 1539 1540 1541 void 1542 cmd_mvwdelch(int nargs, char **args) 1543 { 1544 int y, x; 1545 WINDOW *win; 1546 1547 if (check_arg_count(nargs, 3) == 1) 1548 return; 1549 1550 if (sscanf(args[0], "%p", &win) == 0) { 1551 report_count(1); 1552 report_error("BAD ARGUMENT"); 1553 return; 1554 } 1555 1556 if (sscanf(args[1], "%d", &y) == 0) { 1557 report_count(1); 1558 report_error("BAD ARGUMENT"); 1559 return; 1560 } 1561 1562 if (sscanf(args[2], "%d", &x) == 0) { 1563 report_count(1); 1564 report_error("BAD ARGUMENT"); 1565 return; 1566 } 1567 1568 report_count(1); 1569 report_return(mvwdelch(win, y, x)); 1570 } 1571 1572 1573 void 1574 cmd_mvwgetch(int nargs, char **args) 1575 { 1576 int y, x; 1577 WINDOW *win; 1578 1579 if (check_arg_count(nargs, 3) == 1) 1580 return; 1581 1582 if (sscanf(args[0], "%p", &win) == 0) { 1583 report_count(1); 1584 report_error("BAD ARGUMENT"); 1585 return; 1586 } 1587 1588 if (sscanf(args[1], "%d", &y) == 0) { 1589 report_count(1); 1590 report_error("BAD ARGUMENT"); 1591 return; 1592 } 1593 1594 if (sscanf(args[2], "%d", &x) == 0) { 1595 report_count(1); 1596 report_error("BAD ARGUMENT"); 1597 return; 1598 } 1599 1600 /* XXX - implicit refresh */ 1601 report_count(1); 1602 report_int(mvwgetch(win, y, x)); 1603 } 1604 1605 1606 void 1607 cmd_mvwgetnstr(int nargs, char **args) 1608 { 1609 int y, x, count; 1610 char *string; 1611 WINDOW *win; 1612 1613 if (check_arg_count(nargs, 4) == 1) 1614 return; 1615 1616 if (sscanf(args[0], "%p", &win) == 0) { 1617 report_count(1); 1618 report_error("BAD ARGUMENT"); 1619 return; 1620 } 1621 1622 if (sscanf(args[1], "%d", &y) == 0) { 1623 report_count(1); 1624 report_error("BAD ARGUMENT"); 1625 return; 1626 } 1627 1628 if (sscanf(args[2], "%d", &x) == 0) { 1629 report_count(1); 1630 report_error("BAD ARGUMENT"); 1631 return; 1632 } 1633 1634 if (sscanf(args[3], "%d", &count) == 0) { 1635 report_count(1); 1636 report_error("BAD ARGUMENT"); 1637 return; 1638 } 1639 1640 if ((string = malloc(count + 1)) == NULL) { 1641 report_count(1); 1642 report_error("MALLOC_FAILED"); 1643 return; 1644 } 1645 1646 /* XXX call2 */ 1647 report_count(2); 1648 report_return(mvwgetnstr(win, y, x, string, count)); 1649 report_status(string); 1650 free(string); 1651 } 1652 1653 1654 void 1655 cmd_mvwgetstr(int nargs, char **args) 1656 { 1657 int y, x; 1658 WINDOW *win; 1659 char string[256]; 1660 1661 if (check_arg_count(nargs, 3) == 1) 1662 return; 1663 1664 if (sscanf(args[0], "%p", &win) == 0) { 1665 report_count(1); 1666 report_error("BAD ARGUMENT"); 1667 return; 1668 } 1669 1670 if (sscanf(args[1], "%d", &y) == 0) { 1671 report_count(1); 1672 report_error("BAD ARGUMENT"); 1673 return; 1674 } 1675 1676 if (sscanf(args[2], "%d", &x) == 0) { 1677 report_count(1); 1678 report_error("BAD ARGUMENT"); 1679 return; 1680 } 1681 1682 /* XXX - call2 */ 1683 report_count(2); 1684 report_return(mvwgetstr(win, y, x, string)); 1685 report_status(string); 1686 } 1687 1688 1689 void 1690 cmd_mvwinch(int nargs, char **args) 1691 { 1692 int y, x; 1693 WINDOW *win; 1694 1695 if (check_arg_count(nargs, 3) == 1) 1696 return; 1697 1698 if (sscanf(args[0], "%p", &win) == 0) { 1699 report_count(1); 1700 report_error("BAD ARGUMENT"); 1701 return; 1702 } 1703 1704 if (sscanf(args[1], "%d", &y) == 0) { 1705 report_count(1); 1706 report_error("BAD ARGUMENT"); 1707 return; 1708 } 1709 1710 if (sscanf(args[2], "%d", &x) == 0) { 1711 report_count(1); 1712 report_error("BAD ARGUMENT"); 1713 return; 1714 } 1715 1716 report_count(1); 1717 report_int(mvwinch(win, y, x)); 1718 } 1719 1720 1721 void 1722 cmd_mvwinsch(int nargs, char **args) 1723 { 1724 int y, x; 1725 WINDOW *win; 1726 1727 if (check_arg_count(nargs, 4) == 1) 1728 return; 1729 1730 if (sscanf(args[0], "%p", &win) == 0) { 1731 report_count(1); 1732 report_error("BAD ARGUMENT"); 1733 return; 1734 } 1735 1736 if (sscanf(args[1], "%d", &y) == 0) { 1737 report_count(1); 1738 report_error("BAD ARGUMENT"); 1739 return; 1740 } 1741 1742 if (sscanf(args[2], "%d", &x) == 0) { 1743 report_count(1); 1744 report_error("BAD ARGUMENT"); 1745 return; 1746 } 1747 1748 report_count(1); 1749 report_int(mvwinsch(win, y, x, args[3][0])); 1750 } 1751 1752 1753 void 1754 cmd_assume_default_colors(int nargs, char **args) 1755 { 1756 short fore, back; 1757 1758 if (check_arg_count(nargs, 2) == 1) 1759 return; 1760 1761 if (sscanf(args[0], "%hd", &fore) == 0) { 1762 report_count(1); 1763 report_error("BAD ARGUMENT"); 1764 return; 1765 } 1766 1767 if (sscanf(args[1], "%hd", &back) == 0) { 1768 report_count(1); 1769 report_error("BAD ARGUMENT"); 1770 return; 1771 } 1772 1773 report_count(1); 1774 report_return(assume_default_colors(fore, back)); 1775 } 1776 1777 1778 void 1779 cmd_baudrate(int nargs, char **args) 1780 { 1781 if (check_arg_count(nargs, 0) == 1) 1782 return; 1783 1784 report_count(1); 1785 report_int(baudrate()); 1786 } 1787 1788 1789 void 1790 cmd_beep(int nargs, char **args) 1791 { 1792 if (check_arg_count(nargs, 0) == 1) 1793 return; 1794 1795 report_count(1); 1796 report_return(beep()); 1797 } 1798 1799 1800 void 1801 cmd_box(int nargs, char **args) 1802 { 1803 WINDOW *win; 1804 chtype *vertical, *horizontal; 1805 1806 if (check_arg_count(nargs, 3) == 1) 1807 return; 1808 1809 if (sscanf(args[0], "%p", &win) == 0) { 1810 report_count(1); 1811 report_error("BAD ARGUMENT"); 1812 return; 1813 } 1814 1815 vertical = (chtype *) args[1]; 1816 horizontal = (chtype *) args[2]; 1817 report_count(1); 1818 report_return(box(win, vertical[0], horizontal[0])); 1819 } 1820 1821 1822 void 1823 cmd_can_change_color(int nargs, char **args) 1824 { 1825 if (check_arg_count(nargs, 0) == 1) 1826 return; 1827 1828 report_count(1); 1829 report_int(can_change_color()); 1830 } 1831 1832 1833 void 1834 cmd_cbreak(int nargs, char **args) 1835 { 1836 if (check_arg_count(nargs, 0) == 1) 1837 return; 1838 1839 report_count(1); 1840 report_return(cbreak()); 1841 } 1842 1843 1844 void 1845 cmd_clearok(int nargs, char **args) 1846 { 1847 WINDOW *win; 1848 int flag; 1849 1850 if (check_arg_count(nargs, 2) == 1) 1851 return; 1852 1853 if (sscanf(args[0], "%p", &win) == 0) { 1854 report_count(1); 1855 report_error("BAD ARGUMENT"); 1856 return; 1857 } 1858 1859 if (sscanf(args[1], "%d", &flag) == 0) { 1860 report_count(1); 1861 report_error("BAD ARGUMENT"); 1862 return; 1863 } 1864 1865 report_count(1); 1866 report_return(clearok(win, flag)); 1867 } 1868 1869 1870 void 1871 cmd_color_content(int nargs, char **args) 1872 { 1873 short colour, red, green, blue; 1874 1875 if (check_arg_count(nargs, 1) == 1) 1876 return; 1877 1878 if (sscanf(args[0], "%hd", &colour) == 0) { 1879 report_count(1); 1880 report_error("BAD ARGUMENT"); 1881 return; 1882 } 1883 1884 /* XXX - call4 */ 1885 report_count(4); 1886 report_return(color_content(colour, &red, &green, &blue)); 1887 report_int(red); 1888 report_int(green); 1889 report_int(blue); 1890 } 1891 1892 1893 void 1894 cmd_copywin(int nargs, char **args) 1895 { 1896 int sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol, ovlay; 1897 WINDOW *source, *destination; 1898 1899 if (check_arg_count(nargs, 9) == 1) 1900 return; 1901 1902 if (sscanf(args[0], "%p", &source) == 0) { 1903 report_count(1); 1904 report_error("BAD ARGUMENT"); 1905 return; 1906 } 1907 1908 if (sscanf(args[1], "%p", &destination) == 0) { 1909 report_count(1); 1910 report_error("BAD ARGUMENT"); 1911 return; 1912 } 1913 1914 if (sscanf(args[2], "%d", &sminrow) == 0) { 1915 report_count(1); 1916 report_error("BAD ARGUMENT"); 1917 return; 1918 } 1919 1920 if (sscanf(args[3], "%d", &smincol) == 0) { 1921 report_count(1); 1922 report_error("BAD ARGUMENT"); 1923 return; 1924 } 1925 1926 if (sscanf(args[4], "%d", &dminrow) == 0) { 1927 report_count(1); 1928 report_error("BAD ARGUMENT"); 1929 return; 1930 } 1931 1932 if (sscanf(args[5], "%d", &dmincol) == 0) { 1933 report_count(1); 1934 report_error("BAD ARGUMENT"); 1935 return; 1936 } 1937 1938 if (sscanf(args[6], "%d", &dmaxrow) == 0) { 1939 report_count(1); 1940 report_error("BAD ARGUMENT"); 1941 return; 1942 } 1943 1944 if (sscanf(args[7], "%d", &dmaxcol) == 0) { 1945 report_count(1); 1946 report_error("BAD ARGUMENT"); 1947 return; 1948 } 1949 1950 if (sscanf(args[8], "%d", &ovlay) == 0) { 1951 report_count(1); 1952 report_error("BAD ARGUMENT"); 1953 return; 1954 } 1955 1956 report_count(1); 1957 report_return(copywin(source, destination, sminrow, smincol, dminrow, 1958 dmincol, dmaxrow, dmaxcol, ovlay)); 1959 } 1960 1961 1962 void 1963 cmd_curs_set(int nargs, char **args) 1964 { 1965 int vis; 1966 1967 if (check_arg_count(nargs, 1) == 1) 1968 return; 1969 1970 if (sscanf(args[0], "%d", &vis) == 0) { 1971 report_count(1); 1972 report_error("BAD ARGUMENT"); 1973 return; 1974 } 1975 1976 report_count(1); 1977 report_int(curs_set(vis)); 1978 } 1979 1980 1981 void 1982 cmd_def_prog_mode(int nargs, char **args) 1983 { 1984 if (check_arg_count(nargs, 0) == 1) 1985 return; 1986 1987 report_count(1); 1988 report_return(def_prog_mode()); 1989 } 1990 1991 1992 void 1993 cmd_def_shell_mode(int nargs, char **args) 1994 { 1995 if (check_arg_count(nargs, 0) == 1) 1996 return; 1997 1998 report_count(1); 1999 report_return(def_shell_mode()); 2000 } 2001 2002 2003 void 2004 cmd_define_key(int nargs, char **args) 2005 { 2006 int symbol; 2007 2008 if (check_arg_count(nargs, 2) == 1) 2009 return; 2010 2011 if (sscanf(args[1], "%d", &symbol) == 0) { 2012 report_count(1); 2013 report_error("BAD ARGUMENT"); 2014 return; 2015 } 2016 2017 report_count(1); 2018 report_return(define_key(args[0], symbol)); 2019 } 2020 2021 2022 void 2023 cmd_delay_output(int nargs, char **args) 2024 { 2025 int dtime; 2026 2027 if (check_arg_count(nargs, 1) == 1) 2028 return; 2029 2030 if (sscanf(args[0], "%d", &dtime) == 0) { 2031 report_count(1); 2032 report_error("BAD ARGUMENT"); 2033 return; 2034 } 2035 2036 report_count(1); 2037 report_return(delay_output(dtime)); 2038 } 2039 2040 2041 void 2042 cmd_delscreen(int nargs, char **args) 2043 { 2044 SCREEN *scrn; 2045 2046 if (check_arg_count(nargs, 1) == 1) 2047 return; 2048 2049 if (sscanf(args[0], "%p", &scrn) == 0) { 2050 report_count(1); 2051 report_error("BAD ARGUMENT"); 2052 return; 2053 } 2054 2055 delscreen(scrn); /* void return */ 2056 report_count(1); 2057 report_return(OK); 2058 } 2059 2060 2061 void 2062 cmd_delwin(int nargs, char **args) 2063 { 2064 WINDOW *win; 2065 2066 if (check_arg_count(nargs, 1) == 1) 2067 return; 2068 2069 if (sscanf(args[0], "%p", &win) == 0) { 2070 report_count(1); 2071 report_error("BAD ARGUMENT"); 2072 return; 2073 } 2074 2075 report_count(1); 2076 report_return(delwin(win)); 2077 } 2078 2079 2080 void 2081 cmd_derwin(int nargs, char **args) 2082 { 2083 int lines, cols, y, x; 2084 WINDOW *win; 2085 2086 if (check_arg_count(nargs, 5) == 1) 2087 return; 2088 2089 if (sscanf(args[0], "%p", &win) == 0) { 2090 report_count(1); 2091 report_error("BAD ARGUMENT"); 2092 return; 2093 } 2094 2095 if (sscanf(args[1], "%d", &lines) == 0) { 2096 report_count(1); 2097 report_error("BAD ARGUMENT"); 2098 return; 2099 } 2100 2101 if (sscanf(args[2], "%d", &cols) == 0) { 2102 report_count(1); 2103 report_error("BAD ARGUMENT"); 2104 return; 2105 } 2106 2107 if (sscanf(args[3], "%d", &y) == 0) { 2108 report_count(1); 2109 report_error("BAD ARGUMENT"); 2110 return; 2111 } 2112 2113 if (sscanf(args[4], "%d", &x) == 0) { 2114 report_count(1); 2115 report_error("BAD ARGUMENT"); 2116 return; 2117 } 2118 2119 report_count(1); 2120 report_ptr(derwin(win, lines, cols, y, x)); 2121 } 2122 2123 2124 void 2125 cmd_dupwin(int nargs, char **args) 2126 { 2127 WINDOW *win; 2128 2129 if (check_arg_count(nargs, 1) == 1) 2130 return; 2131 2132 if (sscanf(args[0], "%p", &win) == 0) { 2133 report_count(1); 2134 report_error("BAD ARGUMENT"); 2135 return; 2136 } 2137 2138 report_count(1); 2139 report_ptr(dupwin(win)); 2140 } 2141 2142 2143 void 2144 cmd_doupdate(int nargs, char **args) 2145 { 2146 if (check_arg_count(nargs, 0) == 1) 2147 return; 2148 2149 /* XXX - implicit refresh */ 2150 report_count(1); 2151 report_return(doupdate()); 2152 } 2153 2154 2155 void 2156 cmd_echo(int nargs, char **args) 2157 { 2158 if (check_arg_count(nargs, 0) == 1) 2159 return; 2160 2161 report_count(1); 2162 report_return(echo()); 2163 } 2164 2165 2166 void 2167 cmd_endwin(int nargs, char **args) 2168 { 2169 if (check_arg_count(nargs, 0) == 1) 2170 return; 2171 2172 report_count(1); 2173 report_return(endwin()); 2174 } 2175 2176 2177 void 2178 cmd_erasechar(int nargs, char **args) 2179 { 2180 if (check_arg_count(nargs, 0) == 1) 2181 return; 2182 2183 report_count(1); 2184 report_int(erasechar()); 2185 } 2186 2187 2188 void 2189 cmd_flash(int nargs, char **args) 2190 { 2191 if (check_arg_count(nargs, 0) == 1) 2192 return; 2193 2194 report_count(1); 2195 report_return(flash()); 2196 } 2197 2198 2199 void 2200 cmd_flushinp(int nargs, char **args) 2201 { 2202 if (check_arg_count(nargs, 0) == 1) 2203 return; 2204 2205 report_count(1); 2206 report_return(flushinp()); 2207 } 2208 2209 2210 void 2211 cmd_flushok(int nargs, char **args) 2212 { 2213 int flag; 2214 WINDOW *win; 2215 2216 if (check_arg_count(nargs, 2) == 1) 2217 return; 2218 2219 if (sscanf(args[0], "%p", &win) == 0) { 2220 report_count(1); 2221 report_error("BAD ARGUMENT"); 2222 return; 2223 } 2224 2225 if (sscanf(args[1], "%d", &flag) == 0) { 2226 report_count(1); 2227 report_error("BAD ARGUMENT"); 2228 return; 2229 } 2230 2231 report_count(1); 2232 report_return(flushok(win, flag)); 2233 } 2234 2235 2236 void 2237 cmd_fullname(int nargs, char **args) 2238 { 2239 char string[256]; 2240 2241 if (check_arg_count(nargs, 1) == 1) 2242 return; 2243 2244 /* XXX - call2 */ 2245 report_count(2); 2246 report_status(fullname(args[0], string)); 2247 report_status(string); 2248 } 2249 2250 2251 void 2252 cmd_getattrs(int nargs, char **args) 2253 { 2254 WINDOW *win; 2255 2256 if (check_arg_count(nargs, 1) == 1) 2257 return; 2258 2259 if (sscanf(args[0], "%p", &win) == 0) { 2260 report_count(1); 2261 report_error("BAD ARGUMENT"); 2262 return; 2263 } 2264 2265 report_count(1); 2266 report_int(getattrs(win)); 2267 } 2268 2269 2270 void 2271 cmd_getbkgd(int nargs, char **args) 2272 { 2273 WINDOW *win; 2274 2275 if (check_arg_count(nargs, 1) == 1) 2276 return; 2277 2278 if (sscanf(args[0], "%p", &win) == 0) { 2279 report_count(1); 2280 report_error("BAD ARGUMENT"); 2281 return; 2282 } 2283 2284 report_count(1); 2285 report_byte(getbkgd(win)); 2286 } 2287 2288 2289 void 2290 cmd_getcury(int nargs, char **args) 2291 { 2292 WINDOW *win; 2293 2294 if (check_arg_count(nargs, 1) == 1) 2295 return; 2296 2297 if (sscanf(args[0], "%p", &win) == 0) { 2298 report_count(1); 2299 report_error("BAD ARGUMENT"); 2300 return; 2301 } 2302 2303 report_count(1); 2304 report_int(getcury(win)); 2305 } 2306 2307 2308 void 2309 cmd_getcurx(int nargs, char **args) 2310 { 2311 WINDOW *win; 2312 2313 if (check_arg_count(nargs, 1) == 1) 2314 return; 2315 2316 if (sscanf(args[0], "%p", &win) == 0) { 2317 report_count(1); 2318 report_error("BAD ARGUMENT"); 2319 return; 2320 } 2321 2322 report_count(1); 2323 report_int(getcurx(win)); 2324 } 2325 2326 2327 void 2328 cmd_getyx(int nargs, char **args) 2329 { 2330 WINDOW *win; 2331 int y, x; 2332 2333 if (check_arg_count(nargs, 1) == 1) 2334 return; 2335 2336 if (sscanf(args[0], "%p", &win) == 0) { 2337 report_count(1); 2338 report_error("BAD ARGUMENT"); 2339 return; 2340 } 2341 2342 getyx(win, y, x); 2343 report_count(2); 2344 report_int(y); 2345 report_int(x); 2346 } 2347 2348 2349 void 2350 cmd_getbegy(int nargs, char **args) 2351 { 2352 WINDOW *win; 2353 2354 if (check_arg_count(nargs, 1) == 1) 2355 return; 2356 2357 if (sscanf(args[0], "%p", &win) == 0) { 2358 report_count(1); 2359 report_error("BAD ARGUMENT"); 2360 return; 2361 } 2362 2363 report_count(1); 2364 report_int(getbegy(win)); 2365 } 2366 2367 2368 void 2369 cmd_getbegx(int nargs, char **args) 2370 { 2371 WINDOW *win; 2372 2373 if (check_arg_count(nargs, 1) == 1) 2374 return; 2375 2376 if (sscanf(args[0], "%p", &win) == 0) { 2377 report_count(1); 2378 report_error("BAD ARGUMENT"); 2379 return; 2380 } 2381 2382 report_count(1); 2383 report_int(getbegx(win)); 2384 } 2385 2386 2387 void 2388 cmd_getmaxy(int nargs, char **args) 2389 { 2390 WINDOW *win; 2391 2392 if (check_arg_count(nargs, 1) == 1) 2393 return; 2394 2395 if (sscanf(args[0], "%p", &win) == 0) { 2396 report_count(1); 2397 report_error("BAD ARGUMENT"); 2398 return; 2399 } 2400 2401 report_count(1); 2402 report_int(getmaxy(win)); 2403 } 2404 2405 2406 void 2407 cmd_getmaxx(int nargs, char **args) 2408 { 2409 WINDOW *win; 2410 2411 if (check_arg_count(nargs, 1) == 1) 2412 return; 2413 2414 if (sscanf(args[0], "%p", &win) == 0) { 2415 report_count(1); 2416 report_error("BAD ARGUMENT"); 2417 return; 2418 } 2419 2420 report_count(1); 2421 report_int(getmaxx(win)); 2422 } 2423 2424 2425 void 2426 cmd_getpary(int nargs, char **args) 2427 { 2428 WINDOW *win; 2429 2430 if (check_arg_count(nargs, 1) == 1) 2431 return; 2432 2433 if (sscanf(args[0], "%p", &win) == 0) { 2434 report_count(1); 2435 report_error("BAD ARGUMENT"); 2436 return; 2437 } 2438 2439 report_count(1); 2440 report_int(getpary(win)); 2441 } 2442 2443 2444 void 2445 cmd_getparx(int nargs, char **args) 2446 { 2447 WINDOW *win; 2448 2449 if (check_arg_count(nargs, 1) == 1) 2450 return; 2451 2452 if (sscanf(args[0], "%p", &win) == 0) { 2453 report_count(1); 2454 report_error("BAD ARGUMENT"); 2455 return; 2456 } 2457 2458 report_count(1); 2459 report_int(getparx(win)); 2460 } 2461 2462 2463 void 2464 cmd_getparyx(int nargs, char **args) 2465 { 2466 WINDOW *win; 2467 int y, x; 2468 2469 if (check_arg_count(nargs, 1) == 1) 2470 return; 2471 2472 if (sscanf(args[0], "%p", &win) == 0) { 2473 report_count(1); 2474 report_error("BAD ARGUMENT"); 2475 return; 2476 } 2477 2478 report_count(2); 2479 getparyx(win, y, x); 2480 report_int(y); 2481 report_int(x); 2482 } 2483 2484 2485 void 2486 cmd_gettmode(int nargs, char **args) 2487 { 2488 if (check_arg_count(nargs, 0) == 1) 2489 return; 2490 2491 report_count(1); 2492 report_return(gettmode()); 2493 } 2494 2495 2496 void 2497 cmd_getwin(int nargs, char **args) 2498 { 2499 FILE *fp; 2500 2501 if (check_arg_count(nargs, 1) == 1) 2502 return; 2503 2504 if ((fp = fopen(args[0], "r")) == NULL) { 2505 report_count(1); 2506 report_error("BAD FILE_ARGUMENT"); 2507 return; 2508 } 2509 2510 report_count(1); 2511 report_ptr(getwin(fp)); 2512 fclose(fp); 2513 } 2514 2515 2516 void 2517 cmd_halfdelay(int nargs, char **args) 2518 { 2519 int ms; 2520 2521 if (check_arg_count(nargs, 1) == 1) 2522 return; 2523 2524 if (sscanf(args[0], "%d", &ms) == 0) { 2525 report_count(1); 2526 report_error("BAD ARGUMENT"); 2527 return; 2528 } 2529 2530 report_count(1); 2531 report_return(halfdelay(ms)); 2532 } 2533 2534 2535 void 2536 cmd_has_colors(int nargs, char **args) 2537 { 2538 if (check_arg_count(nargs, 0) == 1) 2539 return; 2540 2541 report_count(1); 2542 report_int(has_colors()); 2543 } 2544 2545 2546 void 2547 cmd_has_ic(int nargs, char **args) 2548 { 2549 if (check_arg_count(nargs, 0) == 1) 2550 return; 2551 2552 report_count(1); 2553 report_int(has_ic()); 2554 } 2555 2556 2557 void 2558 cmd_has_il(int nargs, char **args) 2559 { 2560 if (check_arg_count(nargs, 0) == 1) 2561 return; 2562 2563 report_count(1); 2564 report_int(has_il()); 2565 } 2566 2567 2568 void 2569 cmd_hline(int nargs, char **args) 2570 { 2571 int count; 2572 chtype *ch; 2573 2574 if (check_arg_count(nargs, 2) == 1) 2575 return; 2576 2577 ch = (chtype *) args[0]; 2578 2579 if (sscanf(args[1], "%d", &count) == 0) { 2580 report_count(1); 2581 report_error("BAD ARGUMENT"); 2582 return; 2583 } 2584 2585 report_count(1); 2586 report_return(hline(ch[0], count)); 2587 } 2588 2589 2590 void 2591 cmd_idcok(int nargs, char **args) 2592 { 2593 int flag; 2594 WINDOW *win; 2595 2596 if (check_arg_count(nargs, 2) == 1) 2597 return; 2598 2599 if (sscanf(args[0], "%p", &win) == 0) { 2600 report_count(1); 2601 report_error("BAD ARGUMENT"); 2602 return; 2603 } 2604 2605 if (sscanf(args[1], "%d", &flag) == 0) { 2606 report_count(1); 2607 report_error("BAD ARGUMENT"); 2608 return; 2609 } 2610 2611 report_count(1); 2612 report_return(idcok(win, flag)); 2613 } 2614 2615 2616 void 2617 cmd_idlok(int nargs, char **args) 2618 { 2619 int flag; 2620 WINDOW *win; 2621 2622 if (check_arg_count(nargs, 2) == 1) 2623 return; 2624 2625 if (sscanf(args[0], "%p", &win) == 0) { 2626 report_count(1); 2627 report_error("BAD ARGUMENT"); 2628 return; 2629 } 2630 2631 if (sscanf(args[1], "%d", &flag) == 0) { 2632 report_count(1); 2633 report_error("BAD ARGUMENT"); 2634 return; 2635 } 2636 2637 report_count(1); 2638 report_return(idlok(win, flag)); 2639 } 2640 2641 2642 void 2643 cmd_init_color(int nargs, char **args) 2644 { 2645 short colour, red, green, blue; 2646 2647 if (check_arg_count(nargs, 4) == 1) 2648 return; 2649 2650 if (sscanf(args[0], "%hd", &colour) == 0) { 2651 report_count(1); 2652 report_error("BAD ARGUMENT"); 2653 return; 2654 } 2655 2656 if (sscanf(args[1], "%hd", &red) == 0) { 2657 report_count(1); 2658 report_error("BAD ARGUMENT"); 2659 return; 2660 } 2661 2662 if (sscanf(args[2], "%hd", &green) == 0) { 2663 report_count(1); 2664 report_error("BAD ARGUMENT"); 2665 return; 2666 } 2667 2668 if (sscanf(args[3], "%hd", &blue) == 0) { 2669 report_count(1); 2670 report_error("BAD ARGUMENT"); 2671 return; 2672 } 2673 2674 report_count(1); 2675 report_return(init_color(colour, red, green, blue)); 2676 } 2677 2678 2679 void 2680 cmd_init_pair(int nargs, char **args) 2681 { 2682 short pair, fore, back; 2683 2684 if (check_arg_count(nargs, 3) == 1) 2685 return; 2686 2687 if (sscanf(args[0], "%hd", &pair) == 0) { 2688 report_count(1); 2689 report_error("BAD ARGUMENT"); 2690 return; 2691 } 2692 2693 if (sscanf(args[1], "%hd", &fore) == 0) { 2694 report_count(1); 2695 report_error("BAD ARGUMENT"); 2696 return; 2697 } 2698 2699 if (sscanf(args[2], "%hd", &back) == 0) { 2700 report_count(1); 2701 report_error("BAD ARGUMENT"); 2702 return; 2703 } 2704 2705 report_count(1); 2706 report_return(init_pair(pair, fore, back)); 2707 } 2708 2709 2710 void 2711 cmd_initscr(int nargs, char **args) 2712 { 2713 if (check_arg_count(nargs, 0) == 1) 2714 return; 2715 2716 report_count(1); 2717 report_ptr(initscr()); 2718 } 2719 2720 2721 void 2722 cmd_intrflush(int nargs, char **args) 2723 { 2724 int flag; 2725 WINDOW *win; 2726 2727 if (check_arg_count(nargs, 2) == 1) 2728 return; 2729 2730 if (sscanf(args[0], "%p", &win) == 0) { 2731 report_count(1); 2732 report_error("BAD ARGUMENT"); 2733 return; 2734 } 2735 2736 if (sscanf(args[1], "%d", &flag) == 0) { 2737 report_count(1); 2738 report_error("BAD ARGUMENT"); 2739 return; 2740 } 2741 2742 report_count(1); 2743 report_return(intrflush(win, flag)); 2744 } 2745 2746 2747 void 2748 cmd_isendwin(int nargs, char **args) 2749 { 2750 if (check_arg_count(nargs, 0) == 1) 2751 return; 2752 2753 report_count(1); 2754 report_int(isendwin()); 2755 } 2756 2757 2758 void 2759 cmd_is_linetouched(int nargs, char **args) 2760 { 2761 int line; 2762 WINDOW *win; 2763 2764 if (check_arg_count(nargs, 2) == 1) 2765 return; 2766 2767 if (sscanf(args[0], "%p", &win) == 0) { 2768 report_count(1); 2769 report_error("BAD ARGUMENT"); 2770 return; 2771 } 2772 2773 if (sscanf(args[1], "%d", &line) == 0) { 2774 report_count(1); 2775 report_error("BAD ARGUMENT"); 2776 return; 2777 } 2778 2779 report_count(1); 2780 report_int(is_linetouched(win, line)); 2781 } 2782 2783 2784 void 2785 cmd_is_wintouched(int nargs, char **args) 2786 { 2787 WINDOW *win; 2788 2789 if (check_arg_count(nargs, 1) == 1) 2790 return; 2791 2792 if (sscanf(args[0], "%p", &win) == 0) { 2793 report_count(1); 2794 report_error("BAD ARGUMENT"); 2795 return; 2796 } 2797 2798 report_count(1); 2799 report_int(is_wintouched(win)); 2800 } 2801 2802 2803 void 2804 cmd_keyok(int nargs, char **args) 2805 { 2806 int keysym, flag; 2807 2808 if (check_arg_count(nargs, 2) == 1) 2809 return; 2810 2811 if (sscanf(args[0], "%d", &keysym) == 0) { 2812 report_count(1); 2813 report_error("BAD ARGUMENT"); 2814 return; 2815 } 2816 2817 if (sscanf(args[1], "%d", &flag) == 0) { 2818 report_count(1); 2819 report_error("BAD ARGUMENT"); 2820 return; 2821 } 2822 2823 report_count(1); 2824 report_return(keyok(keysym, flag)); 2825 } 2826 2827 2828 void 2829 cmd_keypad(int nargs, char **args) 2830 { 2831 int flag; 2832 WINDOW *win; 2833 2834 if (check_arg_count(nargs, 2) == 1) 2835 return; 2836 2837 if (sscanf(args[0], "%p", &win) == 0) { 2838 report_count(1); 2839 report_error("BAD ARGUMENT"); 2840 return; 2841 } 2842 2843 if (sscanf(args[1], "%d", &flag) == 0) { 2844 report_count(1); 2845 report_error("BAD ARGUMENT"); 2846 return; 2847 } 2848 2849 report_count(1); 2850 report_return(keypad(win, flag)); 2851 } 2852 2853 2854 void 2855 cmd_keyname(int nargs, char **args) 2856 { 2857 unsigned int key; 2858 2859 if (check_arg_count(nargs, 1) == 1) 2860 return; 2861 2862 if (sscanf(args[0], "%d", &key) == 0) { 2863 report_count(1); 2864 report_error("BAD ARGUMENT"); 2865 return; 2866 } 2867 2868 report_count(1); 2869 report_status(keyname(key)); 2870 } 2871 2872 2873 void 2874 cmd_killchar(int nargs, char **args) 2875 { 2876 if (check_arg_count(nargs, 0) == 1) 2877 return; 2878 2879 report_count(1); 2880 report_int(killchar()); 2881 } 2882 2883 2884 void 2885 cmd_leaveok(int nargs, char **args) 2886 { 2887 int flag; 2888 WINDOW *win; 2889 2890 if (check_arg_count(nargs, 2) == 1) 2891 return; 2892 2893 if (sscanf(args[0], "%p", &win) == 0) { 2894 report_count(1); 2895 report_error("BAD ARGUMENT"); 2896 return; 2897 } 2898 2899 if (sscanf(args[1], "%d", &flag) == 0) { 2900 report_count(1); 2901 report_error("BAD ARGUMENT"); 2902 return; 2903 } 2904 2905 report_count(1); 2906 report_return(leaveok(win, flag)); 2907 } 2908 2909 2910 void 2911 cmd_meta(int nargs, char **args) 2912 { 2913 int flag; 2914 WINDOW *win; 2915 2916 if (check_arg_count(nargs, 2) == 1) 2917 return; 2918 2919 if (sscanf(args[0], "%p", &win) == 0) { 2920 report_count(1); 2921 report_error("BAD ARGUMENT"); 2922 return; 2923 } 2924 2925 if (sscanf(args[1], "%d", &flag) == 0) { 2926 report_count(1); 2927 report_error("BAD ARGUMENT"); 2928 return; 2929 } 2930 2931 report_count(1); 2932 report_return(meta(win, flag)); 2933 } 2934 2935 2936 void 2937 cmd_mvcur(int nargs, char **args) 2938 { 2939 int oldy, oldx, y, x; 2940 2941 if (check_arg_count(nargs, 4) == 1) 2942 return; 2943 2944 if (sscanf(args[0], "%d", &oldy) == 0) { 2945 report_count(1); 2946 report_error("BAD ARGUMENT"); 2947 return; 2948 } 2949 2950 if (sscanf(args[1], "%d", &oldx) == 0) { 2951 report_count(1); 2952 report_error("BAD ARGUMENT"); 2953 return; 2954 } 2955 2956 if (sscanf(args[2], "%d", &y) == 0) { 2957 report_count(1); 2958 report_error("BAD ARGUMENT"); 2959 return; 2960 } 2961 2962 if (sscanf(args[3], "%d", &x) == 0) { 2963 report_count(1); 2964 report_error("BAD ARGUMENT"); 2965 return; 2966 } 2967 2968 report_count(1); 2969 report_return(mvcur(oldy, oldx, y, x)); 2970 } 2971 2972 2973 void 2974 cmd_mvderwin(int nargs, char **args) 2975 { 2976 int y, x; 2977 WINDOW *win; 2978 2979 if (check_arg_count(nargs, 3) == 1) 2980 return; 2981 2982 if (sscanf(args[0], "%p", &win) == 0) { 2983 report_count(1); 2984 report_error("BAD ARGUMENT"); 2985 return; 2986 } 2987 2988 if (sscanf(args[1], "%d", &y) == 0) { 2989 report_count(1); 2990 report_error("BAD ARGUMENT"); 2991 return; 2992 } 2993 2994 if (sscanf(args[2], "%d", &x) == 0) { 2995 report_count(1); 2996 report_error("BAD ARGUMENT"); 2997 return; 2998 } 2999 3000 report_count(1); 3001 report_return(mvderwin(win, y, x)); 3002 } 3003 3004 3005 void 3006 cmd_mvhline(int nargs, char **args) 3007 { 3008 int y, x, n; 3009 chtype *ch; 3010 3011 if (check_arg_count(nargs, 4) == 1) 3012 return; 3013 3014 if (sscanf(args[0], "%d", &y) == 0) { 3015 report_count(1); 3016 report_error("BAD ARGUMENT"); 3017 return; 3018 } 3019 3020 if (sscanf(args[1], "%d", &x) == 0) { 3021 report_count(1); 3022 report_error("BAD ARGUMENT"); 3023 return; 3024 } 3025 3026 ch = (chtype *) args[2]; 3027 3028 if (sscanf(args[3], "%d", &n) == 0) { 3029 report_count(1); 3030 report_error("BAD ARGUMENT"); 3031 return; 3032 } 3033 3034 report_count(1); 3035 report_return(mvhline(y, x, ch[0], n)); 3036 } 3037 3038 3039 void 3040 cmd_mvprintw(int nargs, char **args) 3041 { 3042 int y, x; 3043 3044 if (check_arg_count(nargs, 4) == 1) 3045 return; 3046 3047 if (sscanf(args[0], "%d", &y) == 0) { 3048 report_count(1); 3049 report_error("BAD ARGUMENT"); 3050 return; 3051 } 3052 3053 if (sscanf(args[1], "%d", &x) == 0) { 3054 report_count(1); 3055 report_error("BAD ARGUMENT"); 3056 return; 3057 } 3058 3059 report_count(1); 3060 report_return(mvprintw(y, x, args[2], args[3])); 3061 } 3062 3063 3064 void 3065 cmd_mvscanw(int nargs, char **args) 3066 { 3067 int y, x; 3068 char string[256]; 3069 3070 if (check_arg_count(nargs, 3) == 1) 3071 return; 3072 3073 if (sscanf(args[0], "%d", &y) == 0) { 3074 report_count(1); 3075 report_error("BAD ARGUMENT"); 3076 return; 3077 } 3078 3079 if (sscanf(args[1], "%d", &x) == 0) { 3080 report_count(1); 3081 report_error("BAD ARGUMENT"); 3082 return; 3083 } 3084 3085 /* XXX - call2 */ 3086 report_count(2); 3087 report_return(mvscanw(y, x, args[2], &string)); 3088 report_status(string); 3089 } 3090 3091 3092 void 3093 cmd_mvvline(int nargs, char **args) 3094 { 3095 int y, x, n; 3096 chtype *ch; 3097 3098 if (check_arg_count(nargs, 4) == 1) 3099 return; 3100 3101 if (sscanf(args[0], "%d", &y) == 0) { 3102 report_count(1); 3103 report_error("BAD ARGUMENT"); 3104 return; 3105 } 3106 3107 if (sscanf(args[1], "%d", &x) == 0) { 3108 report_count(1); 3109 report_error("BAD ARGUMENT"); 3110 return; 3111 } 3112 3113 ch = (chtype *) args[2]; 3114 3115 if (sscanf(args[3], "%d", &n) == 0) { 3116 report_count(1); 3117 report_error("BAD ARGUMENT"); 3118 return; 3119 } 3120 3121 report_count(1); 3122 report_return(mvvline(y, x, ch[0], n)); 3123 } 3124 3125 3126 void 3127 cmd_mvwhline(int nargs, char **args) 3128 { 3129 int y, x, ch, n; 3130 WINDOW *win; 3131 3132 if (check_arg_count(nargs, 5) == 1) 3133 return; 3134 3135 if (sscanf(args[0], "%p", &win) == 0) { 3136 report_count(1); 3137 report_error("BAD ARGUMENT"); 3138 return; 3139 } 3140 3141 if (sscanf(args[1], "%d", &y) == 0) { 3142 report_count(1); 3143 report_error("BAD ARGUMENT"); 3144 return; 3145 } 3146 3147 if (sscanf(args[2], "%d", &x) == 0) { 3148 report_count(1); 3149 report_error("BAD ARGUMENT"); 3150 return; 3151 } 3152 3153 if (sscanf(args[3], "%d", &ch) == 0) { 3154 report_count(1); 3155 report_error("BAD ARGUMENT"); 3156 return; 3157 } 3158 3159 if (sscanf(args[4], "%d", &n) == 0) { 3160 report_count(1); 3161 report_error("BAD ARGUMENT"); 3162 return; 3163 } 3164 3165 report_count(1); 3166 report_return(mvwhline(win, y, x, ch, n)); 3167 } 3168 3169 3170 void 3171 cmd_mvwvline(int nargs, char **args) 3172 { 3173 int y, x, n; 3174 WINDOW *win; 3175 chtype *ch; 3176 3177 if (check_arg_count(nargs, 5) == 1) 3178 return; 3179 3180 if (sscanf(args[0], "%p", &win) == 0) { 3181 report_count(1); 3182 report_error("BAD ARGUMENT"); 3183 return; 3184 } 3185 3186 if (sscanf(args[1], "%d", &y) == 0) { 3187 report_count(1); 3188 report_error("BAD ARGUMENT"); 3189 return; 3190 } 3191 3192 if (sscanf(args[2], "%d", &x) == 0) { 3193 report_count(1); 3194 report_error("BAD ARGUMENT"); 3195 return; 3196 } 3197 3198 ch = (chtype *) args[3]; 3199 3200 if (sscanf(args[4], "%d", &n) == 0) { 3201 report_count(1); 3202 report_error("BAD ARGUMENT"); 3203 return; 3204 } 3205 3206 report_count(1); 3207 report_return(mvwvline(win, y, x, ch[0], n)); 3208 } 3209 3210 3211 void 3212 cmd_mvwin(int nargs, char **args) 3213 { 3214 int y, x; 3215 WINDOW *win; 3216 3217 if (check_arg_count(nargs, 3) == 1) 3218 return; 3219 3220 if (sscanf(args[0], "%p", &win) == 0) { 3221 report_count(1); 3222 report_error("BAD ARGUMENT"); 3223 return; 3224 } 3225 3226 if (sscanf(args[1], "%d", &y) == 0) { 3227 report_count(1); 3228 report_error("BAD ARGUMENT"); 3229 return; 3230 } 3231 3232 if (sscanf(args[2], "%d", &x) == 0) { 3233 report_count(1); 3234 report_error("BAD ARGUMENT"); 3235 return; 3236 } 3237 3238 report_count(1); 3239 report_return(mvwin(win, y, x)); 3240 } 3241 3242 3243 void 3244 cmd_mvwinchnstr(int nargs, char **args) 3245 { 3246 int y, x, count; 3247 chtype *string; 3248 WINDOW *win; 3249 3250 if (check_arg_count(nargs, 4) == 1) 3251 return; 3252 3253 if (sscanf(args[0], "%p", &win) == 0) { 3254 report_count(1); 3255 report_error("BAD ARGUMENT"); 3256 return; 3257 } 3258 3259 if (sscanf(args[1], "%d", &y) == 0) { 3260 report_count(1); 3261 report_error("BAD ARGUMENT"); 3262 return; 3263 } 3264 3265 if (sscanf(args[2], "%d", &x) == 0) { 3266 report_count(1); 3267 report_error("BAD ARGUMENT"); 3268 return; 3269 } 3270 3271 if (sscanf(args[3], "%d", &count) == 0) { 3272 report_count(1); 3273 report_error("BAD ARGUMENT"); 3274 return; 3275 } 3276 3277 if ((string = malloc((count + 1) * sizeof(chtype))) == NULL) { 3278 report_count(1); 3279 report_error("MALLOC_FAILED"); 3280 return; 3281 } 3282 3283 /* XXX call2 */ 3284 report_count(2); 3285 report_return(mvwinchnstr(win, y, x, string, count)); 3286 report_nstr(string); 3287 free(string); 3288 } 3289 3290 3291 void 3292 cmd_mvwinchstr(int nargs, char **args) 3293 { 3294 int y, x; 3295 chtype string[256]; 3296 WINDOW *win; 3297 3298 if (check_arg_count(nargs, 3) == 1) 3299 return; 3300 3301 if (sscanf(args[0], "%p", &win) == 0) { 3302 report_count(1); 3303 report_error("BAD ARGUMENT"); 3304 return; 3305 } 3306 3307 if (sscanf(args[1], "%d", &y) == 0) { 3308 report_count(1); 3309 report_error("BAD ARGUMENT"); 3310 return; 3311 } 3312 3313 if (sscanf(args[2], "%d", &x) == 0) { 3314 report_count(1); 3315 report_error("BAD ARGUMENT"); 3316 return; 3317 } 3318 3319 /* XXX call2 */ 3320 report_count(2); 3321 report_return(mvwinchstr(win, y, x, string)); 3322 report_nstr(string); 3323 } 3324 3325 3326 void 3327 cmd_mvwinnstr(int nargs, char **args) 3328 { 3329 int y, x, count; 3330 char *string; 3331 WINDOW *win; 3332 3333 if (check_arg_count(nargs, 4) == 1) 3334 return; 3335 3336 if (sscanf(args[0], "%p", &win) == 0) { 3337 report_count(1); 3338 report_error("BAD ARGUMENT"); 3339 return; 3340 } 3341 3342 if (sscanf(args[1], "%d", &y) == 0) { 3343 report_count(1); 3344 report_error("BAD ARGUMENT"); 3345 return; 3346 } 3347 3348 if (sscanf(args[2], "%d", &x) == 0) { 3349 report_count(1); 3350 report_error("BAD ARGUMENT"); 3351 return; 3352 } 3353 3354 if (sscanf(args[3], "%d", &count) == 0) { 3355 report_count(1); 3356 report_error("BAD ARGUMENT"); 3357 return; 3358 } 3359 3360 if ((string = malloc(count + 1)) == NULL) { 3361 report_count(1); 3362 report_error("MALLOC_FAILED"); 3363 return; 3364 } 3365 3366 /* XXX call2 */ 3367 report_count(2); 3368 report_return(mvwinnstr(win, y, x, string, count)); 3369 report_status(string); 3370 free(string); 3371 } 3372 3373 3374 void 3375 cmd_mvwinstr(int nargs, char **args) 3376 { 3377 int y, x; 3378 char string[256]; 3379 WINDOW *win; 3380 3381 if (check_arg_count(nargs, 3) == 1) 3382 return; 3383 3384 if (sscanf(args[0], "%p", &win) == 0) { 3385 report_count(1); 3386 report_error("BAD ARGUMENT"); 3387 return; 3388 } 3389 3390 if (sscanf(args[1], "%d", &y) == 0) { 3391 report_count(1); 3392 report_error("BAD ARGUMENT"); 3393 return; 3394 } 3395 3396 if (sscanf(args[2], "%d", &x) == 0) { 3397 report_count(1); 3398 report_error("BAD ARGUMENT"); 3399 return; 3400 } 3401 3402 /* XXX call2 */ 3403 report_count(2); 3404 report_return(mvwinstr(win, y, x, string)); 3405 report_status(string); 3406 } 3407 3408 3409 void 3410 cmd_mvwprintw(int nargs, char **args) 3411 { 3412 int y, x; 3413 WINDOW *win; 3414 3415 if (check_arg_count(nargs, 5) == 1) 3416 return; 3417 3418 if (sscanf(args[0], "%p", &win) == 0) { 3419 report_count(1); 3420 report_error("BAD ARGUMENT"); 3421 return; 3422 } 3423 3424 if (sscanf(args[1], "%d", &y) == 0) { 3425 report_count(1); 3426 report_error("BAD ARGUMENT"); 3427 return; 3428 } 3429 3430 if (sscanf(args[2], "%d", &x) == 0) { 3431 report_count(1); 3432 report_error("BAD ARGUMENT"); 3433 return; 3434 } 3435 3436 report_count(1); 3437 report_return(mvwprintw(win, y, x, args[3], args[4])); 3438 } 3439 3440 3441 void 3442 cmd_mvwscanw(int nargs, char **args) 3443 { 3444 int y, x; 3445 WINDOW *win; 3446 char string[256]; 3447 3448 if (check_arg_count(nargs, 4) == 1) 3449 return; 3450 3451 if (sscanf(args[0], "%p", &win) == 0) { 3452 report_count(1); 3453 report_error("BAD ARGUMENT"); 3454 return; 3455 } 3456 3457 if (sscanf(args[1], "%d", &y) == 0) { 3458 report_count(1); 3459 report_error("BAD ARGUMENT"); 3460 return; 3461 } 3462 3463 if (sscanf(args[2], "%d", &x) == 0) { 3464 report_count(1); 3465 report_error("BAD ARGUMENT"); 3466 return; 3467 } 3468 3469 /* XXX - call2 */ 3470 report_count(2); 3471 report_int(mvwscanw(win, y, x, args[3], &string)); 3472 report_status(string); 3473 } 3474 3475 3476 void 3477 cmd_napms(int nargs, char **args) 3478 { 3479 int naptime; 3480 3481 if (check_arg_count(nargs, 1) == 1) 3482 return; 3483 3484 if (sscanf(args[0], "%d", &naptime) == 0) { 3485 report_count(1); 3486 report_error("BAD ARGUMENT"); 3487 return; 3488 } 3489 3490 report_count(1); 3491 report_return(napms(naptime)); 3492 } 3493 3494 3495 void 3496 cmd_newpad(int nargs, char **args) 3497 { 3498 int y, x; 3499 3500 if (check_arg_count(nargs, 2) == 1) 3501 return; 3502 3503 if (sscanf(args[0], "%d", &y) == 0) { 3504 report_count(1); 3505 report_error("BAD ARGUMENT"); 3506 return; 3507 } 3508 3509 if (sscanf(args[1], "%d", &x) == 0) { 3510 report_count(1); 3511 report_error("BAD ARGUMENT"); 3512 return; 3513 } 3514 3515 report_count(1); 3516 report_ptr(newpad(y, x)); 3517 } 3518 3519 3520 void 3521 cmd_newterm(int nargs, char **args) 3522 { 3523 FILE *in, *out; 3524 3525 if (check_arg_count(nargs, 3) == 1) 3526 return; 3527 3528 if ((in = fopen(args[1], "rw")) == NULL) { 3529 report_count(1); 3530 report_error("BAD FILE_ARGUMENT"); 3531 return; 3532 } 3533 3534 3535 if ((out = fopen(args[2], "rw")) == NULL) { 3536 report_count(1); 3537 report_error("BAD FILE_ARGUMENT"); 3538 return; 3539 } 3540 3541 report_count(1); 3542 report_ptr(newterm(args[0], out, in)); 3543 } 3544 3545 3546 void 3547 cmd_newwin(int nargs, char **args) 3548 { 3549 int lines, cols, begin_y, begin_x; 3550 3551 if (check_arg_count(nargs, 4) == 1) 3552 return; 3553 3554 if (sscanf(args[0], "%d", &lines) == 0) { 3555 report_count(1); 3556 report_error("BAD ARGUMENT"); 3557 return; 3558 } 3559 3560 if (sscanf(args[1], "%d", &cols) == 0) { 3561 report_count(1); 3562 report_error("BAD ARGUMENT"); 3563 return; 3564 } 3565 3566 if (sscanf(args[2], "%d", &begin_y) == 0) { 3567 report_count(1); 3568 report_error("BAD ARGUMENT"); 3569 return; 3570 } 3571 3572 if (sscanf(args[3], "%d", &begin_x) == 0) { 3573 report_count(1); 3574 report_error("BAD ARGUMENT"); 3575 return; 3576 } 3577 3578 report_count(1); 3579 report_ptr(newwin(lines, cols, begin_y, begin_x)); 3580 } 3581 3582 3583 void 3584 cmd_nl(int nargs, char **args) 3585 { 3586 if (check_arg_count(nargs, 0) == 1) 3587 return; 3588 3589 report_count(1); 3590 report_return(nl()); 3591 } 3592 3593 3594 void 3595 cmd_no_color_attributes(int nargs, char **args) 3596 { 3597 if (check_arg_count(nargs, 0) == 1) 3598 return; 3599 3600 report_count(1); 3601 report_int(no_color_attributes()); 3602 } 3603 3604 3605 void 3606 cmd_nocbreak(int nargs, char **args) 3607 { 3608 if (check_arg_count(nargs, 0) == 1) 3609 return; 3610 3611 report_count(1); 3612 report_return(nocbreak()); 3613 } 3614 3615 3616 void 3617 cmd_nodelay(int nargs, char **args) 3618 { 3619 int flag; 3620 WINDOW *win; 3621 3622 if (check_arg_count(nargs, 2) == 1) 3623 return; 3624 3625 if (sscanf(args[0], "%p", &win) == 0) { 3626 report_count(1); 3627 report_error("BAD ARGUMENT"); 3628 return; 3629 } 3630 3631 if (sscanf(args[1], "%d", &flag) == 0) { 3632 report_count(1); 3633 report_error("BAD ARGUMENT"); 3634 return; 3635 } 3636 3637 report_count(1); 3638 report_return(nodelay(win, flag)); 3639 } 3640 3641 3642 void 3643 cmd_noecho(int nargs, char **args) 3644 { 3645 if (check_arg_count(nargs, 0) == 1) 3646 return; 3647 3648 report_count(1); 3649 report_return(noecho()); 3650 } 3651 3652 3653 void 3654 cmd_nonl(int nargs, char **args) 3655 { 3656 if (check_arg_count(nargs, 0) == 1) 3657 return; 3658 3659 report_count(1); 3660 report_return(nonl()); 3661 } 3662 3663 3664 void 3665 cmd_noqiflush(int nargs, char **args) 3666 { 3667 if (check_arg_count(nargs, 0) == 1) 3668 return; 3669 3670 noqiflush(); 3671 report_count(1); 3672 report_return(OK); /* fake a return, the call returns void */ 3673 } 3674 3675 3676 void 3677 cmd_noraw(int nargs, char **args) 3678 { 3679 if (check_arg_count(nargs, 0) == 1) 3680 return; 3681 3682 report_count(1); 3683 report_return(noraw()); 3684 } 3685 3686 3687 void 3688 cmd_notimeout(int nargs, char **args) 3689 { 3690 int flag; 3691 WINDOW *win; 3692 3693 if (check_arg_count(nargs, 2) == 1) 3694 return; 3695 3696 if (sscanf(args[0], "%p", &win) == 0) { 3697 report_count(1); 3698 report_error("BAD ARGUMENT"); 3699 return; 3700 } 3701 3702 if (sscanf(args[1], "%d", &flag) == 0) { 3703 report_count(1); 3704 report_error("BAD ARGUMENT"); 3705 return; 3706 } 3707 3708 report_count(1); 3709 report_return(notimeout(win, flag)); 3710 } 3711 3712 3713 void 3714 cmd_overlay(int nargs, char **args) 3715 { 3716 WINDOW *source, *dest; 3717 3718 if (check_arg_count(nargs, 2) == 1) 3719 return; 3720 3721 if (sscanf(args[0], "%p", &source) == 0) { 3722 report_count(1); 3723 report_error("BAD ARGUMENT"); 3724 return; 3725 } 3726 3727 if (sscanf(args[1], "%p", &dest) == 0) { 3728 report_count(1); 3729 report_error("BAD ARGUMENT"); 3730 return; 3731 } 3732 3733 report_count(1); 3734 report_return(overlay(source, dest)); 3735 } 3736 3737 3738 void 3739 cmd_overwrite(int nargs, char **args) 3740 { 3741 WINDOW *source, *dest; 3742 3743 if (check_arg_count(nargs, 2) == 1) 3744 return; 3745 3746 if (sscanf(args[0], "%p", &source) == 0) { 3747 report_count(1); 3748 report_error("BAD ARGUMENT"); 3749 return; 3750 } 3751 3752 if (sscanf(args[1], "%p", &dest) == 0) { 3753 report_count(1); 3754 report_error("BAD ARGUMENT"); 3755 return; 3756 } 3757 3758 report_count(1); 3759 report_return(overwrite(source, dest)); 3760 } 3761 3762 3763 void 3764 cmd_pair_content(int nargs, char **args) 3765 { 3766 short pair, fore, back; 3767 3768 if (check_arg_count(nargs, 1) == 1) 3769 return; 3770 3771 if (sscanf(args[0], "%hd", &pair) == 0) { 3772 report_count(1); 3773 report_error("BAD ARGUMENT"); 3774 return; 3775 } 3776 3777 /* XXX - call3 */ 3778 report_count(3); 3779 report_return(pair_content(pair, &fore, &back)); 3780 report_int(fore); 3781 report_int(back); 3782 } 3783 3784 3785 void 3786 cmd_pechochar(int nargs, char **args) 3787 { 3788 int ch; 3789 WINDOW *pad; 3790 3791 if (check_arg_count(nargs, 2) == 1) 3792 return; 3793 3794 if (sscanf(args[0], "%p", &pad) == 0) { 3795 report_count(1); 3796 report_error("BAD ARGUMENT"); 3797 return; 3798 } 3799 3800 if (sscanf(args[1], "%d", &ch) == 0) { 3801 report_count(1); 3802 report_error("BAD ARGUMENT"); 3803 return; 3804 } 3805 3806 report_count(1); 3807 report_return(pechochar(pad, ch)); 3808 } 3809 3810 3811 void 3812 cmd_pnoutrefresh(int nargs, char **args) 3813 { 3814 int pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, smax_x; 3815 WINDOW *pad; 3816 3817 if (check_arg_count(nargs, 7) == 1) 3818 return; 3819 3820 if (sscanf(args[0], "%p", &pad) == 0) { 3821 report_count(1); 3822 report_error("BAD ARGUMENT"); 3823 return; 3824 } 3825 3826 if (sscanf(args[1], "%d", &pbeg_y) == 0) { 3827 report_count(1); 3828 report_error("BAD ARGUMENT"); 3829 return; 3830 } 3831 3832 if (sscanf(args[2], "%d", &pbeg_x) == 0) { 3833 report_count(1); 3834 report_error("BAD ARGUMENT"); 3835 return; 3836 } 3837 3838 if (sscanf(args[3], "%d", &sbeg_y) == 0) { 3839 report_count(1); 3840 report_error("BAD ARGUMENT"); 3841 return; 3842 } 3843 3844 if (sscanf(args[4], "%d", &sbeg_x) == 0) { 3845 report_count(1); 3846 report_error("BAD ARGUMENT"); 3847 return; 3848 } 3849 3850 if (sscanf(args[5], "%d", &smax_y) == 0) { 3851 report_count(1); 3852 report_error("BAD ARGUMENT"); 3853 return; 3854 } 3855 3856 if (sscanf(args[6], "%d", &smax_x) == 0) { 3857 report_count(1); 3858 report_error("BAD ARGUMENT"); 3859 return; 3860 } 3861 3862 report_count(1); 3863 report_return(pnoutrefresh(pad, pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, 3864 smax_x)); 3865 } 3866 3867 3868 void 3869 cmd_prefresh(int nargs, char **args) 3870 { 3871 int pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, smax_x; 3872 WINDOW *pad; 3873 3874 if (check_arg_count(nargs, 7) == 1) 3875 return; 3876 3877 if (sscanf(args[0], "%p", &pad) == 0) { 3878 report_count(1); 3879 report_error("BAD ARGUMENT"); 3880 return; 3881 } 3882 3883 if (sscanf(args[1], "%d", &pbeg_y) == 0) { 3884 report_count(1); 3885 report_error("BAD ARGUMENT"); 3886 return; 3887 } 3888 3889 if (sscanf(args[2], "%d", &pbeg_x) == 0) { 3890 report_count(1); 3891 report_error("BAD ARGUMENT"); 3892 return; 3893 } 3894 3895 if (sscanf(args[3], "%d", &sbeg_y) == 0) { 3896 report_count(1); 3897 report_error("BAD ARGUMENT"); 3898 return; 3899 } 3900 3901 if (sscanf(args[4], "%d", &sbeg_x) == 0) { 3902 report_count(1); 3903 report_error("BAD ARGUMENT"); 3904 return; 3905 } 3906 3907 if (sscanf(args[5], "%d", &smax_y) == 0) { 3908 report_count(1); 3909 report_error("BAD ARGUMENT"); 3910 return; 3911 } 3912 3913 if (sscanf(args[6], "%d", &smax_x) == 0) { 3914 report_count(1); 3915 report_error("BAD ARGUMENT"); 3916 return; 3917 } 3918 3919 /* XXX causes refresh */ 3920 report_count(1); 3921 report_return(prefresh(pad, pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, 3922 smax_x)); 3923 3924 } 3925 3926 3927 void 3928 cmd_printw(int nargs, char **args) 3929 { 3930 if (check_arg_count(nargs, 2) == 1) 3931 return; 3932 3933 3934 report_count(1); 3935 report_return(printw(args[0], args[1])); 3936 } 3937 3938 3939 void 3940 cmd_putwin(int nargs, char **args) 3941 { 3942 FILE *fp; 3943 WINDOW *win; 3944 3945 if (check_arg_count(nargs, 2) == 1) 3946 return; 3947 3948 if (sscanf(args[0], "%p", &win) == 0) { 3949 report_count(1); 3950 report_error("BAD ARGUMENT"); 3951 return; 3952 } 3953 3954 if ((fp = fopen(args[1], "rw")) == NULL) { 3955 report_count(1); 3956 report_error("BAD FILE_ARGUMENT"); 3957 return; 3958 } 3959 3960 report_count(1); 3961 report_return(putwin(win, fp)); 3962 } 3963 3964 3965 void 3966 cmd_qiflush(int nargs, char **args) 3967 { 3968 if (check_arg_count(nargs, 0) == 1) 3969 return; 3970 3971 qiflush(); 3972 report_count(1); 3973 report_return(OK); /* fake a return because call returns void */ 3974 } 3975 3976 3977 void 3978 cmd_raw(int nargs, char **args) 3979 { 3980 if (check_arg_count(nargs, 0) == 1) 3981 return; 3982 3983 report_count(1); 3984 report_return(raw()); 3985 } 3986 3987 3988 void 3989 cmd_redrawwin(int nargs, char **args) 3990 { 3991 WINDOW *win; 3992 3993 if (check_arg_count(nargs, 1) == 1) 3994 return; 3995 3996 if (sscanf(args[0], "%p", &win) == 0) { 3997 report_count(1); 3998 report_error("BAD ARGUMENT"); 3999 return; 4000 } 4001 4002 report_count(1); 4003 report_return(redrawwin(win)); 4004 } 4005 4006 4007 void 4008 cmd_reset_prog_mode(int nargs, char **args) 4009 { 4010 if (check_arg_count(nargs, 0) == 1) 4011 return; 4012 4013 report_count(1); 4014 report_return(reset_prog_mode()); 4015 } 4016 4017 4018 void 4019 cmd_reset_shell_mode(int nargs, char **args) 4020 { 4021 if (check_arg_count(nargs, 0) == 1) 4022 return; 4023 4024 report_count(1); 4025 report_return(reset_shell_mode()); 4026 } 4027 4028 4029 void 4030 cmd_resetty(int nargs, char **args) 4031 { 4032 if (check_arg_count(nargs, 0) == 1) 4033 return; 4034 4035 report_count(1); 4036 report_return(resetty()); 4037 } 4038 4039 4040 void 4041 cmd_resizeterm(int nargs, char **args) 4042 { 4043 int rows, cols; 4044 4045 if (check_arg_count(nargs, 2) == 1) 4046 return; 4047 4048 if (sscanf(args[0], "%d", &rows) == 0) { 4049 report_count(1); 4050 report_error("BAD ARGUMENT"); 4051 return; 4052 } 4053 4054 if (sscanf(args[1], "%d", &cols) == 0) { 4055 report_count(1); 4056 report_error("BAD ARGUMENT"); 4057 return; 4058 } 4059 4060 report_count(1); 4061 report_return(resizeterm(rows, cols)); 4062 } 4063 4064 4065 void 4066 cmd_savetty(int nargs, char **args) 4067 { 4068 if (check_arg_count(nargs, 0) == 1) 4069 return; 4070 4071 report_count(1); 4072 report_return(savetty()); 4073 } 4074 4075 4076 void 4077 cmd_scanw(int nargs, char **args) 4078 { 4079 char string[256]; 4080 4081 if (check_arg_count(nargs, 0) == 1) 4082 return; 4083 4084 /* XXX call2 */ 4085 report_count(2); 4086 report_return(scanw("%s", string)); 4087 report_status(string); 4088 } 4089 4090 4091 void 4092 cmd_scroll(int nargs, char **args) 4093 { 4094 WINDOW *win; 4095 4096 if (check_arg_count(nargs, 1) == 1) 4097 return; 4098 4099 if (sscanf(args[0], "%p", &win) == 0) { 4100 report_count(1); 4101 report_error("BAD ARGUMENT"); 4102 return; 4103 } 4104 4105 report_count(1); 4106 report_return(scroll(win)); 4107 } 4108 4109 4110 void 4111 cmd_scrollok(int nargs, char **args) 4112 { 4113 WINDOW *win; 4114 int flag; 4115 4116 if (check_arg_count(nargs, 2) == 1) 4117 return; 4118 4119 if (sscanf(args[0], "%p", &win) == 0) { 4120 report_count(1); 4121 report_error("BAD ARGUMENT"); 4122 return; 4123 } 4124 4125 if (sscanf(args[1], "%d", &flag) == 0) { 4126 report_count(1); 4127 report_error("BAD ARGUMENT"); 4128 return; 4129 } 4130 4131 report_count(1); 4132 report_return(scrollok(win, flag)); 4133 } 4134 4135 4136 void 4137 cmd_setterm(int nargs, char **args) 4138 { 4139 if (check_arg_count(nargs, 1) == 1) 4140 return; 4141 4142 report_count(1); 4143 report_return(setterm(args[0])); 4144 } 4145 4146 4147 void 4148 cmd_set_term(int nargs, char **args) 4149 { 4150 SCREEN *scrn; 4151 4152 if (check_arg_count(nargs, 1) == 1) 4153 return; 4154 4155 if (sscanf(args[0], "%p", &scrn) == 0) { 4156 report_count(1); 4157 report_error("BAD ARGUMENT"); 4158 return; 4159 } 4160 4161 report_count(1); 4162 report_ptr(set_term(scrn)); 4163 } 4164 4165 4166 void 4167 cmd_start_color(int nargs, char **args) 4168 { 4169 if (check_arg_count(nargs, 0) == 1) 4170 return; 4171 4172 report_count(1); 4173 report_return(start_color()); 4174 } 4175 4176 4177 void 4178 cmd_subpad(int nargs, char **args) 4179 { 4180 WINDOW *pad; 4181 int lines, cols, begin_y, begin_x; 4182 4183 if (check_arg_count(nargs, 5) == 1) 4184 return; 4185 4186 if (sscanf(args[0], "%p", &pad) == 0) { 4187 report_count(1); 4188 report_error("BAD ARGUMENT"); 4189 return; 4190 } 4191 4192 if (sscanf(args[1], "%d", &lines) == 0) { 4193 report_count(1); 4194 report_error("BAD ARGUMENT"); 4195 return; 4196 } 4197 4198 if (sscanf(args[2], "%d", &cols) == 0) { 4199 report_count(1); 4200 report_error("BAD ARGUMENT"); 4201 return; 4202 } 4203 4204 if (sscanf(args[3], "%d", &begin_y) == 0) { 4205 report_count(1); 4206 report_error("BAD ARGUMENT"); 4207 return; 4208 } 4209 4210 if (sscanf(args[4], "%d", &begin_x) == 0) { 4211 report_count(1); 4212 report_error("BAD ARGUMENT"); 4213 return; 4214 } 4215 4216 report_count(1); 4217 report_ptr(subpad(pad, lines, cols, begin_y, begin_x)); 4218 } 4219 4220 4221 void 4222 cmd_subwin(int nargs, char **args) 4223 { 4224 WINDOW *win; 4225 int lines, cols, begin_y, begin_x; 4226 4227 if (check_arg_count(nargs, 5) == 1) 4228 return; 4229 4230 if (sscanf(args[0], "%p", &win) == 0) { 4231 report_count(1); 4232 report_error("BAD ARGUMENT"); 4233 return; 4234 } 4235 4236 if (sscanf(args[1], "%d", &lines) == 0) { 4237 report_count(1); 4238 report_error("BAD ARGUMENT"); 4239 return; 4240 } 4241 4242 if (sscanf(args[2], "%d", &cols) == 0) { 4243 report_count(1); 4244 report_error("BAD ARGUMENT"); 4245 return; 4246 } 4247 4248 if (sscanf(args[3], "%d", &begin_y) == 0) { 4249 report_count(1); 4250 report_error("BAD ARGUMENT"); 4251 return; 4252 } 4253 4254 if (sscanf(args[4], "%d", &begin_x) == 0) { 4255 report_count(1); 4256 report_error("BAD ARGUMENT"); 4257 return; 4258 } 4259 4260 report_count(1); 4261 report_ptr(subwin(win, lines, cols, begin_y, begin_x)); 4262 } 4263 4264 4265 void 4266 cmd_termattrs(int nargs, char **args) 4267 { 4268 if (check_arg_count(nargs, 0) == 1) 4269 return; 4270 4271 report_count(1); 4272 report_int(termattrs()); 4273 } 4274 4275 4276 void 4277 cmd_term_attrs(int nargs, char **args) 4278 { 4279 if (check_arg_count(nargs, 0) == 1) 4280 return; 4281 4282 report_count(1); 4283 report_int(term_attrs()); 4284 } 4285 4286 4287 void 4288 cmd_touchline(int nargs, char **args) 4289 { 4290 WINDOW *win; 4291 int start, count; 4292 4293 if (check_arg_count(nargs, 3) == 1) 4294 return; 4295 4296 if (sscanf(args[0], "%p", &win) == 0) { 4297 report_count(1); 4298 report_error("BAD ARGUMENT"); 4299 return; 4300 } 4301 4302 if (sscanf(args[1], "%d", &start) == 0) { 4303 report_count(1); 4304 report_error("BAD ARGUMENT"); 4305 return; 4306 } 4307 4308 if (sscanf(args[2], "%d", &count) == 0) { 4309 report_count(1); 4310 report_error("BAD ARGUMENT"); 4311 return; 4312 } 4313 4314 report_count(1); 4315 report_return(touchline(win, start, count)); 4316 } 4317 4318 4319 void 4320 cmd_touchoverlap(int nargs, char **args) 4321 { 4322 WINDOW *win1, *win2; 4323 4324 if (check_arg_count(nargs, 2) == 1) 4325 return; 4326 4327 if (sscanf(args[0], "%p", &win1) == 0) { 4328 report_count(1); 4329 report_error("BAD ARGUMENT"); 4330 return; 4331 } 4332 4333 if (sscanf(args[1], "%p", &win2) == 0) { 4334 report_count(1); 4335 report_error("BAD ARGUMENT"); 4336 return; 4337 } 4338 4339 report_count(1); 4340 report_return(touchoverlap(win1, win2)); 4341 } 4342 4343 4344 void 4345 cmd_touchwin(int nargs, char **args) 4346 { 4347 WINDOW *win; 4348 4349 if (check_arg_count(nargs, 1) == 1) 4350 return; 4351 4352 if (sscanf(args[0], "%p", &win) == 0) { 4353 report_count(1); 4354 report_error("BAD ARGUMENT"); 4355 return; 4356 } 4357 4358 report_count(1); 4359 report_return(touchwin(win)); 4360 } 4361 4362 4363 void 4364 cmd_ungetch(int nargs, char **args) 4365 { 4366 int ch; 4367 4368 if (check_arg_count(nargs, 1) == 1) 4369 return; 4370 4371 if (sscanf(args[0], "%d", &ch) == 0) { 4372 report_count(1); 4373 report_error("BAD ARGUMENT"); 4374 return; 4375 } 4376 4377 report_count(1); 4378 report_return(ungetch(ch)); 4379 } 4380 4381 4382 void 4383 cmd_untouchwin(int nargs, char **args) 4384 { 4385 WINDOW *win; 4386 4387 if (check_arg_count(nargs, 1) == 1) 4388 return; 4389 4390 if (sscanf(args[0], "%p", &win) == 0) { 4391 report_count(1); 4392 report_error("BAD ARGUMENT"); 4393 return; 4394 } 4395 4396 report_count(1); 4397 report_return(untouchwin(win)); 4398 } 4399 4400 4401 void 4402 cmd_use_default_colors(int nargs, char **args) 4403 { 4404 if (check_arg_count(nargs, 0) == 1) 4405 return; 4406 4407 report_count(1); 4408 report_return(use_default_colors()); 4409 } 4410 4411 4412 void 4413 cmd_vline(int nargs, char **args) 4414 { 4415 int count; 4416 chtype *ch; 4417 4418 if (check_arg_count(nargs, 2) == 1) 4419 return; 4420 4421 ch = (chtype *) args[0]; 4422 4423 if (sscanf(args[1], "%d", &count) == 0) { 4424 report_count(1); 4425 report_error("BAD ARGUMENT"); 4426 return; 4427 } 4428 4429 report_count(1); 4430 report_return(vline(ch[0], count)); 4431 } 4432 4433 4434 static int 4435 internal_vw_printw(WINDOW *win, char *arg1, ...) 4436 { 4437 va_list va; 4438 int rv; 4439 4440 va_start(va, arg1); 4441 rv = vw_printw(win, arg1, va); 4442 va_end(va); 4443 4444 return rv; 4445 } 4446 4447 void 4448 cmd_vw_printw(int nargs, char **args) 4449 { 4450 WINDOW *win; 4451 4452 if (check_arg_count(nargs, 3) == 1) 4453 return; 4454 4455 if (sscanf(args[0], "%p", &win) == 0) { 4456 report_count(1); 4457 report_error("BAD ARGUMENT"); 4458 return; 4459 } 4460 4461 report_count(1); 4462 report_return(internal_vw_printw(win, args[1], args[2])); 4463 } 4464 4465 4466 static int 4467 internal_vw_scanw(WINDOW *win, char *arg1, ...) 4468 { 4469 va_list va; 4470 int rv; 4471 4472 va_start(va, arg1); 4473 rv = vw_scanw(win, arg1, va); 4474 va_end(va); 4475 4476 return rv; 4477 } 4478 4479 void 4480 cmd_vw_scanw(int nargs, char **args) 4481 { 4482 WINDOW *win; 4483 char string[256]; 4484 4485 if (check_arg_count(nargs, 2) == 1) 4486 return; 4487 4488 if (sscanf(args[0], "%p", &win) == 0) { 4489 report_count(1); 4490 report_error("BAD ARGUMENT"); 4491 return; 4492 } 4493 4494 /* XXX - call2 */ 4495 report_count(2); 4496 report_int(internal_vw_scanw(win, args[1], string)); 4497 report_status(string); 4498 } 4499 4500 4501 void 4502 cmd_vwprintw(int nargs, char **args) 4503 { 4504 cmd_vw_printw(nargs, args); 4505 } 4506 4507 4508 void 4509 cmd_vwscanw(int nargs, char **args) 4510 { 4511 cmd_vw_scanw(nargs, args); 4512 } 4513 4514 4515 void 4516 cmd_waddch(int nargs, char **args) 4517 { 4518 WINDOW *win; 4519 chtype *ch; 4520 4521 if (check_arg_count(nargs, 2) == 1) 4522 return; 4523 4524 if (sscanf(args[0], "%p", &win) == 0) { 4525 report_count(1); 4526 report_error("BAD ARGUMENT"); 4527 return; 4528 } 4529 4530 ch = (chtype *) args[1]; 4531 4532 report_count(1); 4533 report_return(waddch(win, ch[0])); 4534 } 4535 4536 4537 void 4538 cmd_waddchnstr(int nargs, char **args) 4539 { 4540 WINDOW *win; 4541 int count; 4542 4543 if (check_arg_count(nargs, 3) == 1) 4544 return; 4545 4546 if (sscanf(args[0], "%p", &win) == 0) { 4547 report_count(1); 4548 report_error("BAD ARGUMENT"); 4549 return; 4550 } 4551 4552 if (sscanf(args[2], "%d", &count) == 0) { 4553 report_count(1); 4554 report_error("BAD ARGUMENT"); 4555 return; 4556 } 4557 4558 report_count(1); 4559 report_return(waddchnstr(win, (chtype *) args[1], count)); 4560 } 4561 4562 4563 void 4564 cmd_waddchstr(int nargs, char **args) 4565 { 4566 WINDOW *win; 4567 4568 if (check_arg_count(nargs, 2) == 1) 4569 return; 4570 4571 if (sscanf(args[0], "%p", &win) == 0) { 4572 report_count(1); 4573 report_error("BAD ARGUMENT"); 4574 return; 4575 } 4576 4577 report_count(1); 4578 report_return(waddchstr(win, (chtype *) args[1])); 4579 } 4580 4581 4582 void 4583 cmd_waddnstr(int nargs, char **args) 4584 { 4585 WINDOW *win; 4586 int count; 4587 4588 if (check_arg_count(nargs, 1) == 3) 4589 return; 4590 4591 if (sscanf(args[0], "%p", &win) == 0) { 4592 report_count(1); 4593 report_error("BAD ARGUMENT"); 4594 return; 4595 } 4596 4597 if (sscanf(args[2], "%d", &count) == 0) { 4598 report_count(1); 4599 report_error("BAD ARGUMENT"); 4600 return; 4601 } 4602 4603 report_count(1); 4604 report_return(waddnstr(win, args[1], count)); 4605 4606 } 4607 4608 4609 void 4610 cmd_wattr_get(int nargs, char **args) 4611 { 4612 WINDOW *win; 4613 int attr; 4614 short pair; 4615 4616 if (check_arg_count(nargs, 1) == 1) 4617 return; 4618 4619 if (sscanf(args[0], "%p", &win) == 0) { 4620 report_count(1); 4621 report_error("BAD ARGUMENT"); 4622 return; 4623 } 4624 4625 /* XXX - call3 */ 4626 report_count(3); 4627 report_return(wattr_get(win, &attr, &pair, NULL)); 4628 report_int(attr); 4629 report_int(pair); 4630 } 4631 4632 4633 void 4634 cmd_wattr_off(int nargs, char **args) 4635 { 4636 WINDOW *win; 4637 int attr; 4638 4639 if (check_arg_count(nargs, 2) == 1) 4640 return; 4641 4642 if (sscanf(args[0], "%p", &win) == 0) { 4643 report_count(1); 4644 report_error("BAD ARGUMENT"); 4645 return; 4646 } 4647 4648 if (sscanf(args[1], "%d", &attr) == 0) { 4649 report_count(1); 4650 report_error("BAD ARGUMENT"); 4651 return; 4652 } 4653 4654 report_count(1); 4655 report_return(wattr_off(win, attr, NULL)); 4656 } 4657 4658 4659 void 4660 cmd_wattr_on(int nargs, char **args) 4661 { 4662 WINDOW *win; 4663 int attr; 4664 4665 if (check_arg_count(nargs, 2) == 1) 4666 return; 4667 4668 if (sscanf(args[0], "%p", &win) == 0) { 4669 report_count(1); 4670 report_error("BAD ARGUMENT"); 4671 return; 4672 } 4673 4674 if (sscanf(args[1], "%d", &attr) == 0) { 4675 report_count(1); 4676 report_error("BAD ARGUMENT"); 4677 return; 4678 } 4679 4680 report_count(1); 4681 report_return(wattr_on(win, attr, NULL)); 4682 } 4683 4684 4685 void 4686 cmd_wattr_set(int nargs, char **args) 4687 { 4688 WINDOW *win; 4689 int attr; 4690 short pair; 4691 4692 if (check_arg_count(nargs, 3) == 1) 4693 return; 4694 4695 if (sscanf(args[0], "%p", &win) == 0) { 4696 report_count(1); 4697 report_error("BAD ARGUMENT"); 4698 return; 4699 } 4700 4701 if (sscanf(args[1], "%d", &attr) == 0) { 4702 report_count(1); 4703 report_error("BAD ARGUMENT"); 4704 return; 4705 } 4706 4707 if (sscanf(args[2], "%hd", &pair) == 0) { 4708 report_count(1); 4709 report_error("BAD ARGUMENT"); 4710 return; 4711 } 4712 4713 report_count(1); 4714 report_return(wattr_set(win, attr, pair, NULL)); 4715 } 4716 4717 4718 void 4719 cmd_wattroff(int nargs, char **args) 4720 { 4721 WINDOW *win; 4722 int attr; 4723 4724 if (check_arg_count(nargs, 2) == 1) 4725 return; 4726 4727 if (sscanf(args[0], "%p", &win) == 0) { 4728 report_count(1); 4729 report_error("BAD ARGUMENT"); 4730 return; 4731 } 4732 4733 if (sscanf(args[1], "%d", &attr) == 0) { 4734 report_count(1); 4735 report_error("BAD ARGUMENT"); 4736 return; 4737 } 4738 4739 report_count(1); 4740 report_return(wattroff(win, attr)); 4741 } 4742 4743 4744 void 4745 cmd_wattron(int nargs, char **args) 4746 { 4747 WINDOW *win; 4748 int attr; 4749 4750 if (check_arg_count(nargs, 2) == 1) 4751 return; 4752 4753 if (sscanf(args[0], "%p", &win) == 0) { 4754 report_count(1); 4755 report_error("BAD ARGUMENT"); 4756 return; 4757 } 4758 4759 if (sscanf(args[1], "%d", &attr) == 0) { 4760 report_count(1); 4761 report_error("BAD ARGUMENT"); 4762 return; 4763 } 4764 4765 report_count(1); 4766 report_return(wattron(win, attr)); 4767 } 4768 4769 4770 void 4771 cmd_wattrset(int nargs, char **args) 4772 { 4773 WINDOW *win; 4774 int attr; 4775 4776 if (check_arg_count(nargs, 2) == 1) 4777 return; 4778 4779 if (sscanf(args[0], "%p", &win) == 0) { 4780 report_count(1); 4781 report_error("BAD ARGUMENT"); 4782 return; 4783 } 4784 4785 if (sscanf(args[1], "%d", &attr) == 0) { 4786 report_count(1); 4787 report_error("BAD ARGUMENT"); 4788 return; 4789 } 4790 4791 report_count(1); 4792 report_return(wattrset(win, attr)); 4793 } 4794 4795 4796 void 4797 cmd_wbkgd(int nargs, char **args) 4798 { 4799 WINDOW *win; 4800 chtype *ch; 4801 4802 if (check_arg_count(nargs, 2) == 1) 4803 return; 4804 4805 if (sscanf(args[0], "%p", &win) == 0) { 4806 report_count(1); 4807 report_error("BAD ARGUMENT"); 4808 return; 4809 } 4810 4811 ch = (chtype *) args[1]; 4812 report_count(1); 4813 report_return(wbkgd(win, ch[0])); 4814 } 4815 4816 4817 void 4818 cmd_wbkgdset(int nargs, char **args) 4819 { 4820 WINDOW *win; 4821 int ch; 4822 4823 if (check_arg_count(nargs, 2) == 1) 4824 return; 4825 4826 if (sscanf(args[0], "%p", &win) == 0) { 4827 report_count(1); 4828 report_error("BAD ARGUMENT"); 4829 return; 4830 } 4831 4832 if (sscanf(args[1], "%d", &ch) == 0) { 4833 report_count(1); 4834 report_error("BAD ARGUMENT"); 4835 return; 4836 } 4837 4838 wbkgdset(win, ch); /* void return */ 4839 report_count(1); 4840 report_return(OK); 4841 } 4842 4843 4844 void 4845 cmd_wborder(int nargs, char **args) 4846 { 4847 WINDOW *win; 4848 int ls, rs, ts, bs, tl, tr, bl, br; 4849 4850 if (check_arg_count(nargs, 9) == 1) 4851 return; 4852 4853 if (sscanf(args[0], "%p", &win) == 0) { 4854 report_count(1); 4855 report_error("BAD ARGUMENT"); 4856 return; 4857 } 4858 4859 if (sscanf(args[1], "%d", &ls) == 0) { 4860 report_count(1); 4861 report_error("BAD ARGUMENT"); 4862 return; 4863 } 4864 4865 if (sscanf(args[2], "%d", &rs) == 0) { 4866 report_count(1); 4867 report_error("BAD ARGUMENT"); 4868 return; 4869 } 4870 4871 if (sscanf(args[3], "%d", &ts) == 0) { 4872 report_count(1); 4873 report_error("BAD ARGUMENT"); 4874 return; 4875 } 4876 4877 if (sscanf(args[4], "%d", &bs) == 0) { 4878 report_count(1); 4879 report_error("BAD ARGUMENT"); 4880 return; 4881 } 4882 4883 if (sscanf(args[5], "%d", &tl) == 0) { 4884 report_count(1); 4885 report_error("BAD ARGUMENT"); 4886 return; 4887 } 4888 4889 if (sscanf(args[6], "%d", &tr) == 0) { 4890 report_count(1); 4891 report_error("BAD ARGUMENT"); 4892 return; 4893 } 4894 4895 if (sscanf(args[7], "%d", &bl) == 0) { 4896 report_count(1); 4897 report_error("BAD ARGUMENT"); 4898 return; 4899 } 4900 4901 if (sscanf(args[8], "%d", &br) == 0) { 4902 report_count(1); 4903 report_error("BAD ARGUMENT"); 4904 return; 4905 } 4906 4907 report_count(1); 4908 report_return(wborder(win, ls, rs, ts, bs, tl, tr, bl, br)); 4909 } 4910 4911 4912 void 4913 cmd_wclear(int nargs, char **args) 4914 { 4915 WINDOW *win; 4916 4917 if (check_arg_count(nargs, 1) == 1) 4918 return; 4919 4920 if (sscanf(args[0], "%p", &win) == 0) { 4921 report_count(1); 4922 report_error("BAD ARGUMENT"); 4923 return; 4924 } 4925 4926 report_count(1); 4927 report_return(wclear(win)); 4928 } 4929 4930 4931 void 4932 cmd_wclrtobot(int nargs, char **args) 4933 { 4934 WINDOW *win; 4935 4936 if (check_arg_count(nargs, 1) == 1) 4937 return; 4938 4939 if (sscanf(args[0], "%p", &win) == 0) { 4940 report_count(1); 4941 report_error("BAD ARGUMENT"); 4942 return; 4943 } 4944 4945 report_count(1); 4946 report_return(wclrtobot(win)); 4947 } 4948 4949 4950 void 4951 cmd_wclrtoeol(int nargs, char **args) 4952 { 4953 WINDOW *win; 4954 4955 if (check_arg_count(nargs, 1) == 1) 4956 return; 4957 4958 if (sscanf(args[0], "%p", &win) == 0) { 4959 report_count(1); 4960 report_error("BAD ARGUMENT"); 4961 return; 4962 } 4963 4964 report_count(1); 4965 report_return(wclrtoeol(win)); 4966 4967 } 4968 4969 4970 void 4971 cmd_wcolor_set(int nargs, char **args) 4972 { 4973 WINDOW *win; 4974 short pair; 4975 4976 if (check_arg_count(nargs, 2) == 1) 4977 return; 4978 4979 if (sscanf(args[0], "%p", &win) == 0) { 4980 report_count(1); 4981 report_error("BAD ARGUMENT"); 4982 return; 4983 } 4984 4985 if (sscanf(args[1], "%hd", &pair) == 0) { 4986 report_count(1); 4987 report_error("BAD ARGUMENT"); 4988 return; 4989 } 4990 4991 report_count(1); 4992 report_return(wcolor_set(win, pair, NULL)); 4993 } 4994 4995 4996 void 4997 cmd_wdelch(int nargs, char **args) 4998 { 4999 WINDOW *win; 5000 5001 if (check_arg_count(nargs, 1) == 1) 5002 return; 5003 5004 if (sscanf(args[0], "%p", &win) == 0) { 5005 report_count(1); 5006 report_error("BAD ARGUMENT"); 5007 return; 5008 } 5009 5010 report_count(1); 5011 report_return(wdelch(win)); 5012 } 5013 5014 5015 void 5016 cmd_wdeleteln(int nargs, char **args) 5017 { 5018 WINDOW *win; 5019 5020 if (check_arg_count(nargs, 1) == 1) 5021 return; 5022 5023 if (sscanf(args[0], "%p", &win) == 0) { 5024 report_count(1); 5025 report_error("BAD ARGUMENT"); 5026 return; 5027 } 5028 5029 report_count(1); 5030 report_return(wdeleteln(win)); 5031 5032 } 5033 5034 5035 void 5036 cmd_wechochar(int nargs, char **args) 5037 { 5038 WINDOW *win; 5039 int ch; 5040 5041 if (check_arg_count(nargs, 2) == 1) 5042 return; 5043 5044 if (sscanf(args[0], "%p", &win) == 0) { 5045 report_count(1); 5046 report_error("BAD ARGUMENT"); 5047 return; 5048 } 5049 5050 if (sscanf(args[1], "%d", &ch) == 0) { 5051 report_count(1); 5052 report_error("BAD ARGUMENT"); 5053 return; 5054 } 5055 5056 report_count(1); 5057 report_return(wechochar(win, ch)); 5058 } 5059 5060 5061 void 5062 cmd_werase(int nargs, char **args) 5063 { 5064 WINDOW *win; 5065 5066 if (check_arg_count(nargs, 1) == 1) 5067 return; 5068 5069 if (sscanf(args[0], "%p", &win) == 0) { 5070 report_count(1); 5071 report_error("BAD ARGUMENT"); 5072 return; 5073 } 5074 5075 report_count(1); 5076 report_return(werase(win)); 5077 } 5078 5079 5080 void 5081 cmd_wgetch(int nargs, char **args) 5082 { 5083 WINDOW *win; 5084 5085 if (check_arg_count(nargs, 1) == 1) 5086 return; 5087 5088 if (sscanf(args[0], "%p", &win) == 0) { 5089 report_count(1); 5090 report_error("BAD ARGUMENT"); 5091 return; 5092 } 5093 5094 report_count(1); 5095 report_int(wgetch(win)); 5096 } 5097 5098 5099 void 5100 cmd_wgetnstr(int nargs, char **args) 5101 { 5102 WINDOW *win; 5103 int count; 5104 char string[256]; 5105 5106 if (check_arg_count(nargs, 2) == 1) 5107 return; 5108 5109 if (sscanf(args[0], "%p", &win) == 0) { 5110 report_count(1); 5111 report_error("BAD ARGUMENT"); 5112 return; 5113 } 5114 5115 if (sscanf(args[1], "%d", &count) == 0) { 5116 report_count(1); 5117 report_error("BAD ARGUMENT"); 5118 return; 5119 } 5120 5121 /* XXX - call2 */ 5122 report_count(2); 5123 report_return(wgetnstr(win, string, count)); 5124 report_status(string); 5125 } 5126 5127 5128 void 5129 cmd_wgetstr(int nargs, char **args) 5130 { 5131 WINDOW *win; 5132 char string[256]; 5133 5134 5135 if (check_arg_count(nargs, 1) == 1) 5136 return; 5137 5138 if (sscanf(args[0], "%p", &win) == 0) { 5139 report_count(1); 5140 report_error("BAD ARGUMENT"); 5141 return; 5142 } 5143 5144 string[0] = '\0'; 5145 5146 report_count(2); 5147 report_return(wgetstr(win, string)); 5148 report_status(string); 5149 } 5150 5151 5152 void 5153 cmd_whline(int nargs, char **args) 5154 { 5155 WINDOW *win; 5156 int ch, count; 5157 5158 if (check_arg_count(nargs, 3) == 1) 5159 return; 5160 5161 if (sscanf(args[0], "%p", &win) == 0) { 5162 report_count(1); 5163 report_error("BAD ARGUMENT"); 5164 return; 5165 } 5166 5167 if (sscanf(args[1], "%d", &ch) == 0) { 5168 report_count(1); 5169 report_error("BAD ARGUMENT"); 5170 return; 5171 } 5172 5173 if (sscanf(args[2], "%d", &count) == 0) { 5174 report_count(1); 5175 report_error("BAD ARGUMENT"); 5176 return; 5177 } 5178 5179 report_count(1); 5180 report_return(whline(win, ch, count)); 5181 } 5182 5183 5184 void 5185 cmd_winch(int nargs, char **args) 5186 { 5187 WINDOW *win; 5188 5189 if (check_arg_count(nargs, 1) == 1) 5190 return; 5191 5192 if (sscanf(args[0], "%p", &win) == 0) { 5193 report_count(1); 5194 report_error("BAD ARGUMENT"); 5195 return; 5196 } 5197 5198 report_count(1); 5199 report_int(winch(win)); 5200 } 5201 5202 5203 void 5204 cmd_winchnstr(int nargs, char **args) 5205 { 5206 WINDOW *win; 5207 chtype string[256]; 5208 int count; 5209 5210 if (check_arg_count(nargs, 2) == 1) 5211 return; 5212 5213 if (sscanf(args[0], "%p", &win) == 0) { 5214 report_count(1); 5215 report_error("BAD ARGUMENT"); 5216 return; 5217 } 5218 5219 if (sscanf(args[1], "%d", &count) == 0) { 5220 report_count(1); 5221 report_error("BAD ARGUMENT"); 5222 return; 5223 } 5224 5225 /* XXX - call2 */ 5226 report_count(2); 5227 report_return(winchnstr(win, string, count)); 5228 report_nstr(string); 5229 } 5230 5231 5232 void 5233 cmd_winchstr(int nargs, char **args) 5234 { 5235 WINDOW *win; 5236 chtype string[256]; 5237 5238 if (check_arg_count(nargs, 1) == 1) 5239 return; 5240 5241 if (sscanf(args[0], "%p", &win) == 0) { 5242 report_count(1); 5243 report_error("BAD ARGUMENT"); 5244 return; 5245 } 5246 5247 /* XXX - call2 */ 5248 report_count(2); 5249 report_return(winchstr(win, string)); 5250 report_nstr(string); 5251 } 5252 5253 5254 void 5255 cmd_winnstr(int nargs, char **args) 5256 { 5257 WINDOW *win; 5258 char string[256]; 5259 int count; 5260 5261 if (check_arg_count(nargs, 2) == 1) 5262 return; 5263 5264 if (sscanf(args[0], "%p", &win) == 0) { 5265 report_count(1); 5266 report_error("BAD ARGUMENT"); 5267 return; 5268 } 5269 5270 if (sscanf(args[1], "%d", &count) == 0) { 5271 report_count(1); 5272 report_error("BAD ARGUMENT"); 5273 return; 5274 } 5275 5276 /* XXX - call2 */ 5277 report_count(2); 5278 report_return(winnstr(win, string, count)); 5279 report_status(string); 5280 } 5281 5282 5283 void 5284 cmd_winsch(int nargs, char **args) 5285 { 5286 WINDOW *win; 5287 int ch; 5288 5289 if (check_arg_count(nargs, 2) == 1) 5290 return; 5291 5292 if (sscanf(args[0], "%p", &win) == 0) { 5293 report_count(1); 5294 report_error("BAD ARGUMENT"); 5295 return; 5296 } 5297 5298 if (sscanf(args[1], "%d", &ch) == 0) { 5299 report_count(1); 5300 report_error("BAD ARGUMENT"); 5301 return; 5302 } 5303 5304 report_count(1); 5305 report_return(winsch(win, ch)); 5306 } 5307 5308 5309 void 5310 cmd_winsdelln(int nargs, char **args) 5311 { 5312 WINDOW *win; 5313 int count; 5314 5315 if (check_arg_count(nargs, 2) == 1) 5316 return; 5317 5318 if (sscanf(args[0], "%p", &win) == 0) { 5319 report_count(1); 5320 report_error("BAD ARGUMENT"); 5321 return; 5322 } 5323 5324 if (sscanf(args[1], "%d", &count) == 0) { 5325 report_count(1); 5326 report_error("BAD ARGUMENT"); 5327 return; 5328 } 5329 5330 report_count(1); 5331 report_return(winsdelln(win, count)); 5332 } 5333 5334 5335 void 5336 cmd_winsertln(int nargs, char **args) 5337 { 5338 WINDOW *win; 5339 5340 if (check_arg_count(nargs, 1) == 1) 5341 return; 5342 5343 if (sscanf(args[0], "%p", &win) == 0) { 5344 report_count(1); 5345 report_error("BAD ARGUMENT"); 5346 return; 5347 } 5348 5349 report_count(1); 5350 report_return(winsertln(win)); 5351 } 5352 5353 5354 void 5355 cmd_winstr(int nargs, char **args) 5356 { 5357 WINDOW *win; 5358 char string[256]; 5359 5360 if (check_arg_count(nargs, 1) == 1) 5361 return; 5362 5363 if (sscanf(args[0], "%p", &win) == 0) { 5364 report_count(1); 5365 report_error("BAD ARGUMENT"); 5366 return; 5367 } 5368 5369 /* XXX - call2 */ 5370 report_count(2); 5371 report_return(winstr(win, string)); 5372 report_status(string); 5373 } 5374 5375 5376 void 5377 cmd_wmove(int nargs, char **args) 5378 { 5379 WINDOW *win; 5380 int y, x; 5381 5382 if (check_arg_count(nargs, 3) == 1) 5383 return; 5384 5385 if (sscanf(args[0], "%p", &win) == 0) { 5386 report_count(1); 5387 report_error("BAD ARGUMENT"); 5388 return; 5389 } 5390 5391 if (sscanf(args[1], "%d", &y) == 0) { 5392 report_count(1); 5393 report_error("BAD ARGUMENT"); 5394 return; 5395 } 5396 5397 if (sscanf(args[2], "%d", &x) == 0) { 5398 report_count(1); 5399 report_error("BAD ARGUMENT"); 5400 return; 5401 } 5402 5403 report_count(1); 5404 report_return(wmove(win, y, x)); 5405 } 5406 5407 5408 void 5409 cmd_wnoutrefresh(int nargs, char **args) 5410 { 5411 WINDOW *win; 5412 5413 if (check_arg_count(nargs, 1) == 1) 5414 return; 5415 5416 if (sscanf(args[0], "%p", &win) == 0) { 5417 report_count(1); 5418 report_error("BAD ARGUMENT"); 5419 return; 5420 } 5421 5422 report_count(1); 5423 report_return(wnoutrefresh(win)); 5424 } 5425 5426 5427 void 5428 cmd_wprintw(int nargs, char **args) 5429 { 5430 WINDOW *win; 5431 5432 if (check_arg_count(nargs, 3) == 1) 5433 return; 5434 5435 if (sscanf(args[0], "%p", &win) == 0) { 5436 report_count(1); 5437 report_error("BAD ARGUMENT"); 5438 return; 5439 } 5440 5441 report_count(1); 5442 report_return(wprintw(win, args[1], args[2])); 5443 } 5444 5445 5446 void 5447 cmd_wredrawln(int nargs, char **args) 5448 { 5449 WINDOW *win; 5450 int beg_line, num_lines; 5451 5452 if (check_arg_count(nargs, 3) == 1) 5453 return; 5454 5455 if (sscanf(args[0], "%p", &win) == 0) { 5456 report_count(1); 5457 report_error("BAD ARGUMENT"); 5458 return; 5459 } 5460 5461 if (sscanf(args[1], "%d", &beg_line) == 0) { 5462 report_count(1); 5463 report_error("BAD ARGUMENT"); 5464 return; 5465 } 5466 5467 if (sscanf(args[2], "%d", &num_lines) == 0) { 5468 report_count(1); 5469 report_error("BAD ARGUMENT"); 5470 return; 5471 } 5472 5473 report_count(1); 5474 report_return(wredrawln(win, beg_line, num_lines)); 5475 } 5476 5477 5478 void 5479 cmd_wrefresh(int nargs, char **args) 5480 { 5481 WINDOW *win; 5482 5483 if (check_arg_count(nargs, 1) == 1) 5484 return; 5485 5486 if (sscanf(args[0], "%p", &win) == 0) { 5487 report_count(1); 5488 report_error("BAD ARGUMENT"); 5489 return; 5490 } 5491 5492 /* XXX - generates output */ 5493 report_count(1); 5494 report_return(wrefresh(win)); 5495 } 5496 5497 5498 void 5499 cmd_wresize(int nargs, char **args) 5500 { 5501 WINDOW *win; 5502 int lines, cols; 5503 5504 if (check_arg_count(nargs, 3) == 1) 5505 return; 5506 5507 if (sscanf(args[0], "%p", &win) == 0) { 5508 report_count(1); 5509 report_error("BAD ARGUMENT"); 5510 return; 5511 } 5512 5513 if (sscanf(args[1], "%d", &lines) == 0) { 5514 report_count(1); 5515 report_error("BAD ARGUMENT"); 5516 return; 5517 } 5518 5519 if (sscanf(args[2], "%d", &cols) == 0) { 5520 report_count(1); 5521 report_error("BAD ARGUMENT"); 5522 return; 5523 } 5524 5525 report_count(1); 5526 report_return(wresize(win, lines, cols)); 5527 } 5528 5529 5530 void 5531 cmd_wscanw(int nargs, char **args) 5532 { 5533 WINDOW *win; 5534 char string[256]; 5535 5536 if (check_arg_count(nargs, 2) == 1) 5537 return; 5538 5539 if (sscanf(args[0], "%p", &win) == 0) { 5540 report_count(1); 5541 report_error("BAD ARGUMENT"); 5542 return; 5543 } 5544 5545 report_count(1); 5546 report_return(wscanw(win, args[1], &string)); 5547 } 5548 5549 5550 void 5551 cmd_wscrl(int nargs, char **args) 5552 { 5553 WINDOW *win; 5554 int n; 5555 5556 if (check_arg_count(nargs, 2) == 1) 5557 return; 5558 5559 if (sscanf(args[0], "%p", &win) == 0) { 5560 report_count(1); 5561 report_error("BAD ARGUMENT"); 5562 return; 5563 } 5564 5565 if (sscanf(args[1], "%d", &n) == 0) { 5566 report_count(1); 5567 report_error("BAD ARGUMENT"); 5568 return; 5569 } 5570 5571 report_count(1); 5572 report_return(wscrl(win, n)); 5573 } 5574 5575 5576 void 5577 cmd_wsetscrreg(int nargs, char **args) 5578 { 5579 WINDOW *win; 5580 int top, bottom; 5581 5582 if (check_arg_count(nargs, 3) == 1) 5583 return; 5584 5585 if (sscanf(args[0], "%p", &win) == 0) { 5586 report_count(1); 5587 report_error("BAD ARGUMENT"); 5588 return; 5589 } 5590 5591 if (sscanf(args[1], "%d", &top) == 0) { 5592 report_count(1); 5593 report_error("BAD ARGUMENT"); 5594 return; 5595 } 5596 5597 if (sscanf(args[2], "%d", &bottom) == 0) { 5598 report_count(1); 5599 report_error("BAD ARGUMENT"); 5600 return; 5601 } 5602 5603 report_count(1); 5604 report_return(wsetscrreg(win, top, bottom)); 5605 } 5606 5607 5608 void 5609 cmd_wstandend(int nargs, char **args) 5610 { 5611 WINDOW *win; 5612 5613 if (check_arg_count(nargs, 1) == 1) 5614 return; 5615 5616 if (sscanf(args[0], "%p", &win) == 0) { 5617 report_count(1); 5618 report_error("BAD ARGUMENT"); 5619 return; 5620 } 5621 5622 report_count(1); 5623 report_return(wstandend(win)); 5624 } 5625 5626 5627 void 5628 cmd_wstandout(int nargs, char **args) 5629 { 5630 WINDOW *win; 5631 5632 if (check_arg_count(nargs, 1) == 1) 5633 return; 5634 5635 if (sscanf(args[0], "%p", &win) == 0) { 5636 report_count(1); 5637 report_error("BAD ARGUMENT"); 5638 return; 5639 } 5640 5641 report_count(1); 5642 report_return(wstandout(win)); 5643 } 5644 5645 5646 void 5647 cmd_wtimeout(int nargs, char **args) 5648 { 5649 WINDOW *win; 5650 int tval; 5651 5652 if (check_arg_count(nargs, 2) == 1) 5653 return; 5654 5655 if (sscanf(args[0], "%p", &win) == 0) { 5656 report_count(1); 5657 report_error("BAD ARGUMENT"); 5658 return; 5659 } 5660 5661 if (sscanf(args[1], "%d", &tval) == 0) { 5662 report_count(1); 5663 report_error("BAD ARGUMENT"); 5664 return; 5665 } 5666 5667 wtimeout(win, tval); /* void return */ 5668 report_count(1); 5669 report_return(OK); 5670 } 5671 5672 5673 void 5674 cmd_wtouchln(int nargs, char **args) 5675 { 5676 WINDOW *win; 5677 int line, n, changed; 5678 5679 if (check_arg_count(nargs, 4) == 1) 5680 return; 5681 5682 if (sscanf(args[0], "%p", &win) == 0) { 5683 report_count(1); 5684 report_error("BAD ARGUMENT"); 5685 return; 5686 } 5687 5688 if (sscanf(args[1], "%d", &line) == 0) { 5689 report_count(1); 5690 report_error("BAD ARGUMENT"); 5691 return; 5692 } 5693 5694 if (sscanf(args[2], "%d", &n) == 0) { 5695 report_count(1); 5696 report_error("BAD ARGUMENT"); 5697 return; 5698 } 5699 5700 if (sscanf(args[3], "%d", &changed) == 0) { 5701 report_count(1); 5702 report_error("BAD ARGUMENT"); 5703 return; 5704 } 5705 5706 report_count(1); 5707 report_return(wtouchln(win, line, n, changed)); 5708 } 5709 5710 5711 void 5712 cmd_wunderend(int nargs, char **args) 5713 { 5714 WINDOW *win; 5715 5716 if (check_arg_count(nargs, 1) == 1) 5717 return; 5718 5719 if (sscanf(args[0], "%p", &win) == 0) { 5720 report_count(1); 5721 report_error("BAD ARGUMENT"); 5722 return; 5723 } 5724 5725 report_count(1); 5726 report_return(wunderend(win)); 5727 } 5728 5729 5730 void 5731 cmd_wunderscore(int nargs, char **args) 5732 { 5733 WINDOW *win; 5734 5735 if (check_arg_count(nargs, 1) == 1) 5736 return; 5737 5738 if (sscanf(args[0], "%p", &win) == 0) { 5739 report_count(1); 5740 report_error("BAD ARGUMENT"); 5741 return; 5742 } 5743 5744 report_count(1); 5745 report_return(wunderscore(win)); 5746 } 5747 5748 5749 void 5750 cmd_wvline(int nargs, char **args) 5751 { 5752 WINDOW *win; 5753 int n; 5754 chtype *ch; 5755 5756 if (check_arg_count(nargs, 3) == 1) 5757 return; 5758 5759 if (sscanf(args[0], "%p", &win) == 0) { 5760 report_count(1); 5761 report_error("BAD ARGUMENT"); 5762 return; 5763 } 5764 5765 ch = (chtype *) args[1]; 5766 5767 if (sscanf(args[2], "%d", &n) == 0) { 5768 report_count(1); 5769 report_error("BAD ARGUMENT"); 5770 return; 5771 } 5772 5773 report_count(1); 5774 report_return(wvline(win, ch[0], n)); 5775 } 5776 5777 5778 void 5779 cmd_insnstr(int nargs, char **args) 5780 { 5781 int n; 5782 5783 if (check_arg_count(nargs, 2) == 1) 5784 return; 5785 5786 if (sscanf(args[1], "%d", &n) == 0) { 5787 report_count(1); 5788 report_error("BAD ARGUMENT"); 5789 return; 5790 } 5791 5792 report_count(1); 5793 report_return(insnstr(args[0], n)); 5794 } 5795 5796 5797 void 5798 cmd_insstr(int nargs, char **args) 5799 { 5800 if (check_arg_count(nargs, 1) == 1) 5801 return; 5802 5803 report_count(1); 5804 report_return(insstr(args[0])); 5805 } 5806 5807 5808 void 5809 cmd_mvinsnstr(int nargs, char **args) 5810 { 5811 int y, x, n; 5812 5813 if (check_arg_count(nargs, 4) == 1) 5814 return; 5815 5816 if (sscanf(args[0], "%d", &y) == 0) { 5817 report_count(1); 5818 report_error("BAD ARGUMENT"); 5819 return; 5820 } 5821 5822 if (sscanf(args[1], "%d", &x) == 0) { 5823 report_count(1); 5824 report_error("BAD ARGUMENT"); 5825 return; 5826 } 5827 5828 if (sscanf(args[3], "%d", &n) == 0) { 5829 report_count(1); 5830 report_error("BAD ARGUMENT"); 5831 return; 5832 } 5833 5834 report_count(1); 5835 report_return(mvinsnstr(y, x, args[2], n)); 5836 } 5837 5838 5839 void 5840 cmd_mvinsstr(int nargs, char **args) 5841 { 5842 int y, x; 5843 5844 if (check_arg_count(nargs, 3) == 1) 5845 return; 5846 5847 if (sscanf(args[0], "%d", &y) == 0) { 5848 report_count(1); 5849 report_error("BAD ARGUMENT"); 5850 return; 5851 } 5852 5853 if (sscanf(args[1], "%d", &x) == 0) { 5854 report_count(1); 5855 report_error("BAD ARGUMENT"); 5856 return; 5857 } 5858 5859 report_count(1); 5860 report_return(mvinsstr(y, x, args[2])); 5861 } 5862 5863 5864 void 5865 cmd_mvwinsnstr(int nargs, char **args) 5866 { 5867 WINDOW *win; 5868 int y, x, n; 5869 5870 if (check_arg_count(nargs, 5) == 1) 5871 return; 5872 5873 if (sscanf(args[0], "%p", &win) == 0) { 5874 report_count(1); 5875 report_error("BAD ARGUMENT"); 5876 return; 5877 } 5878 5879 if (sscanf(args[1], "%d", &y) == 0) { 5880 report_count(1); 5881 report_error("BAD ARGUMENT"); 5882 return; 5883 } 5884 5885 if (sscanf(args[2], "%d", &x) == 0) { 5886 report_count(1); 5887 report_error("BAD ARGUMENT"); 5888 return; 5889 } 5890 5891 if (sscanf(args[4], "%d", &n) == 0) { 5892 report_count(1); 5893 report_error("BAD ARGUMENT"); 5894 return; 5895 } 5896 5897 report_count(1); 5898 report_return(mvwinsnstr(win, y, x, args[3], n)); 5899 5900 } 5901 5902 5903 void 5904 cmd_mvwinsstr(int nargs, char **args) 5905 { 5906 WINDOW *win; 5907 int y, x; 5908 5909 if (check_arg_count(nargs, 4) == 1) 5910 return; 5911 5912 if (sscanf(args[0], "%p", &win) == 0) { 5913 report_count(1); 5914 report_error("BAD ARGUMENT"); 5915 return; 5916 } 5917 5918 if (sscanf(args[1], "%d", &y) == 0) { 5919 report_count(1); 5920 report_error("BAD ARGUMENT"); 5921 return; 5922 } 5923 5924 if (sscanf(args[2], "%d", &x) == 0) { 5925 report_count(1); 5926 report_error("BAD ARGUMENT"); 5927 return; 5928 } 5929 5930 report_count(1); 5931 report_return(mvwinsstr(win, y, x, args[3])); 5932 } 5933 5934 5935 void 5936 cmd_winsnstr(int nargs, char **args) 5937 { 5938 WINDOW *win; 5939 int n; 5940 5941 if (check_arg_count(nargs, 3) == 1) 5942 return; 5943 5944 if (sscanf(args[0], "%p", &win) == 0) { 5945 report_count(1); 5946 report_error("BAD ARGUMENT"); 5947 return; 5948 } 5949 5950 if (sscanf(args[2], "%d", &n) == 0) { 5951 report_count(1); 5952 report_error("BAD ARGUMENT"); 5953 return; 5954 } 5955 5956 report_count(1); 5957 report_return(winsnstr(win, args[1], n)); 5958 } 5959 5960 5961 void 5962 cmd_winsstr(int nargs, char **args) 5963 { 5964 WINDOW *win; 5965 5966 if (check_arg_count(nargs, 2) == 1) 5967 return; 5968 5969 if (sscanf(args[0], "%p", &win) == 0) { 5970 report_count(1); 5971 report_error("BAD ARGUMENT"); 5972 return; 5973 } 5974 5975 report_count(1); 5976 report_return(winsstr(win, args[1])); 5977 } 5978 5979 5980 5981 void 5982 cmd_chgat(int nargs, char **args) 5983 { 5984 int n, attr, colour; 5985 5986 if (check_arg_count(nargs, 4) == 1) 5987 return; 5988 5989 if (sscanf(args[0], "%d", &n) == 0) { 5990 report_count(1); 5991 report_error("BAD ARGUMENT"); 5992 return; 5993 } 5994 5995 if (sscanf(args[1], "%d", &attr) == 0) { 5996 report_count(1); 5997 report_error("BAD ARGUMENT"); 5998 return; 5999 } 6000 6001 if (sscanf(args[2], "%d", &colour) == 0) { 6002 report_count(1); 6003 report_error("BAD ARGUMENT"); 6004 return; 6005 } 6006 6007 /* Note: 4th argument unused in current curses implementation */ 6008 report_count(1); 6009 report_return(chgat(n, attr, colour, NULL)); 6010 } 6011 6012 6013 void 6014 cmd_wchgat(int nargs, char **args) 6015 { 6016 WINDOW *win; 6017 int n, attr; 6018 short colour; 6019 6020 if (check_arg_count(nargs, 4) == 1) 6021 return; 6022 6023 if (sscanf(args[0], "%p", &win) == 0) { 6024 report_count(1); 6025 report_error("BAD ARGUMENT"); 6026 return; 6027 } 6028 6029 if (sscanf(args[1], "%d", &n) == 0) { 6030 report_count(1); 6031 report_error("BAD ARGUMENT"); 6032 return; 6033 } 6034 6035 if (sscanf(args[2], "%d", &attr) == 0) { 6036 report_count(1); 6037 report_error("BAD ARGUMENT"); 6038 return; 6039 } 6040 6041 if (sscanf(args[3], "%hd", &colour) == 0) { 6042 report_count(1); 6043 report_error("BAD ARGUMENT"); 6044 return; 6045 } 6046 6047 report_count(1); 6048 report_return(wchgat(win, n, attr, colour, NULL)); 6049 } 6050 6051 6052 void 6053 cmd_mvchgat(int nargs, char **args) 6054 { 6055 int y, x, n, attr; 6056 short colour; 6057 6058 if (check_arg_count(nargs, 6) == 1) 6059 return; 6060 6061 if (sscanf(args[0], "%d", &y) == 0) { 6062 report_count(1); 6063 report_error("BAD ARGUMENT"); 6064 return; 6065 } 6066 6067 if (sscanf(args[1], "%d", &x) == 0) { 6068 report_count(1); 6069 report_error("BAD ARGUMENT"); 6070 return; 6071 } 6072 6073 if (sscanf(args[2], "%d", &n) == 0) { 6074 report_count(1); 6075 report_error("BAD ARGUMENT"); 6076 return; 6077 } 6078 6079 if (sscanf(args[3], "%d", &attr) == 0) { 6080 report_count(1); 6081 report_error("BAD ARGUMENT"); 6082 return; 6083 } 6084 6085 if (sscanf(args[4], "%hd", &colour) == 0) { 6086 report_count(1); 6087 report_error("BAD ARGUMENT"); 6088 return; 6089 } 6090 6091 report_count(1); 6092 report_return(mvchgat(y, x, n, attr, colour, NULL)); 6093 } 6094 6095 6096 void 6097 cmd_mvwchgat(int nargs, char **args) 6098 { 6099 WINDOW *win; 6100 int y, x, n, attr, colour; 6101 6102 if (check_arg_count(nargs, 6) == 1) 6103 return; 6104 6105 if (sscanf(args[0], "%p", &win) == 0) { 6106 report_count(1); 6107 report_error("BAD ARGUMENT"); 6108 return; 6109 } 6110 6111 if (sscanf(args[1], "%d", &y) == 0) { 6112 report_count(1); 6113 report_error("BAD ARGUMENT"); 6114 return; 6115 } 6116 6117 if (sscanf(args[2], "%d", &x) == 0) { 6118 report_count(1); 6119 report_error("BAD ARGUMENT"); 6120 return; 6121 } 6122 6123 if (sscanf(args[3], "%d", &n) == 0) { 6124 report_count(1); 6125 report_error("BAD ARGUMENT"); 6126 return; 6127 } 6128 6129 if (sscanf(args[4], "%d", &attr) == 0) { 6130 report_count(1); 6131 report_error("BAD ARGUMENT"); 6132 return; 6133 } 6134 6135 if (sscanf(args[5], "%d", &colour) == 0) { 6136 report_count(1); 6137 report_error("BAD ARGUMENT"); 6138 return; 6139 } 6140 6141 report_count(1); 6142 report_return(mvwchgat(win, y, x, n, attr, colour, NULL)); 6143 } 6144 6145 6146 void 6147 cmd_add_wch(int nargs, char **args) 6148 { 6149 if (check_arg_count(nargs, 1) == 1) 6150 return; 6151 6152 report_count(1); 6153 report_error("UNSUPPORTED"); 6154 } 6155 6156 6157 void 6158 cmd_wadd_wch(int nargs, char **args) 6159 { 6160 if (check_arg_count(nargs, 1) == 1) 6161 return; 6162 6163 report_count(1); 6164 report_error("UNSUPPORTED"); 6165 } 6166 6167 6168 void 6169 cmd_mvadd_wch(int nargs, char **args) 6170 { 6171 if (check_arg_count(nargs, 1) == 1) 6172 return; 6173 6174 report_count(1); 6175 report_error("UNSUPPORTED"); 6176 } 6177 6178 6179 void 6180 cmd_mvwadd_wch(int nargs, char **args) 6181 { 6182 if (check_arg_count(nargs, 1) == 1) 6183 return; 6184 6185 report_count(1); 6186 report_error("UNSUPPORTED"); 6187 } 6188 6189 6190 6191 void 6192 cmd_add_wchnstr(int nargs, char **args) 6193 { 6194 if (check_arg_count(nargs, 1) == 1) 6195 return; 6196 6197 report_count(1); 6198 report_error("UNSUPPORTED"); 6199 } 6200 6201 6202 void 6203 cmd_add_wchstr(int nargs, char **args) 6204 { 6205 if (check_arg_count(nargs, 1) == 1) 6206 return; 6207 6208 report_count(1); 6209 report_error("UNSUPPORTED"); 6210 } 6211 6212 6213 void 6214 cmd_wadd_wchnstr(int nargs, char **args) 6215 { 6216 if (check_arg_count(nargs, 1) == 1) 6217 return; 6218 6219 report_count(1); 6220 report_error("UNSUPPORTED"); 6221 } 6222 6223 6224 void 6225 cmd_wadd_wchstr(int nargs, char **args) 6226 { 6227 if (check_arg_count(nargs, 1) == 1) 6228 return; 6229 6230 report_count(1); 6231 report_error("UNSUPPORTED"); 6232 } 6233 6234 6235 void 6236 cmd_mvadd_wchnstr(int nargs, char **args) 6237 { 6238 if (check_arg_count(nargs, 1) == 1) 6239 return; 6240 6241 report_count(1); 6242 report_error("UNSUPPORTED"); 6243 } 6244 6245 6246 void 6247 cmd_mvadd_wchstr(int nargs, char **args) 6248 { 6249 if (check_arg_count(nargs, 1) == 1) 6250 return; 6251 6252 report_count(1); 6253 report_error("UNSUPPORTED"); 6254 } 6255 6256 6257 void 6258 cmd_mvwadd_wchnstr(int nargs, char **args) 6259 { 6260 if (check_arg_count(nargs, 1) == 1) 6261 return; 6262 6263 report_count(1); 6264 report_error("UNSUPPORTED"); 6265 } 6266 6267 6268 void 6269 cmd_mvwadd_wchstr(int nargs, char **args) 6270 { 6271 if (check_arg_count(nargs, 1) == 1) 6272 return; 6273 6274 report_count(1); 6275 report_error("UNSUPPORTED"); 6276 } 6277 6278 6279 6280 void 6281 cmd_addnwstr(int nargs, char **args) 6282 { 6283 if (check_arg_count(nargs, 1) == 1) 6284 return; 6285 6286 report_count(1); 6287 report_error("UNSUPPORTED"); 6288 } 6289 6290 6291 void 6292 cmd_addwstr(int nargs, char **args) 6293 { 6294 if (check_arg_count(nargs, 1) == 1) 6295 return; 6296 6297 report_count(1); 6298 report_error("UNSUPPORTED"); 6299 } 6300 6301 6302 void 6303 cmd_mvaddnwstr(int nargs, char **args) 6304 { 6305 if (check_arg_count(nargs, 1) == 1) 6306 return; 6307 6308 report_count(1); 6309 report_error("UNSUPPORTED"); 6310 } 6311 6312 6313 void 6314 cmd_mvaddwstr(int nargs, char **args) 6315 { 6316 if (check_arg_count(nargs, 1) == 1) 6317 return; 6318 6319 report_count(1); 6320 report_error("UNSUPPORTED"); 6321 } 6322 6323 6324 void 6325 cmd_mvwaddnwstr(int nargs, char **args) 6326 { 6327 if (check_arg_count(nargs, 1) == 1) 6328 return; 6329 6330 report_count(1); 6331 report_error("UNSUPPORTED"); 6332 } 6333 6334 6335 void 6336 cmd_mvwaddwstr(int nargs, char **args) 6337 { 6338 if (check_arg_count(nargs, 1) == 1) 6339 return; 6340 6341 report_count(1); 6342 report_error("UNSUPPORTED"); 6343 } 6344 6345 6346 void 6347 cmd_waddnwstr(int nargs, char **args) 6348 { 6349 if (check_arg_count(nargs, 1) == 1) 6350 return; 6351 6352 report_count(1); 6353 report_error("UNSUPPORTED"); 6354 } 6355 6356 6357 void 6358 cmd_waddwstr(int nargs, char **args) 6359 { 6360 if (check_arg_count(nargs, 1) == 1) 6361 return; 6362 6363 report_count(1); 6364 report_error("UNSUPPORTED"); 6365 } 6366 6367 6368 6369 void 6370 cmd_echo_wchar(int nargs, char **args) 6371 { 6372 if (check_arg_count(nargs, 1) == 1) 6373 return; 6374 6375 report_count(1); 6376 report_error("UNSUPPORTED"); 6377 } 6378 6379 6380 void 6381 cmd_wecho_wchar(int nargs, char **args) 6382 { 6383 if (check_arg_count(nargs, 1) == 1) 6384 return; 6385 6386 report_count(1); 6387 report_error("UNSUPPORTED"); 6388 } 6389 6390 6391 void 6392 cmd_pecho_wchar(int nargs, char **args) 6393 { 6394 if (check_arg_count(nargs, 1) == 1) 6395 return; 6396 6397 report_count(1); 6398 report_error("UNSUPPORTED"); 6399 } 6400 6401 6402 6403 /* insert */ 6404 void 6405 cmd_ins_wch(int nargs, char **args) 6406 { 6407 if (check_arg_count(nargs, 1) == 1) 6408 return; 6409 6410 report_count(1); 6411 report_error("UNSUPPORTED"); 6412 } 6413 6414 6415 void 6416 cmd_wins_wch(int nargs, char **args) 6417 { 6418 if (check_arg_count(nargs, 1) == 1) 6419 return; 6420 6421 report_count(1); 6422 report_error("UNSUPPORTED"); 6423 } 6424 6425 6426 void 6427 cmd_mvins_wch(int nargs, char **args) 6428 { 6429 if (check_arg_count(nargs, 1) == 1) 6430 return; 6431 6432 report_count(1); 6433 report_error("UNSUPPORTED"); 6434 } 6435 6436 6437 void 6438 cmd_mvwins_wch(int nargs, char **args) 6439 { 6440 if (check_arg_count(nargs, 1) == 1) 6441 return; 6442 6443 report_count(1); 6444 report_error("UNSUPPORTED"); 6445 } 6446 6447 6448 6449 void 6450 cmd_ins_nwstr(int nargs, char **args) 6451 { 6452 if (check_arg_count(nargs, 1) == 1) 6453 return; 6454 6455 report_count(1); 6456 report_error("UNSUPPORTED"); 6457 } 6458 6459 6460 void 6461 cmd_ins_wstr(int nargs, char **args) 6462 { 6463 if (check_arg_count(nargs, 1) == 1) 6464 return; 6465 6466 report_count(1); 6467 report_error("UNSUPPORTED"); 6468 } 6469 6470 6471 void 6472 cmd_mvins_nwstr(int nargs, char **args) 6473 { 6474 if (check_arg_count(nargs, 1) == 1) 6475 return; 6476 6477 report_count(1); 6478 report_error("UNSUPPORTED"); 6479 } 6480 6481 6482 void 6483 cmd_mvins_wstr(int nargs, char **args) 6484 { 6485 if (check_arg_count(nargs, 1) == 1) 6486 return; 6487 6488 report_count(1); 6489 report_error("UNSUPPORTED"); 6490 } 6491 6492 6493 void 6494 cmd_mvwins_nwstr(int nargs, char **args) 6495 { 6496 if (check_arg_count(nargs, 1) == 1) 6497 return; 6498 6499 report_count(1); 6500 report_error("UNSUPPORTED"); 6501 } 6502 6503 6504 void 6505 cmd_mvwins_wstr(int nargs, char **args) 6506 { 6507 if (check_arg_count(nargs, 1) == 1) 6508 return; 6509 6510 report_count(1); 6511 report_error("UNSUPPORTED"); 6512 } 6513 6514 6515 void 6516 cmd_wins_nwstr(int nargs, char **args) 6517 { 6518 if (check_arg_count(nargs, 1) == 1) 6519 return; 6520 6521 report_count(1); 6522 report_error("UNSUPPORTED"); 6523 } 6524 6525 6526 void 6527 cmd_wins_wstr(int nargs, char **args) 6528 { 6529 if (check_arg_count(nargs, 1) == 1) 6530 return; 6531 6532 report_count(1); 6533 report_error("UNSUPPORTED"); 6534 } 6535 6536 6537 6538 /* input */ 6539 void 6540 cmd_get_wch(int nargs, char **args) 6541 { 6542 if (check_arg_count(nargs, 1) == 1) 6543 return; 6544 6545 report_count(1); 6546 report_error("UNSUPPORTED"); 6547 } 6548 6549 6550 void 6551 cmd_unget_wch(int nargs, char **args) 6552 { 6553 if (check_arg_count(nargs, 1) == 1) 6554 return; 6555 6556 report_count(1); 6557 report_error("UNSUPPORTED"); 6558 } 6559 6560 6561 void 6562 cmd_mvget_wch(int nargs, char **args) 6563 { 6564 if (check_arg_count(nargs, 1) == 1) 6565 return; 6566 6567 report_count(1); 6568 report_error("UNSUPPORTED"); 6569 } 6570 6571 6572 void 6573 cmd_mvwget_wch(int nargs, char **args) 6574 { 6575 if (check_arg_count(nargs, 1) == 1) 6576 return; 6577 6578 report_count(1); 6579 report_error("UNSUPPORTED"); 6580 } 6581 6582 6583 void 6584 cmd_wget_wch(int nargs, char **args) 6585 { 6586 if (check_arg_count(nargs, 1) == 1) 6587 return; 6588 6589 report_count(1); 6590 report_error("UNSUPPORTED"); 6591 } 6592 6593 6594 6595 void 6596 cmd_getn_wstr(int nargs, char **args) 6597 { 6598 if (check_arg_count(nargs, 1) == 1) 6599 return; 6600 6601 report_count(1); 6602 report_error("UNSUPPORTED"); 6603 } 6604 6605 6606 void 6607 cmd_get_wstr(int nargs, char **args) 6608 { 6609 if (check_arg_count(nargs, 1) == 1) 6610 return; 6611 6612 report_count(1); 6613 report_error("UNSUPPORTED"); 6614 } 6615 6616 6617 void 6618 cmd_mvgetn_wstr(int nargs, char **args) 6619 { 6620 if (check_arg_count(nargs, 1) == 1) 6621 return; 6622 6623 report_count(1); 6624 report_error("UNSUPPORTED"); 6625 } 6626 6627 6628 void 6629 cmd_mvget_wstr(int nargs, char **args) 6630 { 6631 if (check_arg_count(nargs, 1) == 1) 6632 return; 6633 6634 report_count(1); 6635 report_error("UNSUPPORTED"); 6636 } 6637 6638 6639 void 6640 cmd_mvwgetn_wstr(int nargs, char **args) 6641 { 6642 if (check_arg_count(nargs, 1) == 1) 6643 return; 6644 6645 report_count(1); 6646 report_error("UNSUPPORTED"); 6647 } 6648 6649 6650 void 6651 cmd_mvwget_wstr(int nargs, char **args) 6652 { 6653 if (check_arg_count(nargs, 1) == 1) 6654 return; 6655 6656 report_count(1); 6657 report_error("UNSUPPORTED"); 6658 } 6659 6660 6661 void 6662 cmd_wgetn_wstr(int nargs, char **args) 6663 { 6664 if (check_arg_count(nargs, 1) == 1) 6665 return; 6666 6667 report_count(1); 6668 report_error("UNSUPPORTED"); 6669 } 6670 6671 6672 void 6673 cmd_wget_wstr(int nargs, char **args) 6674 { 6675 if (check_arg_count(nargs, 1) == 1) 6676 return; 6677 6678 report_count(1); 6679 report_error("UNSUPPORTED"); 6680 } 6681 6682 6683 6684 void 6685 cmd_in_wch(int nargs, char **args) 6686 { 6687 if (check_arg_count(nargs, 1) == 1) 6688 return; 6689 6690 report_count(1); 6691 report_error("UNSUPPORTED"); 6692 } 6693 6694 6695 void 6696 cmd_mvin_wch(int nargs, char **args) 6697 { 6698 if (check_arg_count(nargs, 1) == 1) 6699 return; 6700 6701 report_count(1); 6702 report_error("UNSUPPORTED"); 6703 } 6704 6705 6706 void 6707 cmd_mvwin_wch(int nargs, char **args) 6708 { 6709 if (check_arg_count(nargs, 1) == 1) 6710 return; 6711 6712 report_count(1); 6713 report_error("UNSUPPORTED"); 6714 } 6715 6716 6717 void 6718 cmd_win_wch(int nargs, char **args) 6719 { 6720 if (check_arg_count(nargs, 1) == 1) 6721 return; 6722 6723 report_count(1); 6724 report_error("UNSUPPORTED"); 6725 } 6726 6727 6728 6729 void 6730 cmd_in_wchnstr(int nargs, char **args) 6731 { 6732 if (check_arg_count(nargs, 1) == 1) 6733 return; 6734 6735 report_count(1); 6736 report_error("UNSUPPORTED"); 6737 } 6738 6739 6740 void 6741 cmd_in_wchstr(int nargs, char **args) 6742 { 6743 if (check_arg_count(nargs, 1) == 1) 6744 return; 6745 6746 report_count(1); 6747 report_error("UNSUPPORTED"); 6748 } 6749 6750 6751 void 6752 cmd_mvin_wchnstr(int nargs, char **args) 6753 { 6754 if (check_arg_count(nargs, 1) == 1) 6755 return; 6756 6757 report_count(1); 6758 report_error("UNSUPPORTED"); 6759 } 6760 6761 6762 void 6763 cmd_mvin_wchstr(int nargs, char **args) 6764 { 6765 if (check_arg_count(nargs, 1) == 1) 6766 return; 6767 6768 report_count(1); 6769 report_error("UNSUPPORTED"); 6770 } 6771 6772 6773 void 6774 cmd_mvwin_wchnstr(int nargs, char **args) 6775 { 6776 if (check_arg_count(nargs, 1) == 1) 6777 return; 6778 6779 report_count(1); 6780 report_error("UNSUPPORTED"); 6781 } 6782 6783 6784 void 6785 cmd_mvwin_wchstr(int nargs, char **args) 6786 { 6787 if (check_arg_count(nargs, 1) == 1) 6788 return; 6789 6790 report_count(1); 6791 report_error("UNSUPPORTED"); 6792 } 6793 6794 6795 void 6796 cmd_win_wchnstr(int nargs, char **args) 6797 { 6798 if (check_arg_count(nargs, 1) == 1) 6799 return; 6800 6801 report_count(1); 6802 report_error("UNSUPPORTED"); 6803 } 6804 6805 6806 void 6807 cmd_win_wchstr(int nargs, char **args) 6808 { 6809 if (check_arg_count(nargs, 1) == 1) 6810 return; 6811 6812 report_count(1); 6813 report_error("UNSUPPORTED"); 6814 } 6815 6816 6817 6818 void 6819 cmd_innwstr(int nargs, char **args) 6820 { 6821 if (check_arg_count(nargs, 1) == 1) 6822 return; 6823 6824 report_count(1); 6825 report_error("UNSUPPORTED"); 6826 } 6827 6828 6829 void 6830 cmd_inwstr(int nargs, char **args) 6831 { 6832 if (check_arg_count(nargs, 1) == 1) 6833 return; 6834 6835 report_count(1); 6836 report_error("UNSUPPORTED"); 6837 } 6838 6839 6840 void 6841 cmd_mvinnwstr(int nargs, char **args) 6842 { 6843 if (check_arg_count(nargs, 1) == 1) 6844 return; 6845 6846 report_count(1); 6847 report_error("UNSUPPORTED"); 6848 } 6849 6850 6851 void 6852 cmd_mvinwstr(int nargs, char **args) 6853 { 6854 if (check_arg_count(nargs, 1) == 1) 6855 return; 6856 6857 report_count(1); 6858 report_error("UNSUPPORTED"); 6859 } 6860 6861 6862 void 6863 cmd_mvwinnwstr(int nargs, char **args) 6864 { 6865 if (check_arg_count(nargs, 1) == 1) 6866 return; 6867 6868 report_count(1); 6869 report_error("UNSUPPORTED"); 6870 } 6871 6872 6873 void 6874 cmd_mvwinwstr(int nargs, char **args) 6875 { 6876 if (check_arg_count(nargs, 1) == 1) 6877 return; 6878 6879 report_count(1); 6880 report_error("UNSUPPORTED"); 6881 } 6882 6883 6884 void 6885 cmd_winnwstr(int nargs, char **args) 6886 { 6887 if (check_arg_count(nargs, 1) == 1) 6888 return; 6889 6890 report_count(1); 6891 report_error("UNSUPPORTED"); 6892 } 6893 6894 6895 void 6896 cmd_winwstr(int nargs, char **args) 6897 { 6898 if (check_arg_count(nargs, 1) == 1) 6899 return; 6900 6901 report_count(1); 6902 report_error("UNSUPPORTED"); 6903 } 6904 6905 6906 6907 /* cchar handlgin */ 6908 void 6909 cmd_setcchar(int nargs, char **args) 6910 { 6911 if (check_arg_count(nargs, 1) == 1) 6912 return; 6913 6914 report_count(1); 6915 report_error("UNSUPPORTED"); 6916 } 6917 6918 6919 void 6920 cmd_getcchar(int nargs, char **args) 6921 { 6922 if (check_arg_count(nargs, 1) == 1) 6923 return; 6924 6925 report_count(1); 6926 report_error("UNSUPPORTED"); 6927 } 6928 6929 6930 6931 /* misc */ 6932 void 6933 cmd_key_name(int nargs, char **args) 6934 { 6935 int w; 6936 6937 if (check_arg_count(nargs, 1) == 1) 6938 return; 6939 6940 if (sscanf(args[0], "%d", &w) == 0) { 6941 report_count(1); 6942 report_error("BAD ARGUMENT"); 6943 return; 6944 } 6945 6946 report_count(1); 6947 report_status(key_name(w)); 6948 } 6949 6950 6951 void 6952 cmd_border_set(int nargs, char **args) 6953 { 6954 if (check_arg_count(nargs, 1) == 1) 6955 return; 6956 6957 report_count(1); 6958 report_error("UNSUPPORTED"); 6959 } 6960 6961 6962 void 6963 cmd_wborder_set(int nargs, char **args) 6964 { 6965 if (check_arg_count(nargs, 1) == 1) 6966 return; 6967 6968 report_count(1); 6969 report_error("UNSUPPORTED"); 6970 } 6971 6972 6973 void 6974 cmd_box_set(int nargs, char **args) 6975 { 6976 if (check_arg_count(nargs, 1) == 1) 6977 return; 6978 6979 report_count(1); 6980 report_error("UNSUPPORTED"); 6981 } 6982 6983 6984 void 6985 cmd_erasewchar(int nargs, char **args) 6986 { 6987 wchar_t ch; 6988 6989 if (check_arg_count(nargs, 0) == 1) 6990 return; 6991 6992 /* XXX - call2 */ 6993 report_count(2); 6994 report_return(erasewchar(&ch)); 6995 report_int(ch); 6996 } 6997 6998 6999 void 7000 cmd_killwchar(int nargs, char **args) 7001 { 7002 wchar_t ch; 7003 7004 if (check_arg_count(nargs, 0) == 1) 7005 return; 7006 7007 /* XXX - call2 */ 7008 report_count(2); 7009 report_return(erasewchar(&ch)); 7010 report_int(ch); 7011 } 7012 7013 7014 void 7015 cmd_hline_set(int nargs, char **args) 7016 { 7017 if (check_arg_count(nargs, 1) == 1) 7018 return; 7019 7020 report_count(1); 7021 report_error("UNSUPPORTED"); 7022 } 7023 7024 7025 void 7026 cmd_mvhline_set(int nargs, char **args) 7027 { 7028 if (check_arg_count(nargs, 1) == 1) 7029 return; 7030 7031 report_count(1); 7032 report_error("UNSUPPORTED"); 7033 } 7034 7035 7036 void 7037 cmd_mvvline_set(int nargs, char **args) 7038 { 7039 if (check_arg_count(nargs, 1) == 1) 7040 return; 7041 7042 report_count(1); 7043 report_error("UNSUPPORTED"); 7044 } 7045 7046 7047 void 7048 cmd_mvwhline_set(int nargs, char **args) 7049 { 7050 if (check_arg_count(nargs, 1) == 1) 7051 return; 7052 7053 report_count(1); 7054 report_error("UNSUPPORTED"); 7055 } 7056 7057 7058 void 7059 cmd_mvwvline_set(int nargs, char **args) 7060 { 7061 if (check_arg_count(nargs, 1) == 1) 7062 return; 7063 7064 report_count(1); 7065 report_error("UNSUPPORTED"); 7066 } 7067 7068 7069 void 7070 cmd_vline_set(int nargs, char **args) 7071 { 7072 if (check_arg_count(nargs, 1) == 1) 7073 return; 7074 7075 report_count(1); 7076 report_error("UNSUPPORTED"); 7077 } 7078 7079 7080 void 7081 cmd_whline_set(int nargs, char **args) 7082 { 7083 if (check_arg_count(nargs, 1) == 1) 7084 return; 7085 7086 report_count(1); 7087 report_error("UNSUPPORTED"); 7088 } 7089 7090 7091 void 7092 cmd_wvline_set(int nargs, char **args) 7093 { 7094 if (check_arg_count(nargs, 1) == 1) 7095 return; 7096 7097 report_count(1); 7098 report_error("UNSUPPORTED"); 7099 } 7100 7101 7102 void 7103 cmd_bkgrnd(int nargs, char **args) 7104 { 7105 if (check_arg_count(nargs, 1) == 1) 7106 return; 7107 7108 report_count(1); 7109 report_error("UNSUPPORTED"); 7110 } 7111 7112 7113 void 7114 cmd_bkgrndset(int nargs, char **args) 7115 { 7116 if (check_arg_count(nargs, 1) == 1) 7117 return; 7118 7119 report_count(1); 7120 report_error("UNSUPPORTED"); 7121 } 7122 7123 7124 void 7125 cmd_getbkgrnd(int nargs, char **args) 7126 { 7127 if (check_arg_count(nargs, 1) == 1) 7128 return; 7129 7130 report_count(1); 7131 report_error("UNSUPPORTED"); 7132 } 7133 7134 7135 void 7136 cmd_wbkgrnd(int nargs, char **args) 7137 { 7138 if (check_arg_count(nargs, 1) == 1) 7139 return; 7140 7141 report_count(1); 7142 report_error("UNSUPPORTED"); 7143 } 7144 7145 7146 void 7147 cmd_wbkgrndset(int nargs, char **args) 7148 { 7149 if (check_arg_count(nargs, 1) == 1) 7150 return; 7151 7152 report_count(1); 7153 report_error("UNSUPPORTED"); 7154 } 7155 7156 7157 void 7158 cmd_wgetbkgrnd(int nargs, char **args) 7159 { 7160 if (check_arg_count(nargs, 1) == 1) 7161 return; 7162 7163 report_count(1); 7164 report_error("UNSUPPORTED"); 7165 } 7166