1 /* $NetBSD: curses_commands.c,v 1.6 2011/09/15 11:46:19 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, ch, n; 3009 3010 if (check_arg_count(nargs, 4) == 1) 3011 return; 3012 3013 if (sscanf(args[0], "%d", &y) == 0) { 3014 report_count(1); 3015 report_error("BAD ARGUMENT"); 3016 return; 3017 } 3018 3019 if (sscanf(args[1], "%d", &x) == 0) { 3020 report_count(1); 3021 report_error("BAD ARGUMENT"); 3022 return; 3023 } 3024 3025 if (sscanf(args[2], "%d", &ch) == 0) { 3026 report_count(1); 3027 report_error("BAD ARGUMENT"); 3028 return; 3029 } 3030 3031 if (sscanf(args[3], "%d", &n) == 0) { 3032 report_count(1); 3033 report_error("BAD ARGUMENT"); 3034 return; 3035 } 3036 3037 report_count(1); 3038 report_return(mvhline(y, x, ch, n)); 3039 } 3040 3041 3042 void 3043 cmd_mvprintw(int nargs, char **args) 3044 { 3045 int y, x; 3046 3047 if (check_arg_count(nargs, 4) == 1) 3048 return; 3049 3050 if (sscanf(args[0], "%d", &y) == 0) { 3051 report_count(1); 3052 report_error("BAD ARGUMENT"); 3053 return; 3054 } 3055 3056 if (sscanf(args[1], "%d", &x) == 0) { 3057 report_count(1); 3058 report_error("BAD ARGUMENT"); 3059 return; 3060 } 3061 3062 report_count(1); 3063 report_return(mvprintw(y, x, args[2], args[3])); 3064 } 3065 3066 3067 void 3068 cmd_mvscanw(int nargs, char **args) 3069 { 3070 int y, x; 3071 char string[256]; 3072 3073 if (check_arg_count(nargs, 3) == 1) 3074 return; 3075 3076 if (sscanf(args[0], "%d", &y) == 0) { 3077 report_count(1); 3078 report_error("BAD ARGUMENT"); 3079 return; 3080 } 3081 3082 if (sscanf(args[1], "%d", &x) == 0) { 3083 report_count(1); 3084 report_error("BAD ARGUMENT"); 3085 return; 3086 } 3087 3088 /* XXX - call2 */ 3089 report_count(2); 3090 report_int(mvscanw(y, x, args[2], &string)); 3091 report_status(string); 3092 } 3093 3094 3095 void 3096 cmd_mvvline(int nargs, char **args) 3097 { 3098 int y, x, ch, n; 3099 3100 if (check_arg_count(nargs, 4) == 1) 3101 return; 3102 3103 if (sscanf(args[0], "%d", &y) == 0) { 3104 report_count(1); 3105 report_error("BAD ARGUMENT"); 3106 return; 3107 } 3108 3109 if (sscanf(args[1], "%d", &x) == 0) { 3110 report_count(1); 3111 report_error("BAD ARGUMENT"); 3112 return; 3113 } 3114 3115 if (sscanf(args[2], "%d", &ch) == 0) { 3116 report_count(1); 3117 report_error("BAD ARGUMENT"); 3118 return; 3119 } 3120 3121 if (sscanf(args[3], "%d", &n) == 0) { 3122 report_count(1); 3123 report_error("BAD ARGUMENT"); 3124 return; 3125 } 3126 3127 report_count(1); 3128 report_return(mvvline(y, x, ch, n)); 3129 } 3130 3131 3132 void 3133 cmd_mvwhline(int nargs, char **args) 3134 { 3135 int y, x, ch, n; 3136 WINDOW *win; 3137 3138 if (check_arg_count(nargs, 5) == 1) 3139 return; 3140 3141 if (sscanf(args[0], "%p", &win) == 0) { 3142 report_count(1); 3143 report_error("BAD ARGUMENT"); 3144 return; 3145 } 3146 3147 if (sscanf(args[1], "%d", &y) == 0) { 3148 report_count(1); 3149 report_error("BAD ARGUMENT"); 3150 return; 3151 } 3152 3153 if (sscanf(args[2], "%d", &x) == 0) { 3154 report_count(1); 3155 report_error("BAD ARGUMENT"); 3156 return; 3157 } 3158 3159 if (sscanf(args[3], "%d", &ch) == 0) { 3160 report_count(1); 3161 report_error("BAD ARGUMENT"); 3162 return; 3163 } 3164 3165 if (sscanf(args[4], "%d", &n) == 0) { 3166 report_count(1); 3167 report_error("BAD ARGUMENT"); 3168 return; 3169 } 3170 3171 report_count(1); 3172 report_return(mvwhline(win, y, x, ch, n)); 3173 } 3174 3175 3176 void 3177 cmd_mvwvline(int nargs, char **args) 3178 { 3179 int y, x, ch, n; 3180 WINDOW *win; 3181 3182 if (check_arg_count(nargs, 5) == 1) 3183 return; 3184 3185 if (sscanf(args[0], "%p", &win) == 0) { 3186 report_count(1); 3187 report_error("BAD ARGUMENT"); 3188 return; 3189 } 3190 3191 if (sscanf(args[1], "%d", &y) == 0) { 3192 report_count(1); 3193 report_error("BAD ARGUMENT"); 3194 return; 3195 } 3196 3197 if (sscanf(args[2], "%d", &x) == 0) { 3198 report_count(1); 3199 report_error("BAD ARGUMENT"); 3200 return; 3201 } 3202 3203 if (sscanf(args[3], "%d", &ch) == 0) { 3204 report_count(1); 3205 report_error("BAD ARGUMENT"); 3206 return; 3207 } 3208 3209 if (sscanf(args[4], "%d", &n) == 0) { 3210 report_count(1); 3211 report_error("BAD ARGUMENT"); 3212 return; 3213 } 3214 3215 report_count(1); 3216 report_return(mvwvline(win, y, x, ch, n)); 3217 } 3218 3219 3220 void 3221 cmd_mvwin(int nargs, char **args) 3222 { 3223 int y, x; 3224 WINDOW *win; 3225 3226 if (check_arg_count(nargs, 3) == 1) 3227 return; 3228 3229 if (sscanf(args[0], "%p", &win) == 0) { 3230 report_count(1); 3231 report_error("BAD ARGUMENT"); 3232 return; 3233 } 3234 3235 if (sscanf(args[1], "%d", &y) == 0) { 3236 report_count(1); 3237 report_error("BAD ARGUMENT"); 3238 return; 3239 } 3240 3241 if (sscanf(args[2], "%d", &x) == 0) { 3242 report_count(1); 3243 report_error("BAD ARGUMENT"); 3244 return; 3245 } 3246 3247 report_count(1); 3248 report_return(mvwin(win, y, x)); 3249 } 3250 3251 3252 void 3253 cmd_mvwinchnstr(int nargs, char **args) 3254 { 3255 int y, x, count; 3256 chtype *string; 3257 WINDOW *win; 3258 3259 if (check_arg_count(nargs, 4) == 1) 3260 return; 3261 3262 if (sscanf(args[0], "%p", &win) == 0) { 3263 report_count(1); 3264 report_error("BAD ARGUMENT"); 3265 return; 3266 } 3267 3268 if (sscanf(args[1], "%d", &y) == 0) { 3269 report_count(1); 3270 report_error("BAD ARGUMENT"); 3271 return; 3272 } 3273 3274 if (sscanf(args[2], "%d", &x) == 0) { 3275 report_count(1); 3276 report_error("BAD ARGUMENT"); 3277 return; 3278 } 3279 3280 if (sscanf(args[3], "%d", &count) == 0) { 3281 report_count(1); 3282 report_error("BAD ARGUMENT"); 3283 return; 3284 } 3285 3286 if ((string = malloc((count + 1) * sizeof(chtype))) == NULL) { 3287 report_count(1); 3288 report_error("MALLOC_FAILED"); 3289 return; 3290 } 3291 3292 /* XXX call2 */ 3293 report_count(2); 3294 report_return(mvwinchnstr(win, y, x, string, count)); 3295 report_nstr(string); 3296 free(string); 3297 } 3298 3299 3300 void 3301 cmd_mvwinchstr(int nargs, char **args) 3302 { 3303 int y, x; 3304 chtype string[256]; 3305 WINDOW *win; 3306 3307 if (check_arg_count(nargs, 3) == 1) 3308 return; 3309 3310 if (sscanf(args[0], "%p", &win) == 0) { 3311 report_count(1); 3312 report_error("BAD ARGUMENT"); 3313 return; 3314 } 3315 3316 if (sscanf(args[1], "%d", &y) == 0) { 3317 report_count(1); 3318 report_error("BAD ARGUMENT"); 3319 return; 3320 } 3321 3322 if (sscanf(args[2], "%d", &x) == 0) { 3323 report_count(1); 3324 report_error("BAD ARGUMENT"); 3325 return; 3326 } 3327 3328 /* XXX call2 */ 3329 report_count(2); 3330 report_return(mvwinchstr(win, y, x, string)); 3331 report_nstr(string); 3332 } 3333 3334 3335 void 3336 cmd_mvwinnstr(int nargs, char **args) 3337 { 3338 int y, x, count; 3339 char *string; 3340 WINDOW *win; 3341 3342 if (check_arg_count(nargs, 4) == 1) 3343 return; 3344 3345 if (sscanf(args[0], "%p", &win) == 0) { 3346 report_count(1); 3347 report_error("BAD ARGUMENT"); 3348 return; 3349 } 3350 3351 if (sscanf(args[1], "%d", &y) == 0) { 3352 report_count(1); 3353 report_error("BAD ARGUMENT"); 3354 return; 3355 } 3356 3357 if (sscanf(args[2], "%d", &x) == 0) { 3358 report_count(1); 3359 report_error("BAD ARGUMENT"); 3360 return; 3361 } 3362 3363 if (sscanf(args[3], "%d", &count) == 0) { 3364 report_count(1); 3365 report_error("BAD ARGUMENT"); 3366 return; 3367 } 3368 3369 if ((string = malloc(count + 1)) == NULL) { 3370 report_count(1); 3371 report_error("MALLOC_FAILED"); 3372 return; 3373 } 3374 3375 /* XXX call2 */ 3376 report_count(2); 3377 report_return(mvwinnstr(win, y, x, string, count)); 3378 report_status(string); 3379 free(string); 3380 } 3381 3382 3383 void 3384 cmd_mvwinstr(int nargs, char **args) 3385 { 3386 int y, x; 3387 char string[256]; 3388 WINDOW *win; 3389 3390 if (check_arg_count(nargs, 3) == 1) 3391 return; 3392 3393 if (sscanf(args[0], "%p", &win) == 0) { 3394 report_count(1); 3395 report_error("BAD ARGUMENT"); 3396 return; 3397 } 3398 3399 if (sscanf(args[1], "%d", &y) == 0) { 3400 report_count(1); 3401 report_error("BAD ARGUMENT"); 3402 return; 3403 } 3404 3405 if (sscanf(args[2], "%d", &x) == 0) { 3406 report_count(1); 3407 report_error("BAD ARGUMENT"); 3408 return; 3409 } 3410 3411 /* XXX call2 */ 3412 report_count(2); 3413 report_return(mvwinstr(win, y, x, string)); 3414 report_status(string); 3415 } 3416 3417 3418 void 3419 cmd_mvwprintw(int nargs, char **args) 3420 { 3421 int y, x; 3422 WINDOW *win; 3423 3424 if (check_arg_count(nargs, 5) == 1) 3425 return; 3426 3427 if (sscanf(args[0], "%p", &win) == 0) { 3428 report_count(1); 3429 report_error("BAD ARGUMENT"); 3430 return; 3431 } 3432 3433 if (sscanf(args[1], "%d", &y) == 0) { 3434 report_count(1); 3435 report_error("BAD ARGUMENT"); 3436 return; 3437 } 3438 3439 if (sscanf(args[2], "%d", &x) == 0) { 3440 report_count(1); 3441 report_error("BAD ARGUMENT"); 3442 return; 3443 } 3444 3445 report_count(1); 3446 report_return(mvwprintw(win, y, x, args[3], args[4])); 3447 } 3448 3449 3450 void 3451 cmd_mvwscanw(int nargs, char **args) 3452 { 3453 int y, x; 3454 WINDOW *win; 3455 char string[256]; 3456 3457 if (check_arg_count(nargs, 4) == 1) 3458 return; 3459 3460 if (sscanf(args[0], "%p", &win) == 0) { 3461 report_count(1); 3462 report_error("BAD ARGUMENT"); 3463 return; 3464 } 3465 3466 if (sscanf(args[1], "%d", &y) == 0) { 3467 report_count(1); 3468 report_error("BAD ARGUMENT"); 3469 return; 3470 } 3471 3472 if (sscanf(args[2], "%d", &x) == 0) { 3473 report_count(1); 3474 report_error("BAD ARGUMENT"); 3475 return; 3476 } 3477 3478 /* XXX - call2 */ 3479 report_count(2); 3480 report_int(mvwscanw(win, y, x, args[3], &string)); 3481 report_status(string); 3482 } 3483 3484 3485 void 3486 cmd_napms(int nargs, char **args) 3487 { 3488 int naptime; 3489 3490 if (check_arg_count(nargs, 1) == 1) 3491 return; 3492 3493 if (sscanf(args[0], "%d", &naptime) == 0) { 3494 report_count(1); 3495 report_error("BAD ARGUMENT"); 3496 return; 3497 } 3498 3499 report_count(1); 3500 report_return(napms(naptime)); 3501 } 3502 3503 3504 void 3505 cmd_newpad(int nargs, char **args) 3506 { 3507 int y, x; 3508 3509 if (check_arg_count(nargs, 2) == 1) 3510 return; 3511 3512 if (sscanf(args[0], "%d", &y) == 0) { 3513 report_count(1); 3514 report_error("BAD ARGUMENT"); 3515 return; 3516 } 3517 3518 if (sscanf(args[1], "%d", &x) == 0) { 3519 report_count(1); 3520 report_error("BAD ARGUMENT"); 3521 return; 3522 } 3523 3524 report_count(1); 3525 report_ptr(newpad(y, x)); 3526 } 3527 3528 3529 void 3530 cmd_newterm(int nargs, char **args) 3531 { 3532 FILE *in, *out; 3533 3534 if (check_arg_count(nargs, 3) == 1) 3535 return; 3536 3537 if ((in = fopen(args[1], "rw")) == NULL) { 3538 report_count(1); 3539 report_error("BAD FILE_ARGUMENT"); 3540 return; 3541 } 3542 3543 3544 if ((out = fopen(args[2], "rw")) == NULL) { 3545 report_count(1); 3546 report_error("BAD FILE_ARGUMENT"); 3547 return; 3548 } 3549 3550 report_count(1); 3551 report_ptr(newterm(args[0], out, in)); 3552 } 3553 3554 3555 void 3556 cmd_newwin(int nargs, char **args) 3557 { 3558 int lines, cols, begin_y, begin_x; 3559 3560 if (check_arg_count(nargs, 4) == 1) 3561 return; 3562 3563 if (sscanf(args[0], "%d", &lines) == 0) { 3564 report_count(1); 3565 report_error("BAD ARGUMENT"); 3566 return; 3567 } 3568 3569 if (sscanf(args[1], "%d", &cols) == 0) { 3570 report_count(1); 3571 report_error("BAD ARGUMENT"); 3572 return; 3573 } 3574 3575 if (sscanf(args[2], "%d", &begin_y) == 0) { 3576 report_count(1); 3577 report_error("BAD ARGUMENT"); 3578 return; 3579 } 3580 3581 if (sscanf(args[3], "%d", &begin_x) == 0) { 3582 report_count(1); 3583 report_error("BAD ARGUMENT"); 3584 return; 3585 } 3586 3587 report_count(1); 3588 report_ptr(newwin(lines, cols, begin_y, begin_x)); 3589 } 3590 3591 3592 void 3593 cmd_nl(int nargs, char **args) 3594 { 3595 if (check_arg_count(nargs, 0) == 1) 3596 return; 3597 3598 report_count(1); 3599 report_return(nl()); 3600 } 3601 3602 3603 void 3604 cmd_no_color_attributes(int nargs, char **args) 3605 { 3606 if (check_arg_count(nargs, 0) == 1) 3607 return; 3608 3609 report_count(1); 3610 report_int(no_color_attributes()); 3611 } 3612 3613 3614 void 3615 cmd_nocbreak(int nargs, char **args) 3616 { 3617 if (check_arg_count(nargs, 0) == 1) 3618 return; 3619 3620 report_count(1); 3621 report_return(nocbreak()); 3622 } 3623 3624 3625 void 3626 cmd_nodelay(int nargs, char **args) 3627 { 3628 int flag; 3629 WINDOW *win; 3630 3631 if (check_arg_count(nargs, 2) == 1) 3632 return; 3633 3634 if (sscanf(args[0], "%p", &win) == 0) { 3635 report_count(1); 3636 report_error("BAD ARGUMENT"); 3637 return; 3638 } 3639 3640 if (sscanf(args[1], "%d", &flag) == 0) { 3641 report_count(1); 3642 report_error("BAD ARGUMENT"); 3643 return; 3644 } 3645 3646 report_count(1); 3647 report_return(nodelay(win, flag)); 3648 } 3649 3650 3651 void 3652 cmd_noecho(int nargs, char **args) 3653 { 3654 if (check_arg_count(nargs, 0) == 1) 3655 return; 3656 3657 report_count(1); 3658 report_return(noecho()); 3659 } 3660 3661 3662 void 3663 cmd_nonl(int nargs, char **args) 3664 { 3665 if (check_arg_count(nargs, 0) == 1) 3666 return; 3667 3668 report_count(1); 3669 report_return(nonl()); 3670 } 3671 3672 3673 void 3674 cmd_noqiflush(int nargs, char **args) 3675 { 3676 if (check_arg_count(nargs, 0) == 1) 3677 return; 3678 3679 noqiflush(); 3680 report_count(1); 3681 report_return(OK); /* fake a return, the call returns void */ 3682 } 3683 3684 3685 void 3686 cmd_noraw(int nargs, char **args) 3687 { 3688 if (check_arg_count(nargs, 0) == 1) 3689 return; 3690 3691 report_count(1); 3692 report_return(noraw()); 3693 } 3694 3695 3696 void 3697 cmd_notimeout(int nargs, char **args) 3698 { 3699 int flag; 3700 WINDOW *win; 3701 3702 if (check_arg_count(nargs, 2) == 1) 3703 return; 3704 3705 if (sscanf(args[0], "%p", &win) == 0) { 3706 report_count(1); 3707 report_error("BAD ARGUMENT"); 3708 return; 3709 } 3710 3711 if (sscanf(args[1], "%d", &flag) == 0) { 3712 report_count(1); 3713 report_error("BAD ARGUMENT"); 3714 return; 3715 } 3716 3717 report_count(1); 3718 report_return(notimeout(win, flag)); 3719 } 3720 3721 3722 void 3723 cmd_overlay(int nargs, char **args) 3724 { 3725 WINDOW *source, *dest; 3726 3727 if (check_arg_count(nargs, 2) == 1) 3728 return; 3729 3730 if (sscanf(args[0], "%p", &source) == 0) { 3731 report_count(1); 3732 report_error("BAD ARGUMENT"); 3733 return; 3734 } 3735 3736 if (sscanf(args[1], "%p", &dest) == 0) { 3737 report_count(1); 3738 report_error("BAD ARGUMENT"); 3739 return; 3740 } 3741 3742 report_count(1); 3743 report_return(overlay(source, dest)); 3744 } 3745 3746 3747 void 3748 cmd_overwrite(int nargs, char **args) 3749 { 3750 WINDOW *source, *dest; 3751 3752 if (check_arg_count(nargs, 2) == 1) 3753 return; 3754 3755 if (sscanf(args[0], "%p", &source) == 0) { 3756 report_count(1); 3757 report_error("BAD ARGUMENT"); 3758 return; 3759 } 3760 3761 if (sscanf(args[1], "%p", &dest) == 0) { 3762 report_count(1); 3763 report_error("BAD ARGUMENT"); 3764 return; 3765 } 3766 3767 report_count(1); 3768 report_return(overwrite(source, dest)); 3769 } 3770 3771 3772 void 3773 cmd_pair_content(int nargs, char **args) 3774 { 3775 short pair, fore, back; 3776 3777 if (check_arg_count(nargs, 1) == 1) 3778 return; 3779 3780 if (sscanf(args[0], "%hd", &pair) == 0) { 3781 report_count(1); 3782 report_error("BAD ARGUMENT"); 3783 return; 3784 } 3785 3786 /* XXX - call3 */ 3787 report_count(3); 3788 report_return(pair_content(pair, &fore, &back)); 3789 report_int(fore); 3790 report_int(back); 3791 } 3792 3793 3794 void 3795 cmd_pechochar(int nargs, char **args) 3796 { 3797 int ch; 3798 WINDOW *pad; 3799 3800 if (check_arg_count(nargs, 2) == 1) 3801 return; 3802 3803 if (sscanf(args[0], "%p", &pad) == 0) { 3804 report_count(1); 3805 report_error("BAD ARGUMENT"); 3806 return; 3807 } 3808 3809 if (sscanf(args[1], "%d", &ch) == 0) { 3810 report_count(1); 3811 report_error("BAD ARGUMENT"); 3812 return; 3813 } 3814 3815 report_count(1); 3816 report_return(pechochar(pad, ch)); 3817 } 3818 3819 3820 void 3821 cmd_pnoutrefresh(int nargs, char **args) 3822 { 3823 int pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, smax_x; 3824 WINDOW *pad; 3825 3826 if (check_arg_count(nargs, 7) == 1) 3827 return; 3828 3829 if (sscanf(args[0], "%p", &pad) == 0) { 3830 report_count(1); 3831 report_error("BAD ARGUMENT"); 3832 return; 3833 } 3834 3835 if (sscanf(args[1], "%d", &pbeg_y) == 0) { 3836 report_count(1); 3837 report_error("BAD ARGUMENT"); 3838 return; 3839 } 3840 3841 if (sscanf(args[2], "%d", &pbeg_x) == 0) { 3842 report_count(1); 3843 report_error("BAD ARGUMENT"); 3844 return; 3845 } 3846 3847 if (sscanf(args[3], "%d", &sbeg_y) == 0) { 3848 report_count(1); 3849 report_error("BAD ARGUMENT"); 3850 return; 3851 } 3852 3853 if (sscanf(args[4], "%d", &sbeg_x) == 0) { 3854 report_count(1); 3855 report_error("BAD ARGUMENT"); 3856 return; 3857 } 3858 3859 if (sscanf(args[5], "%d", &smax_y) == 0) { 3860 report_count(1); 3861 report_error("BAD ARGUMENT"); 3862 return; 3863 } 3864 3865 if (sscanf(args[6], "%d", &smax_x) == 0) { 3866 report_count(1); 3867 report_error("BAD ARGUMENT"); 3868 return; 3869 } 3870 3871 report_count(1); 3872 report_return(pnoutrefresh(pad, pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, 3873 smax_x)); 3874 } 3875 3876 3877 void 3878 cmd_prefresh(int nargs, char **args) 3879 { 3880 int pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, smax_x; 3881 WINDOW *pad; 3882 3883 if (check_arg_count(nargs, 7) == 1) 3884 return; 3885 3886 if (sscanf(args[0], "%p", &pad) == 0) { 3887 report_count(1); 3888 report_error("BAD ARGUMENT"); 3889 return; 3890 } 3891 3892 if (sscanf(args[1], "%d", &pbeg_y) == 0) { 3893 report_count(1); 3894 report_error("BAD ARGUMENT"); 3895 return; 3896 } 3897 3898 if (sscanf(args[2], "%d", &pbeg_x) == 0) { 3899 report_count(1); 3900 report_error("BAD ARGUMENT"); 3901 return; 3902 } 3903 3904 if (sscanf(args[3], "%d", &sbeg_y) == 0) { 3905 report_count(1); 3906 report_error("BAD ARGUMENT"); 3907 return; 3908 } 3909 3910 if (sscanf(args[4], "%d", &sbeg_x) == 0) { 3911 report_count(1); 3912 report_error("BAD ARGUMENT"); 3913 return; 3914 } 3915 3916 if (sscanf(args[5], "%d", &smax_y) == 0) { 3917 report_count(1); 3918 report_error("BAD ARGUMENT"); 3919 return; 3920 } 3921 3922 if (sscanf(args[6], "%d", &smax_x) == 0) { 3923 report_count(1); 3924 report_error("BAD ARGUMENT"); 3925 return; 3926 } 3927 3928 /* XXX causes refresh */ 3929 report_count(1); 3930 report_return(prefresh(pad, pbeg_y, pbeg_x, sbeg_y, sbeg_x, smax_y, 3931 smax_x)); 3932 3933 } 3934 3935 3936 void 3937 cmd_printw(int nargs, char **args) 3938 { 3939 if (check_arg_count(nargs, 2) == 1) 3940 return; 3941 3942 3943 report_count(1); 3944 report_return(printw(args[0], args[1])); 3945 } 3946 3947 3948 void 3949 cmd_putwin(int nargs, char **args) 3950 { 3951 FILE *fp; 3952 WINDOW *win; 3953 3954 if (check_arg_count(nargs, 2) == 1) 3955 return; 3956 3957 if (sscanf(args[0], "%p", &win) == 0) { 3958 report_count(1); 3959 report_error("BAD ARGUMENT"); 3960 return; 3961 } 3962 3963 if ((fp = fopen(args[1], "rw")) == NULL) { 3964 report_count(1); 3965 report_error("BAD FILE_ARGUMENT"); 3966 return; 3967 } 3968 3969 report_count(1); 3970 report_return(putwin(win, fp)); 3971 } 3972 3973 3974 void 3975 cmd_qiflush(int nargs, char **args) 3976 { 3977 if (check_arg_count(nargs, 0) == 1) 3978 return; 3979 3980 qiflush(); 3981 report_count(1); 3982 report_return(OK); /* fake a return because call returns void */ 3983 } 3984 3985 3986 void 3987 cmd_raw(int nargs, char **args) 3988 { 3989 if (check_arg_count(nargs, 0) == 1) 3990 return; 3991 3992 report_count(1); 3993 report_return(raw()); 3994 } 3995 3996 3997 void 3998 cmd_redrawwin(int nargs, char **args) 3999 { 4000 WINDOW *win; 4001 4002 if (check_arg_count(nargs, 1) == 1) 4003 return; 4004 4005 if (sscanf(args[0], "%p", &win) == 0) { 4006 report_count(1); 4007 report_error("BAD ARGUMENT"); 4008 return; 4009 } 4010 4011 report_count(1); 4012 report_return(redrawwin(win)); 4013 } 4014 4015 4016 void 4017 cmd_reset_prog_mode(int nargs, char **args) 4018 { 4019 if (check_arg_count(nargs, 0) == 1) 4020 return; 4021 4022 report_count(1); 4023 report_return(reset_prog_mode()); 4024 } 4025 4026 4027 void 4028 cmd_reset_shell_mode(int nargs, char **args) 4029 { 4030 if (check_arg_count(nargs, 0) == 1) 4031 return; 4032 4033 report_count(1); 4034 report_return(reset_shell_mode()); 4035 } 4036 4037 4038 void 4039 cmd_resetty(int nargs, char **args) 4040 { 4041 if (check_arg_count(nargs, 0) == 1) 4042 return; 4043 4044 report_count(1); 4045 report_return(resetty()); 4046 } 4047 4048 4049 void 4050 cmd_resizeterm(int nargs, char **args) 4051 { 4052 int rows, cols; 4053 4054 if (check_arg_count(nargs, 2) == 1) 4055 return; 4056 4057 if (sscanf(args[0], "%d", &rows) == 0) { 4058 report_count(1); 4059 report_error("BAD ARGUMENT"); 4060 return; 4061 } 4062 4063 if (sscanf(args[1], "%d", &cols) == 0) { 4064 report_count(1); 4065 report_error("BAD ARGUMENT"); 4066 return; 4067 } 4068 4069 report_count(1); 4070 report_return(resizeterm(rows, cols)); 4071 } 4072 4073 4074 void 4075 cmd_savetty(int nargs, char **args) 4076 { 4077 if (check_arg_count(nargs, 0) == 1) 4078 return; 4079 4080 report_count(1); 4081 report_return(savetty()); 4082 } 4083 4084 4085 void 4086 cmd_scanw(int nargs, char **args) 4087 { 4088 char string[256]; 4089 4090 if (check_arg_count(nargs, 0) == 1) 4091 return; 4092 4093 /* XXX call2 */ 4094 report_count(2); 4095 report_return(scanw("%s", string)); 4096 report_status(string); 4097 } 4098 4099 4100 void 4101 cmd_scroll(int nargs, char **args) 4102 { 4103 WINDOW *win; 4104 4105 if (check_arg_count(nargs, 1) == 1) 4106 return; 4107 4108 if (sscanf(args[0], "%p", &win) == 0) { 4109 report_count(1); 4110 report_error("BAD ARGUMENT"); 4111 return; 4112 } 4113 4114 report_count(1); 4115 report_return(scroll(win)); 4116 } 4117 4118 4119 void 4120 cmd_scrollok(int nargs, char **args) 4121 { 4122 WINDOW *win; 4123 int flag; 4124 4125 if (check_arg_count(nargs, 2) == 1) 4126 return; 4127 4128 if (sscanf(args[0], "%p", &win) == 0) { 4129 report_count(1); 4130 report_error("BAD ARGUMENT"); 4131 return; 4132 } 4133 4134 if (sscanf(args[1], "%d", &flag) == 0) { 4135 report_count(1); 4136 report_error("BAD ARGUMENT"); 4137 return; 4138 } 4139 4140 report_count(1); 4141 report_return(scrollok(win, flag)); 4142 } 4143 4144 4145 void 4146 cmd_setterm(int nargs, char **args) 4147 { 4148 if (check_arg_count(nargs, 1) == 1) 4149 return; 4150 4151 report_count(1); 4152 report_return(setterm(args[0])); 4153 } 4154 4155 4156 void 4157 cmd_set_term(int nargs, char **args) 4158 { 4159 SCREEN *scrn; 4160 4161 if (check_arg_count(nargs, 1) == 1) 4162 return; 4163 4164 if (sscanf(args[0], "%p", &scrn) == 0) { 4165 report_count(1); 4166 report_error("BAD ARGUMENT"); 4167 return; 4168 } 4169 4170 report_count(1); 4171 report_ptr(set_term(scrn)); 4172 } 4173 4174 4175 void 4176 cmd_start_color(int nargs, char **args) 4177 { 4178 if (check_arg_count(nargs, 0) == 1) 4179 return; 4180 4181 report_count(1); 4182 report_return(start_color()); 4183 } 4184 4185 4186 void 4187 cmd_subpad(int nargs, char **args) 4188 { 4189 WINDOW *pad; 4190 int lines, cols, begin_y, begin_x; 4191 4192 if (check_arg_count(nargs, 5) == 1) 4193 return; 4194 4195 if (sscanf(args[0], "%p", &pad) == 0) { 4196 report_count(1); 4197 report_error("BAD ARGUMENT"); 4198 return; 4199 } 4200 4201 if (sscanf(args[1], "%d", &lines) == 0) { 4202 report_count(1); 4203 report_error("BAD ARGUMENT"); 4204 return; 4205 } 4206 4207 if (sscanf(args[2], "%d", &cols) == 0) { 4208 report_count(1); 4209 report_error("BAD ARGUMENT"); 4210 return; 4211 } 4212 4213 if (sscanf(args[3], "%d", &begin_y) == 0) { 4214 report_count(1); 4215 report_error("BAD ARGUMENT"); 4216 return; 4217 } 4218 4219 if (sscanf(args[4], "%d", &begin_x) == 0) { 4220 report_count(1); 4221 report_error("BAD ARGUMENT"); 4222 return; 4223 } 4224 4225 report_count(1); 4226 report_ptr(subpad(pad, lines, cols, begin_y, begin_x)); 4227 } 4228 4229 4230 void 4231 cmd_subwin(int nargs, char **args) 4232 { 4233 WINDOW *win; 4234 int lines, cols, begin_y, begin_x; 4235 4236 if (check_arg_count(nargs, 5) == 1) 4237 return; 4238 4239 if (sscanf(args[0], "%p", &win) == 0) { 4240 report_count(1); 4241 report_error("BAD ARGUMENT"); 4242 return; 4243 } 4244 4245 if (sscanf(args[1], "%d", &lines) == 0) { 4246 report_count(1); 4247 report_error("BAD ARGUMENT"); 4248 return; 4249 } 4250 4251 if (sscanf(args[2], "%d", &cols) == 0) { 4252 report_count(1); 4253 report_error("BAD ARGUMENT"); 4254 return; 4255 } 4256 4257 if (sscanf(args[3], "%d", &begin_y) == 0) { 4258 report_count(1); 4259 report_error("BAD ARGUMENT"); 4260 return; 4261 } 4262 4263 if (sscanf(args[4], "%d", &begin_x) == 0) { 4264 report_count(1); 4265 report_error("BAD ARGUMENT"); 4266 return; 4267 } 4268 4269 report_count(1); 4270 report_ptr(subwin(win, lines, cols, begin_y, begin_x)); 4271 } 4272 4273 4274 void 4275 cmd_termattrs(int nargs, char **args) 4276 { 4277 if (check_arg_count(nargs, 0) == 1) 4278 return; 4279 4280 report_count(1); 4281 report_int(termattrs()); 4282 } 4283 4284 4285 void 4286 cmd_term_attrs(int nargs, char **args) 4287 { 4288 if (check_arg_count(nargs, 0) == 1) 4289 return; 4290 4291 report_count(1); 4292 report_int(term_attrs()); 4293 } 4294 4295 4296 void 4297 cmd_touchline(int nargs, char **args) 4298 { 4299 WINDOW *win; 4300 int start, count; 4301 4302 if (check_arg_count(nargs, 3) == 1) 4303 return; 4304 4305 if (sscanf(args[0], "%p", &win) == 0) { 4306 report_count(1); 4307 report_error("BAD ARGUMENT"); 4308 return; 4309 } 4310 4311 if (sscanf(args[1], "%d", &start) == 0) { 4312 report_count(1); 4313 report_error("BAD ARGUMENT"); 4314 return; 4315 } 4316 4317 if (sscanf(args[2], "%d", &count) == 0) { 4318 report_count(1); 4319 report_error("BAD ARGUMENT"); 4320 return; 4321 } 4322 4323 report_count(1); 4324 report_return(touchline(win, start, count)); 4325 } 4326 4327 4328 void 4329 cmd_touchoverlap(int nargs, char **args) 4330 { 4331 WINDOW *win1, *win2; 4332 4333 if (check_arg_count(nargs, 2) == 1) 4334 return; 4335 4336 if (sscanf(args[0], "%p", &win1) == 0) { 4337 report_count(1); 4338 report_error("BAD ARGUMENT"); 4339 return; 4340 } 4341 4342 if (sscanf(args[1], "%p", &win2) == 0) { 4343 report_count(1); 4344 report_error("BAD ARGUMENT"); 4345 return; 4346 } 4347 4348 report_count(1); 4349 report_return(touchoverlap(win1, win2)); 4350 } 4351 4352 4353 void 4354 cmd_touchwin(int nargs, char **args) 4355 { 4356 WINDOW *win; 4357 4358 if (check_arg_count(nargs, 1) == 1) 4359 return; 4360 4361 if (sscanf(args[0], "%p", &win) == 0) { 4362 report_count(1); 4363 report_error("BAD ARGUMENT"); 4364 return; 4365 } 4366 4367 report_count(1); 4368 report_return(touchwin(win)); 4369 } 4370 4371 4372 void 4373 cmd_ungetch(int nargs, char **args) 4374 { 4375 int ch; 4376 4377 if (check_arg_count(nargs, 1) == 1) 4378 return; 4379 4380 if (sscanf(args[0], "%d", &ch) == 0) { 4381 report_count(1); 4382 report_error("BAD ARGUMENT"); 4383 return; 4384 } 4385 4386 report_count(1); 4387 report_return(ungetch(ch)); 4388 } 4389 4390 4391 void 4392 cmd_untouchwin(int nargs, char **args) 4393 { 4394 WINDOW *win; 4395 4396 if (check_arg_count(nargs, 1) == 1) 4397 return; 4398 4399 if (sscanf(args[0], "%p", &win) == 0) { 4400 report_count(1); 4401 report_error("BAD ARGUMENT"); 4402 return; 4403 } 4404 4405 report_count(1); 4406 report_return(untouchwin(win)); 4407 } 4408 4409 4410 void 4411 cmd_use_default_colors(int nargs, char **args) 4412 { 4413 if (check_arg_count(nargs, 0) == 1) 4414 return; 4415 4416 report_count(1); 4417 report_return(use_default_colors()); 4418 } 4419 4420 4421 void 4422 cmd_vline(int nargs, char **args) 4423 { 4424 int ch, count; 4425 4426 if (check_arg_count(nargs, 2) == 1) 4427 return; 4428 4429 if (sscanf(args[0], "%d", &ch) == 0) { 4430 report_count(1); 4431 report_error("BAD ARGUMENT"); 4432 return; 4433 } 4434 4435 if (sscanf(args[1], "%d", &count) == 0) { 4436 report_count(1); 4437 report_error("BAD ARGUMENT"); 4438 return; 4439 } 4440 4441 report_count(1); 4442 report_return(vline(ch, count)); 4443 } 4444 4445 4446 static int 4447 internal_vw_printw(WINDOW *win, char *arg1, ...) 4448 { 4449 va_list va; 4450 int rv; 4451 4452 va_start(va, arg1); 4453 rv = vw_printw(win, arg1, va); 4454 va_end(va); 4455 4456 return rv; 4457 } 4458 4459 void 4460 cmd_vw_printw(int nargs, char **args) 4461 { 4462 WINDOW *win; 4463 4464 if (check_arg_count(nargs, 3) == 1) 4465 return; 4466 4467 if (sscanf(args[0], "%p", &win) == 0) { 4468 report_count(1); 4469 report_error("BAD ARGUMENT"); 4470 return; 4471 } 4472 4473 report_count(1); 4474 report_return(internal_vw_printw(win, args[1], args[2])); 4475 } 4476 4477 4478 static int 4479 internal_vw_scanw(WINDOW *win, char *arg1, ...) 4480 { 4481 va_list va; 4482 int rv; 4483 4484 va_start(va, arg1); 4485 rv = vw_scanw(win, arg1, va); 4486 va_end(va); 4487 4488 return rv; 4489 } 4490 4491 void 4492 cmd_vw_scanw(int nargs, char **args) 4493 { 4494 WINDOW *win; 4495 char string[256]; 4496 4497 if (check_arg_count(nargs, 2) == 1) 4498 return; 4499 4500 if (sscanf(args[0], "%p", &win) == 0) { 4501 report_count(1); 4502 report_error("BAD ARGUMENT"); 4503 return; 4504 } 4505 4506 /* XXX - call2 */ 4507 report_count(2); 4508 report_int(internal_vw_scanw(win, args[1], string)); 4509 report_status(string); 4510 } 4511 4512 4513 void 4514 cmd_vwprintw(int nargs, char **args) 4515 { 4516 cmd_vw_printw(nargs, args); 4517 } 4518 4519 4520 void 4521 cmd_vwscanw(int nargs, char **args) 4522 { 4523 cmd_vw_scanw(nargs, args); 4524 } 4525 4526 4527 void 4528 cmd_waddch(int nargs, char **args) 4529 { 4530 WINDOW *win; 4531 chtype *ch; 4532 4533 if (check_arg_count(nargs, 2) == 1) 4534 return; 4535 4536 if (sscanf(args[0], "%p", &win) == 0) { 4537 report_count(1); 4538 report_error("BAD ARGUMENT"); 4539 return; 4540 } 4541 4542 ch = (chtype *) args[1]; 4543 4544 report_count(1); 4545 report_return(waddch(win, ch[0])); 4546 } 4547 4548 4549 void 4550 cmd_waddchnstr(int nargs, char **args) 4551 { 4552 WINDOW *win; 4553 int count; 4554 4555 if (check_arg_count(nargs, 3) == 1) 4556 return; 4557 4558 if (sscanf(args[0], "%p", &win) == 0) { 4559 report_count(1); 4560 report_error("BAD ARGUMENT"); 4561 return; 4562 } 4563 4564 if (sscanf(args[2], "%d", &count) == 0) { 4565 report_count(1); 4566 report_error("BAD ARGUMENT"); 4567 return; 4568 } 4569 4570 report_count(1); 4571 report_return(waddchnstr(win, (chtype *) args[1], count)); 4572 } 4573 4574 4575 void 4576 cmd_waddchstr(int nargs, char **args) 4577 { 4578 WINDOW *win; 4579 4580 if (check_arg_count(nargs, 2) == 1) 4581 return; 4582 4583 if (sscanf(args[0], "%p", &win) == 0) { 4584 report_count(1); 4585 report_error("BAD ARGUMENT"); 4586 return; 4587 } 4588 4589 report_count(1); 4590 report_return(waddchstr(win, (chtype *) args[1])); 4591 } 4592 4593 4594 void 4595 cmd_waddnstr(int nargs, char **args) 4596 { 4597 WINDOW *win; 4598 int count; 4599 4600 if (check_arg_count(nargs, 1) == 3) 4601 return; 4602 4603 if (sscanf(args[0], "%p", &win) == 0) { 4604 report_count(1); 4605 report_error("BAD ARGUMENT"); 4606 return; 4607 } 4608 4609 if (sscanf(args[2], "%d", &count) == 0) { 4610 report_count(1); 4611 report_error("BAD ARGUMENT"); 4612 return; 4613 } 4614 4615 report_count(1); 4616 report_return(waddnstr(win, args[1], count)); 4617 4618 } 4619 4620 4621 void 4622 cmd_wattr_get(int nargs, char **args) 4623 { 4624 WINDOW *win; 4625 int attr; 4626 short pair; 4627 4628 if (check_arg_count(nargs, 1) == 1) 4629 return; 4630 4631 if (sscanf(args[0], "%p", &win) == 0) { 4632 report_count(1); 4633 report_error("BAD ARGUMENT"); 4634 return; 4635 } 4636 4637 /* XXX - call3 */ 4638 report_count(3); 4639 report_return(wattr_get(win, &attr, &pair, NULL)); 4640 report_int(attr); 4641 report_int(pair); 4642 } 4643 4644 4645 void 4646 cmd_wattr_off(int nargs, char **args) 4647 { 4648 WINDOW *win; 4649 int attr; 4650 4651 if (check_arg_count(nargs, 2) == 1) 4652 return; 4653 4654 if (sscanf(args[0], "%p", &win) == 0) { 4655 report_count(1); 4656 report_error("BAD ARGUMENT"); 4657 return; 4658 } 4659 4660 if (sscanf(args[1], "%d", &attr) == 0) { 4661 report_count(1); 4662 report_error("BAD ARGUMENT"); 4663 return; 4664 } 4665 4666 report_count(1); 4667 report_return(wattr_off(win, attr, NULL)); 4668 } 4669 4670 4671 void 4672 cmd_wattr_on(int nargs, char **args) 4673 { 4674 WINDOW *win; 4675 int attr; 4676 4677 if (check_arg_count(nargs, 2) == 1) 4678 return; 4679 4680 if (sscanf(args[0], "%p", &win) == 0) { 4681 report_count(1); 4682 report_error("BAD ARGUMENT"); 4683 return; 4684 } 4685 4686 if (sscanf(args[1], "%d", &attr) == 0) { 4687 report_count(1); 4688 report_error("BAD ARGUMENT"); 4689 return; 4690 } 4691 4692 report_count(1); 4693 report_return(wattr_on(win, attr, NULL)); 4694 } 4695 4696 4697 void 4698 cmd_wattr_set(int nargs, char **args) 4699 { 4700 WINDOW *win; 4701 int attr; 4702 short pair; 4703 4704 if (check_arg_count(nargs, 3) == 1) 4705 return; 4706 4707 if (sscanf(args[0], "%p", &win) == 0) { 4708 report_count(1); 4709 report_error("BAD ARGUMENT"); 4710 return; 4711 } 4712 4713 if (sscanf(args[1], "%d", &attr) == 0) { 4714 report_count(1); 4715 report_error("BAD ARGUMENT"); 4716 return; 4717 } 4718 4719 if (sscanf(args[2], "%hd", &pair) == 0) { 4720 report_count(1); 4721 report_error("BAD ARGUMENT"); 4722 return; 4723 } 4724 4725 report_count(1); 4726 report_return(wattr_set(win, attr, pair, NULL)); 4727 } 4728 4729 4730 void 4731 cmd_wattroff(int nargs, char **args) 4732 { 4733 WINDOW *win; 4734 int attr; 4735 4736 if (check_arg_count(nargs, 2) == 1) 4737 return; 4738 4739 if (sscanf(args[0], "%p", &win) == 0) { 4740 report_count(1); 4741 report_error("BAD ARGUMENT"); 4742 return; 4743 } 4744 4745 if (sscanf(args[1], "%d", &attr) == 0) { 4746 report_count(1); 4747 report_error("BAD ARGUMENT"); 4748 return; 4749 } 4750 4751 report_count(1); 4752 report_return(wattroff(win, attr)); 4753 } 4754 4755 4756 void 4757 cmd_wattron(int nargs, char **args) 4758 { 4759 WINDOW *win; 4760 int attr; 4761 4762 if (check_arg_count(nargs, 2) == 1) 4763 return; 4764 4765 if (sscanf(args[0], "%p", &win) == 0) { 4766 report_count(1); 4767 report_error("BAD ARGUMENT"); 4768 return; 4769 } 4770 4771 if (sscanf(args[1], "%d", &attr) == 0) { 4772 report_count(1); 4773 report_error("BAD ARGUMENT"); 4774 return; 4775 } 4776 4777 report_count(1); 4778 report_return(wattron(win, attr)); 4779 } 4780 4781 4782 void 4783 cmd_wattrset(int nargs, char **args) 4784 { 4785 WINDOW *win; 4786 int attr; 4787 4788 if (check_arg_count(nargs, 2) == 1) 4789 return; 4790 4791 if (sscanf(args[0], "%p", &win) == 0) { 4792 report_count(1); 4793 report_error("BAD ARGUMENT"); 4794 return; 4795 } 4796 4797 if (sscanf(args[1], "%d", &attr) == 0) { 4798 report_count(1); 4799 report_error("BAD ARGUMENT"); 4800 return; 4801 } 4802 4803 report_count(1); 4804 report_return(wattrset(win, attr)); 4805 } 4806 4807 4808 void 4809 cmd_wbkgd(int nargs, char **args) 4810 { 4811 WINDOW *win; 4812 chtype *ch; 4813 4814 if (check_arg_count(nargs, 2) == 1) 4815 return; 4816 4817 if (sscanf(args[0], "%p", &win) == 0) { 4818 report_count(1); 4819 report_error("BAD ARGUMENT"); 4820 return; 4821 } 4822 4823 ch = (chtype *) args[1]; 4824 report_count(1); 4825 report_return(wbkgd(win, ch[0])); 4826 } 4827 4828 4829 void 4830 cmd_wbkgdset(int nargs, char **args) 4831 { 4832 WINDOW *win; 4833 int ch; 4834 4835 if (check_arg_count(nargs, 2) == 1) 4836 return; 4837 4838 if (sscanf(args[0], "%p", &win) == 0) { 4839 report_count(1); 4840 report_error("BAD ARGUMENT"); 4841 return; 4842 } 4843 4844 if (sscanf(args[1], "%d", &ch) == 0) { 4845 report_count(1); 4846 report_error("BAD ARGUMENT"); 4847 return; 4848 } 4849 4850 wbkgdset(win, ch); /* void return */ 4851 report_count(1); 4852 report_return(OK); 4853 } 4854 4855 4856 void 4857 cmd_wborder(int nargs, char **args) 4858 { 4859 WINDOW *win; 4860 int ls, rs, ts, bs, tl, tr, bl, br; 4861 4862 if (check_arg_count(nargs, 9) == 1) 4863 return; 4864 4865 if (sscanf(args[0], "%p", &win) == 0) { 4866 report_count(1); 4867 report_error("BAD ARGUMENT"); 4868 return; 4869 } 4870 4871 if (sscanf(args[1], "%d", &ls) == 0) { 4872 report_count(1); 4873 report_error("BAD ARGUMENT"); 4874 return; 4875 } 4876 4877 if (sscanf(args[2], "%d", &rs) == 0) { 4878 report_count(1); 4879 report_error("BAD ARGUMENT"); 4880 return; 4881 } 4882 4883 if (sscanf(args[3], "%d", &ts) == 0) { 4884 report_count(1); 4885 report_error("BAD ARGUMENT"); 4886 return; 4887 } 4888 4889 if (sscanf(args[4], "%d", &bs) == 0) { 4890 report_count(1); 4891 report_error("BAD ARGUMENT"); 4892 return; 4893 } 4894 4895 if (sscanf(args[5], "%d", &tl) == 0) { 4896 report_count(1); 4897 report_error("BAD ARGUMENT"); 4898 return; 4899 } 4900 4901 if (sscanf(args[6], "%d", &tr) == 0) { 4902 report_count(1); 4903 report_error("BAD ARGUMENT"); 4904 return; 4905 } 4906 4907 if (sscanf(args[7], "%d", &bl) == 0) { 4908 report_count(1); 4909 report_error("BAD ARGUMENT"); 4910 return; 4911 } 4912 4913 if (sscanf(args[8], "%d", &br) == 0) { 4914 report_count(1); 4915 report_error("BAD ARGUMENT"); 4916 return; 4917 } 4918 4919 report_count(1); 4920 report_return(wborder(win, ls, rs, ts, bs, tl, tr, bl, br)); 4921 } 4922 4923 4924 void 4925 cmd_wclear(int nargs, char **args) 4926 { 4927 WINDOW *win; 4928 4929 if (check_arg_count(nargs, 1) == 1) 4930 return; 4931 4932 if (sscanf(args[0], "%p", &win) == 0) { 4933 report_count(1); 4934 report_error("BAD ARGUMENT"); 4935 return; 4936 } 4937 4938 report_count(1); 4939 report_return(wclear(win)); 4940 } 4941 4942 4943 void 4944 cmd_wclrtobot(int nargs, char **args) 4945 { 4946 WINDOW *win; 4947 4948 if (check_arg_count(nargs, 1) == 1) 4949 return; 4950 4951 if (sscanf(args[0], "%p", &win) == 0) { 4952 report_count(1); 4953 report_error("BAD ARGUMENT"); 4954 return; 4955 } 4956 4957 report_count(1); 4958 report_return(wclrtobot(win)); 4959 } 4960 4961 4962 void 4963 cmd_wclrtoeol(int nargs, char **args) 4964 { 4965 WINDOW *win; 4966 4967 if (check_arg_count(nargs, 1) == 1) 4968 return; 4969 4970 if (sscanf(args[0], "%p", &win) == 0) { 4971 report_count(1); 4972 report_error("BAD ARGUMENT"); 4973 return; 4974 } 4975 4976 report_count(1); 4977 report_return(wclrtoeol(win)); 4978 4979 } 4980 4981 4982 void 4983 cmd_wcolor_set(int nargs, char **args) 4984 { 4985 WINDOW *win; 4986 short pair; 4987 4988 if (check_arg_count(nargs, 2) == 1) 4989 return; 4990 4991 if (sscanf(args[0], "%p", &win) == 0) { 4992 report_count(1); 4993 report_error("BAD ARGUMENT"); 4994 return; 4995 } 4996 4997 if (sscanf(args[1], "%hd", &pair) == 0) { 4998 report_count(1); 4999 report_error("BAD ARGUMENT"); 5000 return; 5001 } 5002 5003 report_count(1); 5004 report_return(wcolor_set(win, pair, NULL)); 5005 } 5006 5007 5008 void 5009 cmd_wdelch(int nargs, char **args) 5010 { 5011 WINDOW *win; 5012 5013 if (check_arg_count(nargs, 1) == 1) 5014 return; 5015 5016 if (sscanf(args[0], "%p", &win) == 0) { 5017 report_count(1); 5018 report_error("BAD ARGUMENT"); 5019 return; 5020 } 5021 5022 report_count(1); 5023 report_return(wdelch(win)); 5024 } 5025 5026 5027 void 5028 cmd_wdeleteln(int nargs, char **args) 5029 { 5030 WINDOW *win; 5031 5032 if (check_arg_count(nargs, 1) == 1) 5033 return; 5034 5035 if (sscanf(args[0], "%p", &win) == 0) { 5036 report_count(1); 5037 report_error("BAD ARGUMENT"); 5038 return; 5039 } 5040 5041 report_count(1); 5042 report_return(wdeleteln(win)); 5043 5044 } 5045 5046 5047 void 5048 cmd_wechochar(int nargs, char **args) 5049 { 5050 WINDOW *win; 5051 int ch; 5052 5053 if (check_arg_count(nargs, 2) == 1) 5054 return; 5055 5056 if (sscanf(args[0], "%p", &win) == 0) { 5057 report_count(1); 5058 report_error("BAD ARGUMENT"); 5059 return; 5060 } 5061 5062 if (sscanf(args[1], "%d", &ch) == 0) { 5063 report_count(1); 5064 report_error("BAD ARGUMENT"); 5065 return; 5066 } 5067 5068 report_count(1); 5069 report_return(wechochar(win, ch)); 5070 } 5071 5072 5073 void 5074 cmd_werase(int nargs, char **args) 5075 { 5076 WINDOW *win; 5077 5078 if (check_arg_count(nargs, 1) == 1) 5079 return; 5080 5081 if (sscanf(args[0], "%p", &win) == 0) { 5082 report_count(1); 5083 report_error("BAD ARGUMENT"); 5084 return; 5085 } 5086 5087 report_count(1); 5088 report_return(werase(win)); 5089 } 5090 5091 5092 void 5093 cmd_wgetch(int nargs, char **args) 5094 { 5095 WINDOW *win; 5096 5097 if (check_arg_count(nargs, 1) == 1) 5098 return; 5099 5100 if (sscanf(args[0], "%p", &win) == 0) { 5101 report_count(1); 5102 report_error("BAD ARGUMENT"); 5103 return; 5104 } 5105 5106 report_count(1); 5107 report_int(wgetch(win)); 5108 } 5109 5110 5111 void 5112 cmd_wgetnstr(int nargs, char **args) 5113 { 5114 WINDOW *win; 5115 int count; 5116 char string[256]; 5117 5118 if (check_arg_count(nargs, 2) == 1) 5119 return; 5120 5121 if (sscanf(args[0], "%p", &win) == 0) { 5122 report_count(1); 5123 report_error("BAD ARGUMENT"); 5124 return; 5125 } 5126 5127 if (sscanf(args[1], "%d", &count) == 0) { 5128 report_count(1); 5129 report_error("BAD ARGUMENT"); 5130 return; 5131 } 5132 5133 /* XXX - call2 */ 5134 report_count(2); 5135 report_return(wgetnstr(win, string, count)); 5136 report_status(string); 5137 } 5138 5139 5140 void 5141 cmd_wgetstr(int nargs, char **args) 5142 { 5143 WINDOW *win; 5144 char string[256]; 5145 5146 5147 if (check_arg_count(nargs, 1) == 1) 5148 return; 5149 5150 if (sscanf(args[0], "%p", &win) == 0) { 5151 report_count(1); 5152 report_error("BAD ARGUMENT"); 5153 return; 5154 } 5155 5156 string[0] = '\0'; 5157 5158 report_count(2); 5159 report_return(wgetstr(win, string)); 5160 report_status(string); 5161 } 5162 5163 5164 void 5165 cmd_whline(int nargs, char **args) 5166 { 5167 WINDOW *win; 5168 int ch, count; 5169 5170 if (check_arg_count(nargs, 3) == 1) 5171 return; 5172 5173 if (sscanf(args[0], "%p", &win) == 0) { 5174 report_count(1); 5175 report_error("BAD ARGUMENT"); 5176 return; 5177 } 5178 5179 if (sscanf(args[1], "%d", &ch) == 0) { 5180 report_count(1); 5181 report_error("BAD ARGUMENT"); 5182 return; 5183 } 5184 5185 if (sscanf(args[2], "%d", &count) == 0) { 5186 report_count(1); 5187 report_error("BAD ARGUMENT"); 5188 return; 5189 } 5190 5191 report_count(1); 5192 report_return(whline(win, ch, count)); 5193 } 5194 5195 5196 void 5197 cmd_winch(int nargs, char **args) 5198 { 5199 WINDOW *win; 5200 5201 if (check_arg_count(nargs, 1) == 1) 5202 return; 5203 5204 if (sscanf(args[0], "%p", &win) == 0) { 5205 report_count(1); 5206 report_error("BAD ARGUMENT"); 5207 return; 5208 } 5209 5210 report_count(1); 5211 report_int(winch(win)); 5212 } 5213 5214 5215 void 5216 cmd_winchnstr(int nargs, char **args) 5217 { 5218 WINDOW *win; 5219 chtype string[256]; 5220 int count; 5221 5222 if (check_arg_count(nargs, 2) == 1) 5223 return; 5224 5225 if (sscanf(args[0], "%p", &win) == 0) { 5226 report_count(1); 5227 report_error("BAD ARGUMENT"); 5228 return; 5229 } 5230 5231 if (sscanf(args[1], "%d", &count) == 0) { 5232 report_count(1); 5233 report_error("BAD ARGUMENT"); 5234 return; 5235 } 5236 5237 /* XXX - call2 */ 5238 report_count(2); 5239 report_return(winchnstr(win, string, count)); 5240 report_nstr(string); 5241 } 5242 5243 5244 void 5245 cmd_winchstr(int nargs, char **args) 5246 { 5247 WINDOW *win; 5248 chtype string[256]; 5249 5250 if (check_arg_count(nargs, 1) == 1) 5251 return; 5252 5253 if (sscanf(args[0], "%p", &win) == 0) { 5254 report_count(1); 5255 report_error("BAD ARGUMENT"); 5256 return; 5257 } 5258 5259 /* XXX - call2 */ 5260 report_count(2); 5261 report_return(winchstr(win, string)); 5262 report_nstr(string); 5263 } 5264 5265 5266 void 5267 cmd_winnstr(int nargs, char **args) 5268 { 5269 WINDOW *win; 5270 char string[256]; 5271 int count; 5272 5273 if (check_arg_count(nargs, 2) == 1) 5274 return; 5275 5276 if (sscanf(args[0], "%p", &win) == 0) { 5277 report_count(1); 5278 report_error("BAD ARGUMENT"); 5279 return; 5280 } 5281 5282 if (sscanf(args[1], "%d", &count) == 0) { 5283 report_count(1); 5284 report_error("BAD ARGUMENT"); 5285 return; 5286 } 5287 5288 /* XXX - call2 */ 5289 report_count(2); 5290 report_return(winnstr(win, string, count)); 5291 report_status(string); 5292 } 5293 5294 5295 void 5296 cmd_winsch(int nargs, char **args) 5297 { 5298 WINDOW *win; 5299 int ch; 5300 5301 if (check_arg_count(nargs, 2) == 1) 5302 return; 5303 5304 if (sscanf(args[0], "%p", &win) == 0) { 5305 report_count(1); 5306 report_error("BAD ARGUMENT"); 5307 return; 5308 } 5309 5310 if (sscanf(args[1], "%d", &ch) == 0) { 5311 report_count(1); 5312 report_error("BAD ARGUMENT"); 5313 return; 5314 } 5315 5316 report_count(1); 5317 report_return(winsch(win, ch)); 5318 } 5319 5320 5321 void 5322 cmd_winsdelln(int nargs, char **args) 5323 { 5324 WINDOW *win; 5325 int count; 5326 5327 if (check_arg_count(nargs, 2) == 1) 5328 return; 5329 5330 if (sscanf(args[0], "%p", &win) == 0) { 5331 report_count(1); 5332 report_error("BAD ARGUMENT"); 5333 return; 5334 } 5335 5336 if (sscanf(args[1], "%d", &count) == 0) { 5337 report_count(1); 5338 report_error("BAD ARGUMENT"); 5339 return; 5340 } 5341 5342 report_count(1); 5343 report_return(winsdelln(win, count)); 5344 } 5345 5346 5347 void 5348 cmd_winsertln(int nargs, char **args) 5349 { 5350 WINDOW *win; 5351 5352 if (check_arg_count(nargs, 1) == 1) 5353 return; 5354 5355 if (sscanf(args[0], "%p", &win) == 0) { 5356 report_count(1); 5357 report_error("BAD ARGUMENT"); 5358 return; 5359 } 5360 5361 report_count(1); 5362 report_return(winsertln(win)); 5363 } 5364 5365 5366 void 5367 cmd_winstr(int nargs, char **args) 5368 { 5369 WINDOW *win; 5370 char string[256]; 5371 5372 if (check_arg_count(nargs, 1) == 1) 5373 return; 5374 5375 if (sscanf(args[0], "%p", &win) == 0) { 5376 report_count(1); 5377 report_error("BAD ARGUMENT"); 5378 return; 5379 } 5380 5381 /* XXX - call2 */ 5382 report_count(2); 5383 report_return(winstr(win, string)); 5384 report_status(string); 5385 } 5386 5387 5388 void 5389 cmd_wmove(int nargs, char **args) 5390 { 5391 WINDOW *win; 5392 int y, x; 5393 5394 if (check_arg_count(nargs, 3) == 1) 5395 return; 5396 5397 if (sscanf(args[0], "%p", &win) == 0) { 5398 report_count(1); 5399 report_error("BAD ARGUMENT"); 5400 return; 5401 } 5402 5403 if (sscanf(args[1], "%d", &y) == 0) { 5404 report_count(1); 5405 report_error("BAD ARGUMENT"); 5406 return; 5407 } 5408 5409 if (sscanf(args[2], "%d", &x) == 0) { 5410 report_count(1); 5411 report_error("BAD ARGUMENT"); 5412 return; 5413 } 5414 5415 report_count(1); 5416 report_return(wmove(win, y, x)); 5417 } 5418 5419 5420 void 5421 cmd_wnoutrefresh(int nargs, char **args) 5422 { 5423 WINDOW *win; 5424 5425 if (check_arg_count(nargs, 1) == 1) 5426 return; 5427 5428 if (sscanf(args[0], "%p", &win) == 0) { 5429 report_count(1); 5430 report_error("BAD ARGUMENT"); 5431 return; 5432 } 5433 5434 report_count(1); 5435 report_return(wnoutrefresh(win)); 5436 } 5437 5438 5439 void 5440 cmd_wprintw(int nargs, char **args) 5441 { 5442 WINDOW *win; 5443 5444 if (check_arg_count(nargs, 3) == 1) 5445 return; 5446 5447 if (sscanf(args[0], "%p", &win) == 0) { 5448 report_count(1); 5449 report_error("BAD ARGUMENT"); 5450 return; 5451 } 5452 5453 report_count(1); 5454 report_return(wprintw(win, args[1], args[2])); 5455 } 5456 5457 5458 void 5459 cmd_wredrawln(int nargs, char **args) 5460 { 5461 WINDOW *win; 5462 int beg_line, num_lines; 5463 5464 if (check_arg_count(nargs, 3) == 1) 5465 return; 5466 5467 if (sscanf(args[0], "%p", &win) == 0) { 5468 report_count(1); 5469 report_error("BAD ARGUMENT"); 5470 return; 5471 } 5472 5473 if (sscanf(args[1], "%d", &beg_line) == 0) { 5474 report_count(1); 5475 report_error("BAD ARGUMENT"); 5476 return; 5477 } 5478 5479 if (sscanf(args[2], "%d", &num_lines) == 0) { 5480 report_count(1); 5481 report_error("BAD ARGUMENT"); 5482 return; 5483 } 5484 5485 report_count(1); 5486 report_return(wredrawln(win, beg_line, num_lines)); 5487 } 5488 5489 5490 void 5491 cmd_wrefresh(int nargs, char **args) 5492 { 5493 WINDOW *win; 5494 5495 if (check_arg_count(nargs, 1) == 1) 5496 return; 5497 5498 if (sscanf(args[0], "%p", &win) == 0) { 5499 report_count(1); 5500 report_error("BAD ARGUMENT"); 5501 return; 5502 } 5503 5504 /* XXX - generates output */ 5505 report_count(1); 5506 report_return(wrefresh(win)); 5507 } 5508 5509 5510 void 5511 cmd_wresize(int nargs, char **args) 5512 { 5513 WINDOW *win; 5514 int lines, cols; 5515 5516 if (check_arg_count(nargs, 3) == 1) 5517 return; 5518 5519 if (sscanf(args[0], "%p", &win) == 0) { 5520 report_count(1); 5521 report_error("BAD ARGUMENT"); 5522 return; 5523 } 5524 5525 if (sscanf(args[1], "%d", &lines) == 0) { 5526 report_count(1); 5527 report_error("BAD ARGUMENT"); 5528 return; 5529 } 5530 5531 if (sscanf(args[2], "%d", &cols) == 0) { 5532 report_count(1); 5533 report_error("BAD ARGUMENT"); 5534 return; 5535 } 5536 5537 report_count(1); 5538 report_return(wresize(win, lines, cols)); 5539 } 5540 5541 5542 void 5543 cmd_wscanw(int nargs, char **args) 5544 { 5545 WINDOW *win; 5546 char string[256]; 5547 5548 if (check_arg_count(nargs, 2) == 1) 5549 return; 5550 5551 if (sscanf(args[0], "%p", &win) == 0) { 5552 report_count(1); 5553 report_error("BAD ARGUMENT"); 5554 return; 5555 } 5556 5557 report_count(1); 5558 report_return(wscanw(win, args[1], &string)); 5559 } 5560 5561 5562 void 5563 cmd_wscrl(int nargs, char **args) 5564 { 5565 WINDOW *win; 5566 int n; 5567 5568 if (check_arg_count(nargs, 2) == 1) 5569 return; 5570 5571 if (sscanf(args[0], "%p", &win) == 0) { 5572 report_count(1); 5573 report_error("BAD ARGUMENT"); 5574 return; 5575 } 5576 5577 if (sscanf(args[1], "%d", &n) == 0) { 5578 report_count(1); 5579 report_error("BAD ARGUMENT"); 5580 return; 5581 } 5582 5583 report_count(1); 5584 report_return(wscrl(win, n)); 5585 } 5586 5587 5588 void 5589 cmd_wsetscrreg(int nargs, char **args) 5590 { 5591 WINDOW *win; 5592 int top, bottom; 5593 5594 if (check_arg_count(nargs, 3) == 1) 5595 return; 5596 5597 if (sscanf(args[0], "%p", &win) == 0) { 5598 report_count(1); 5599 report_error("BAD ARGUMENT"); 5600 return; 5601 } 5602 5603 if (sscanf(args[1], "%d", &top) == 0) { 5604 report_count(1); 5605 report_error("BAD ARGUMENT"); 5606 return; 5607 } 5608 5609 if (sscanf(args[2], "%d", &bottom) == 0) { 5610 report_count(1); 5611 report_error("BAD ARGUMENT"); 5612 return; 5613 } 5614 5615 report_count(1); 5616 report_return(wsetscrreg(win, top, bottom)); 5617 } 5618 5619 5620 void 5621 cmd_wstandend(int nargs, char **args) 5622 { 5623 WINDOW *win; 5624 5625 if (check_arg_count(nargs, 1) == 1) 5626 return; 5627 5628 if (sscanf(args[0], "%p", &win) == 0) { 5629 report_count(1); 5630 report_error("BAD ARGUMENT"); 5631 return; 5632 } 5633 5634 report_count(1); 5635 report_return(wstandend(win)); 5636 } 5637 5638 5639 void 5640 cmd_wstandout(int nargs, char **args) 5641 { 5642 WINDOW *win; 5643 5644 if (check_arg_count(nargs, 1) == 1) 5645 return; 5646 5647 if (sscanf(args[0], "%p", &win) == 0) { 5648 report_count(1); 5649 report_error("BAD ARGUMENT"); 5650 return; 5651 } 5652 5653 report_count(1); 5654 report_return(wstandout(win)); 5655 } 5656 5657 5658 void 5659 cmd_wtimeout(int nargs, char **args) 5660 { 5661 WINDOW *win; 5662 int tval; 5663 5664 if (check_arg_count(nargs, 2) == 1) 5665 return; 5666 5667 if (sscanf(args[0], "%p", &win) == 0) { 5668 report_count(1); 5669 report_error("BAD ARGUMENT"); 5670 return; 5671 } 5672 5673 if (sscanf(args[1], "%d", &tval) == 0) { 5674 report_count(1); 5675 report_error("BAD ARGUMENT"); 5676 return; 5677 } 5678 5679 wtimeout(win, tval); /* void return */ 5680 report_count(1); 5681 report_return(OK); 5682 } 5683 5684 5685 void 5686 cmd_wtouchln(int nargs, char **args) 5687 { 5688 WINDOW *win; 5689 int line, n, changed; 5690 5691 if (check_arg_count(nargs, 4) == 1) 5692 return; 5693 5694 if (sscanf(args[0], "%p", &win) == 0) { 5695 report_count(1); 5696 report_error("BAD ARGUMENT"); 5697 return; 5698 } 5699 5700 if (sscanf(args[1], "%d", &line) == 0) { 5701 report_count(1); 5702 report_error("BAD ARGUMENT"); 5703 return; 5704 } 5705 5706 if (sscanf(args[2], "%d", &n) == 0) { 5707 report_count(1); 5708 report_error("BAD ARGUMENT"); 5709 return; 5710 } 5711 5712 if (sscanf(args[3], "%d", &changed) == 0) { 5713 report_count(1); 5714 report_error("BAD ARGUMENT"); 5715 return; 5716 } 5717 5718 report_count(1); 5719 report_return(wtouchln(win, line, n, changed)); 5720 } 5721 5722 5723 void 5724 cmd_wunderend(int nargs, char **args) 5725 { 5726 WINDOW *win; 5727 5728 if (check_arg_count(nargs, 1) == 1) 5729 return; 5730 5731 if (sscanf(args[0], "%p", &win) == 0) { 5732 report_count(1); 5733 report_error("BAD ARGUMENT"); 5734 return; 5735 } 5736 5737 report_count(1); 5738 report_return(wunderend(win)); 5739 } 5740 5741 5742 void 5743 cmd_wunderscore(int nargs, char **args) 5744 { 5745 WINDOW *win; 5746 5747 if (check_arg_count(nargs, 1) == 1) 5748 return; 5749 5750 if (sscanf(args[0], "%p", &win) == 0) { 5751 report_count(1); 5752 report_error("BAD ARGUMENT"); 5753 return; 5754 } 5755 5756 report_count(1); 5757 report_return(wunderscore(win)); 5758 } 5759 5760 5761 void 5762 cmd_wvline(int nargs, char **args) 5763 { 5764 WINDOW *win; 5765 int ch, n; 5766 5767 if (check_arg_count(nargs, 3) == 1) 5768 return; 5769 5770 if (sscanf(args[0], "%p", &win) == 0) { 5771 report_count(1); 5772 report_error("BAD ARGUMENT"); 5773 return; 5774 } 5775 5776 if (sscanf(args[1], "%d", &ch) == 0) { 5777 report_count(1); 5778 report_error("BAD ARGUMENT"); 5779 return; 5780 } 5781 5782 if (sscanf(args[2], "%d", &n) == 0) { 5783 report_count(1); 5784 report_error("BAD ARGUMENT"); 5785 return; 5786 } 5787 5788 report_count(1); 5789 report_return(wvline(win, ch, n)); 5790 } 5791 5792 5793 void 5794 cmd_insnstr(int nargs, char **args) 5795 { 5796 int n; 5797 5798 if (check_arg_count(nargs, 2) == 1) 5799 return; 5800 5801 if (sscanf(args[1], "%d", &n) == 0) { 5802 report_count(1); 5803 report_error("BAD ARGUMENT"); 5804 return; 5805 } 5806 5807 report_count(1); 5808 report_return(insnstr(args[0], n)); 5809 } 5810 5811 5812 void 5813 cmd_insstr(int nargs, char **args) 5814 { 5815 if (check_arg_count(nargs, 1) == 1) 5816 return; 5817 5818 report_count(1); 5819 report_return(insstr(args[0])); 5820 } 5821 5822 5823 void 5824 cmd_mvinsnstr(int nargs, char **args) 5825 { 5826 int y, x, n; 5827 5828 if (check_arg_count(nargs, 4) == 1) 5829 return; 5830 5831 if (sscanf(args[0], "%d", &y) == 0) { 5832 report_count(1); 5833 report_error("BAD ARGUMENT"); 5834 return; 5835 } 5836 5837 if (sscanf(args[1], "%d", &x) == 0) { 5838 report_count(1); 5839 report_error("BAD ARGUMENT"); 5840 return; 5841 } 5842 5843 if (sscanf(args[3], "%d", &n) == 0) { 5844 report_count(1); 5845 report_error("BAD ARGUMENT"); 5846 return; 5847 } 5848 5849 report_count(1); 5850 report_return(mvinsnstr(y, x, args[2], n)); 5851 } 5852 5853 5854 void 5855 cmd_mvinsstr(int nargs, char **args) 5856 { 5857 int y, x; 5858 5859 if (check_arg_count(nargs, 3) == 1) 5860 return; 5861 5862 if (sscanf(args[0], "%d", &y) == 0) { 5863 report_count(1); 5864 report_error("BAD ARGUMENT"); 5865 return; 5866 } 5867 5868 if (sscanf(args[1], "%d", &x) == 0) { 5869 report_count(1); 5870 report_error("BAD ARGUMENT"); 5871 return; 5872 } 5873 5874 report_count(1); 5875 report_return(mvinsstr(y, x, args[2])); 5876 } 5877 5878 5879 void 5880 cmd_mvwinsnstr(int nargs, char **args) 5881 { 5882 WINDOW *win; 5883 int y, x, n; 5884 5885 if (check_arg_count(nargs, 5) == 1) 5886 return; 5887 5888 if (sscanf(args[0], "%p", &win) == 0) { 5889 report_count(1); 5890 report_error("BAD ARGUMENT"); 5891 return; 5892 } 5893 5894 if (sscanf(args[1], "%d", &y) == 0) { 5895 report_count(1); 5896 report_error("BAD ARGUMENT"); 5897 return; 5898 } 5899 5900 if (sscanf(args[2], "%d", &x) == 0) { 5901 report_count(1); 5902 report_error("BAD ARGUMENT"); 5903 return; 5904 } 5905 5906 if (sscanf(args[4], "%d", &n) == 0) { 5907 report_count(1); 5908 report_error("BAD ARGUMENT"); 5909 return; 5910 } 5911 5912 report_count(1); 5913 report_return(mvwinsnstr(win, y, x, args[3], n)); 5914 5915 } 5916 5917 5918 void 5919 cmd_mvwinsstr(int nargs, char **args) 5920 { 5921 WINDOW *win; 5922 int y, x; 5923 5924 if (check_arg_count(nargs, 4) == 1) 5925 return; 5926 5927 if (sscanf(args[0], "%p", &win) == 0) { 5928 report_count(1); 5929 report_error("BAD ARGUMENT"); 5930 return; 5931 } 5932 5933 if (sscanf(args[1], "%d", &y) == 0) { 5934 report_count(1); 5935 report_error("BAD ARGUMENT"); 5936 return; 5937 } 5938 5939 if (sscanf(args[2], "%d", &x) == 0) { 5940 report_count(1); 5941 report_error("BAD ARGUMENT"); 5942 return; 5943 } 5944 5945 report_count(1); 5946 report_return(mvwinsstr(win, y, x, args[3])); 5947 } 5948 5949 5950 void 5951 cmd_winsnstr(int nargs, char **args) 5952 { 5953 WINDOW *win; 5954 int n; 5955 5956 if (check_arg_count(nargs, 3) == 1) 5957 return; 5958 5959 if (sscanf(args[0], "%p", &win) == 0) { 5960 report_count(1); 5961 report_error("BAD ARGUMENT"); 5962 return; 5963 } 5964 5965 if (sscanf(args[2], "%d", &n) == 0) { 5966 report_count(1); 5967 report_error("BAD ARGUMENT"); 5968 return; 5969 } 5970 5971 report_count(1); 5972 report_return(winsnstr(win, args[1], n)); 5973 } 5974 5975 5976 void 5977 cmd_winsstr(int nargs, char **args) 5978 { 5979 WINDOW *win; 5980 5981 if (check_arg_count(nargs, 2) == 1) 5982 return; 5983 5984 if (sscanf(args[0], "%p", &win) == 0) { 5985 report_count(1); 5986 report_error("BAD ARGUMENT"); 5987 return; 5988 } 5989 5990 report_count(1); 5991 report_return(winsstr(win, args[1])); 5992 } 5993 5994 5995 5996 void 5997 cmd_chgat(int nargs, char **args) 5998 { 5999 int n, attr, colour; 6000 6001 if (check_arg_count(nargs, 4) == 1) 6002 return; 6003 6004 if (sscanf(args[0], "%d", &n) == 0) { 6005 report_count(1); 6006 report_error("BAD ARGUMENT"); 6007 return; 6008 } 6009 6010 if (sscanf(args[1], "%d", &attr) == 0) { 6011 report_count(1); 6012 report_error("BAD ARGUMENT"); 6013 return; 6014 } 6015 6016 if (sscanf(args[2], "%d", &colour) == 0) { 6017 report_count(1); 6018 report_error("BAD ARGUMENT"); 6019 return; 6020 } 6021 6022 /* Note: 4th argument unused in current curses implementation */ 6023 report_count(1); 6024 report_return(chgat(n, attr, colour, NULL)); 6025 } 6026 6027 6028 void 6029 cmd_wchgat(int nargs, char **args) 6030 { 6031 WINDOW *win; 6032 int n, attr; 6033 short colour; 6034 6035 if (check_arg_count(nargs, 4) == 1) 6036 return; 6037 6038 if (sscanf(args[0], "%p", &win) == 0) { 6039 report_count(1); 6040 report_error("BAD ARGUMENT"); 6041 return; 6042 } 6043 6044 if (sscanf(args[1], "%d", &n) == 0) { 6045 report_count(1); 6046 report_error("BAD ARGUMENT"); 6047 return; 6048 } 6049 6050 if (sscanf(args[2], "%d", &attr) == 0) { 6051 report_count(1); 6052 report_error("BAD ARGUMENT"); 6053 return; 6054 } 6055 6056 if (sscanf(args[3], "%hd", &colour) == 0) { 6057 report_count(1); 6058 report_error("BAD ARGUMENT"); 6059 return; 6060 } 6061 6062 report_count(1); 6063 report_return(wchgat(win, n, attr, colour, NULL)); 6064 } 6065 6066 6067 void 6068 cmd_mvchgat(int nargs, char **args) 6069 { 6070 int y, x, n, attr; 6071 short colour; 6072 6073 if (check_arg_count(nargs, 6) == 1) 6074 return; 6075 6076 if (sscanf(args[0], "%d", &y) == 0) { 6077 report_count(1); 6078 report_error("BAD ARGUMENT"); 6079 return; 6080 } 6081 6082 if (sscanf(args[1], "%d", &x) == 0) { 6083 report_count(1); 6084 report_error("BAD ARGUMENT"); 6085 return; 6086 } 6087 6088 if (sscanf(args[2], "%d", &n) == 0) { 6089 report_count(1); 6090 report_error("BAD ARGUMENT"); 6091 return; 6092 } 6093 6094 if (sscanf(args[3], "%d", &attr) == 0) { 6095 report_count(1); 6096 report_error("BAD ARGUMENT"); 6097 return; 6098 } 6099 6100 if (sscanf(args[4], "%hd", &colour) == 0) { 6101 report_count(1); 6102 report_error("BAD ARGUMENT"); 6103 return; 6104 } 6105 6106 report_count(1); 6107 report_return(mvchgat(y, x, n, attr, colour, NULL)); 6108 } 6109 6110 6111 void 6112 cmd_mvwchgat(int nargs, char **args) 6113 { 6114 WINDOW *win; 6115 int y, x, n, attr, colour; 6116 6117 if (check_arg_count(nargs, 6) == 1) 6118 return; 6119 6120 if (sscanf(args[0], "%p", &win) == 0) { 6121 report_count(1); 6122 report_error("BAD ARGUMENT"); 6123 return; 6124 } 6125 6126 if (sscanf(args[1], "%d", &y) == 0) { 6127 report_count(1); 6128 report_error("BAD ARGUMENT"); 6129 return; 6130 } 6131 6132 if (sscanf(args[2], "%d", &x) == 0) { 6133 report_count(1); 6134 report_error("BAD ARGUMENT"); 6135 return; 6136 } 6137 6138 if (sscanf(args[3], "%d", &n) == 0) { 6139 report_count(1); 6140 report_error("BAD ARGUMENT"); 6141 return; 6142 } 6143 6144 if (sscanf(args[4], "%d", &attr) == 0) { 6145 report_count(1); 6146 report_error("BAD ARGUMENT"); 6147 return; 6148 } 6149 6150 if (sscanf(args[5], "%d", &colour) == 0) { 6151 report_count(1); 6152 report_error("BAD ARGUMENT"); 6153 return; 6154 } 6155 6156 report_count(1); 6157 report_return(mvwchgat(win, y, x, n, attr, colour, NULL)); 6158 } 6159 6160 6161 void 6162 cmd_add_wch(int nargs, char **args) 6163 { 6164 if (check_arg_count(nargs, 1) == 1) 6165 return; 6166 6167 report_count(1); 6168 report_error("UNSUPPORTED"); 6169 } 6170 6171 6172 void 6173 cmd_wadd_wch(int nargs, char **args) 6174 { 6175 if (check_arg_count(nargs, 1) == 1) 6176 return; 6177 6178 report_count(1); 6179 report_error("UNSUPPORTED"); 6180 } 6181 6182 6183 void 6184 cmd_mvadd_wch(int nargs, char **args) 6185 { 6186 if (check_arg_count(nargs, 1) == 1) 6187 return; 6188 6189 report_count(1); 6190 report_error("UNSUPPORTED"); 6191 } 6192 6193 6194 void 6195 cmd_mvwadd_wch(int nargs, char **args) 6196 { 6197 if (check_arg_count(nargs, 1) == 1) 6198 return; 6199 6200 report_count(1); 6201 report_error("UNSUPPORTED"); 6202 } 6203 6204 6205 6206 void 6207 cmd_add_wchnstr(int nargs, char **args) 6208 { 6209 if (check_arg_count(nargs, 1) == 1) 6210 return; 6211 6212 report_count(1); 6213 report_error("UNSUPPORTED"); 6214 } 6215 6216 6217 void 6218 cmd_add_wchstr(int nargs, char **args) 6219 { 6220 if (check_arg_count(nargs, 1) == 1) 6221 return; 6222 6223 report_count(1); 6224 report_error("UNSUPPORTED"); 6225 } 6226 6227 6228 void 6229 cmd_wadd_wchnstr(int nargs, char **args) 6230 { 6231 if (check_arg_count(nargs, 1) == 1) 6232 return; 6233 6234 report_count(1); 6235 report_error("UNSUPPORTED"); 6236 } 6237 6238 6239 void 6240 cmd_wadd_wchstr(int nargs, char **args) 6241 { 6242 if (check_arg_count(nargs, 1) == 1) 6243 return; 6244 6245 report_count(1); 6246 report_error("UNSUPPORTED"); 6247 } 6248 6249 6250 void 6251 cmd_mvadd_wchnstr(int nargs, char **args) 6252 { 6253 if (check_arg_count(nargs, 1) == 1) 6254 return; 6255 6256 report_count(1); 6257 report_error("UNSUPPORTED"); 6258 } 6259 6260 6261 void 6262 cmd_mvadd_wchstr(int nargs, char **args) 6263 { 6264 if (check_arg_count(nargs, 1) == 1) 6265 return; 6266 6267 report_count(1); 6268 report_error("UNSUPPORTED"); 6269 } 6270 6271 6272 void 6273 cmd_mvwadd_wchnstr(int nargs, char **args) 6274 { 6275 if (check_arg_count(nargs, 1) == 1) 6276 return; 6277 6278 report_count(1); 6279 report_error("UNSUPPORTED"); 6280 } 6281 6282 6283 void 6284 cmd_mvwadd_wchstr(int nargs, char **args) 6285 { 6286 if (check_arg_count(nargs, 1) == 1) 6287 return; 6288 6289 report_count(1); 6290 report_error("UNSUPPORTED"); 6291 } 6292 6293 6294 6295 void 6296 cmd_addnwstr(int nargs, char **args) 6297 { 6298 if (check_arg_count(nargs, 1) == 1) 6299 return; 6300 6301 report_count(1); 6302 report_error("UNSUPPORTED"); 6303 } 6304 6305 6306 void 6307 cmd_addwstr(int nargs, char **args) 6308 { 6309 if (check_arg_count(nargs, 1) == 1) 6310 return; 6311 6312 report_count(1); 6313 report_error("UNSUPPORTED"); 6314 } 6315 6316 6317 void 6318 cmd_mvaddnwstr(int nargs, char **args) 6319 { 6320 if (check_arg_count(nargs, 1) == 1) 6321 return; 6322 6323 report_count(1); 6324 report_error("UNSUPPORTED"); 6325 } 6326 6327 6328 void 6329 cmd_mvaddwstr(int nargs, char **args) 6330 { 6331 if (check_arg_count(nargs, 1) == 1) 6332 return; 6333 6334 report_count(1); 6335 report_error("UNSUPPORTED"); 6336 } 6337 6338 6339 void 6340 cmd_mvwaddnwstr(int nargs, char **args) 6341 { 6342 if (check_arg_count(nargs, 1) == 1) 6343 return; 6344 6345 report_count(1); 6346 report_error("UNSUPPORTED"); 6347 } 6348 6349 6350 void 6351 cmd_mvwaddwstr(int nargs, char **args) 6352 { 6353 if (check_arg_count(nargs, 1) == 1) 6354 return; 6355 6356 report_count(1); 6357 report_error("UNSUPPORTED"); 6358 } 6359 6360 6361 void 6362 cmd_waddnwstr(int nargs, char **args) 6363 { 6364 if (check_arg_count(nargs, 1) == 1) 6365 return; 6366 6367 report_count(1); 6368 report_error("UNSUPPORTED"); 6369 } 6370 6371 6372 void 6373 cmd_waddwstr(int nargs, char **args) 6374 { 6375 if (check_arg_count(nargs, 1) == 1) 6376 return; 6377 6378 report_count(1); 6379 report_error("UNSUPPORTED"); 6380 } 6381 6382 6383 6384 void 6385 cmd_echo_wchar(int nargs, char **args) 6386 { 6387 if (check_arg_count(nargs, 1) == 1) 6388 return; 6389 6390 report_count(1); 6391 report_error("UNSUPPORTED"); 6392 } 6393 6394 6395 void 6396 cmd_wecho_wchar(int nargs, char **args) 6397 { 6398 if (check_arg_count(nargs, 1) == 1) 6399 return; 6400 6401 report_count(1); 6402 report_error("UNSUPPORTED"); 6403 } 6404 6405 6406 void 6407 cmd_pecho_wchar(int nargs, char **args) 6408 { 6409 if (check_arg_count(nargs, 1) == 1) 6410 return; 6411 6412 report_count(1); 6413 report_error("UNSUPPORTED"); 6414 } 6415 6416 6417 6418 /* insert */ 6419 void 6420 cmd_ins_wch(int nargs, char **args) 6421 { 6422 if (check_arg_count(nargs, 1) == 1) 6423 return; 6424 6425 report_count(1); 6426 report_error("UNSUPPORTED"); 6427 } 6428 6429 6430 void 6431 cmd_wins_wch(int nargs, char **args) 6432 { 6433 if (check_arg_count(nargs, 1) == 1) 6434 return; 6435 6436 report_count(1); 6437 report_error("UNSUPPORTED"); 6438 } 6439 6440 6441 void 6442 cmd_mvins_wch(int nargs, char **args) 6443 { 6444 if (check_arg_count(nargs, 1) == 1) 6445 return; 6446 6447 report_count(1); 6448 report_error("UNSUPPORTED"); 6449 } 6450 6451 6452 void 6453 cmd_mvwins_wch(int nargs, char **args) 6454 { 6455 if (check_arg_count(nargs, 1) == 1) 6456 return; 6457 6458 report_count(1); 6459 report_error("UNSUPPORTED"); 6460 } 6461 6462 6463 6464 void 6465 cmd_ins_nwstr(int nargs, char **args) 6466 { 6467 if (check_arg_count(nargs, 1) == 1) 6468 return; 6469 6470 report_count(1); 6471 report_error("UNSUPPORTED"); 6472 } 6473 6474 6475 void 6476 cmd_ins_wstr(int nargs, char **args) 6477 { 6478 if (check_arg_count(nargs, 1) == 1) 6479 return; 6480 6481 report_count(1); 6482 report_error("UNSUPPORTED"); 6483 } 6484 6485 6486 void 6487 cmd_mvins_nwstr(int nargs, char **args) 6488 { 6489 if (check_arg_count(nargs, 1) == 1) 6490 return; 6491 6492 report_count(1); 6493 report_error("UNSUPPORTED"); 6494 } 6495 6496 6497 void 6498 cmd_mvins_wstr(int nargs, char **args) 6499 { 6500 if (check_arg_count(nargs, 1) == 1) 6501 return; 6502 6503 report_count(1); 6504 report_error("UNSUPPORTED"); 6505 } 6506 6507 6508 void 6509 cmd_mvwins_nwstr(int nargs, char **args) 6510 { 6511 if (check_arg_count(nargs, 1) == 1) 6512 return; 6513 6514 report_count(1); 6515 report_error("UNSUPPORTED"); 6516 } 6517 6518 6519 void 6520 cmd_mvwins_wstr(int nargs, char **args) 6521 { 6522 if (check_arg_count(nargs, 1) == 1) 6523 return; 6524 6525 report_count(1); 6526 report_error("UNSUPPORTED"); 6527 } 6528 6529 6530 void 6531 cmd_wins_nwstr(int nargs, char **args) 6532 { 6533 if (check_arg_count(nargs, 1) == 1) 6534 return; 6535 6536 report_count(1); 6537 report_error("UNSUPPORTED"); 6538 } 6539 6540 6541 void 6542 cmd_wins_wstr(int nargs, char **args) 6543 { 6544 if (check_arg_count(nargs, 1) == 1) 6545 return; 6546 6547 report_count(1); 6548 report_error("UNSUPPORTED"); 6549 } 6550 6551 6552 6553 /* input */ 6554 void 6555 cmd_get_wch(int nargs, char **args) 6556 { 6557 if (check_arg_count(nargs, 1) == 1) 6558 return; 6559 6560 report_count(1); 6561 report_error("UNSUPPORTED"); 6562 } 6563 6564 6565 void 6566 cmd_unget_wch(int nargs, char **args) 6567 { 6568 if (check_arg_count(nargs, 1) == 1) 6569 return; 6570 6571 report_count(1); 6572 report_error("UNSUPPORTED"); 6573 } 6574 6575 6576 void 6577 cmd_mvget_wch(int nargs, char **args) 6578 { 6579 if (check_arg_count(nargs, 1) == 1) 6580 return; 6581 6582 report_count(1); 6583 report_error("UNSUPPORTED"); 6584 } 6585 6586 6587 void 6588 cmd_mvwget_wch(int nargs, char **args) 6589 { 6590 if (check_arg_count(nargs, 1) == 1) 6591 return; 6592 6593 report_count(1); 6594 report_error("UNSUPPORTED"); 6595 } 6596 6597 6598 void 6599 cmd_wget_wch(int nargs, char **args) 6600 { 6601 if (check_arg_count(nargs, 1) == 1) 6602 return; 6603 6604 report_count(1); 6605 report_error("UNSUPPORTED"); 6606 } 6607 6608 6609 6610 void 6611 cmd_getn_wstr(int nargs, char **args) 6612 { 6613 if (check_arg_count(nargs, 1) == 1) 6614 return; 6615 6616 report_count(1); 6617 report_error("UNSUPPORTED"); 6618 } 6619 6620 6621 void 6622 cmd_get_wstr(int nargs, char **args) 6623 { 6624 if (check_arg_count(nargs, 1) == 1) 6625 return; 6626 6627 report_count(1); 6628 report_error("UNSUPPORTED"); 6629 } 6630 6631 6632 void 6633 cmd_mvgetn_wstr(int nargs, char **args) 6634 { 6635 if (check_arg_count(nargs, 1) == 1) 6636 return; 6637 6638 report_count(1); 6639 report_error("UNSUPPORTED"); 6640 } 6641 6642 6643 void 6644 cmd_mvget_wstr(int nargs, char **args) 6645 { 6646 if (check_arg_count(nargs, 1) == 1) 6647 return; 6648 6649 report_count(1); 6650 report_error("UNSUPPORTED"); 6651 } 6652 6653 6654 void 6655 cmd_mvwgetn_wstr(int nargs, char **args) 6656 { 6657 if (check_arg_count(nargs, 1) == 1) 6658 return; 6659 6660 report_count(1); 6661 report_error("UNSUPPORTED"); 6662 } 6663 6664 6665 void 6666 cmd_mvwget_wstr(int nargs, char **args) 6667 { 6668 if (check_arg_count(nargs, 1) == 1) 6669 return; 6670 6671 report_count(1); 6672 report_error("UNSUPPORTED"); 6673 } 6674 6675 6676 void 6677 cmd_wgetn_wstr(int nargs, char **args) 6678 { 6679 if (check_arg_count(nargs, 1) == 1) 6680 return; 6681 6682 report_count(1); 6683 report_error("UNSUPPORTED"); 6684 } 6685 6686 6687 void 6688 cmd_wget_wstr(int nargs, char **args) 6689 { 6690 if (check_arg_count(nargs, 1) == 1) 6691 return; 6692 6693 report_count(1); 6694 report_error("UNSUPPORTED"); 6695 } 6696 6697 6698 6699 void 6700 cmd_in_wch(int nargs, char **args) 6701 { 6702 if (check_arg_count(nargs, 1) == 1) 6703 return; 6704 6705 report_count(1); 6706 report_error("UNSUPPORTED"); 6707 } 6708 6709 6710 void 6711 cmd_mvin_wch(int nargs, char **args) 6712 { 6713 if (check_arg_count(nargs, 1) == 1) 6714 return; 6715 6716 report_count(1); 6717 report_error("UNSUPPORTED"); 6718 } 6719 6720 6721 void 6722 cmd_mvwin_wch(int nargs, char **args) 6723 { 6724 if (check_arg_count(nargs, 1) == 1) 6725 return; 6726 6727 report_count(1); 6728 report_error("UNSUPPORTED"); 6729 } 6730 6731 6732 void 6733 cmd_win_wch(int nargs, char **args) 6734 { 6735 if (check_arg_count(nargs, 1) == 1) 6736 return; 6737 6738 report_count(1); 6739 report_error("UNSUPPORTED"); 6740 } 6741 6742 6743 6744 void 6745 cmd_in_wchnstr(int nargs, char **args) 6746 { 6747 if (check_arg_count(nargs, 1) == 1) 6748 return; 6749 6750 report_count(1); 6751 report_error("UNSUPPORTED"); 6752 } 6753 6754 6755 void 6756 cmd_in_wchstr(int nargs, char **args) 6757 { 6758 if (check_arg_count(nargs, 1) == 1) 6759 return; 6760 6761 report_count(1); 6762 report_error("UNSUPPORTED"); 6763 } 6764 6765 6766 void 6767 cmd_mvin_wchnstr(int nargs, char **args) 6768 { 6769 if (check_arg_count(nargs, 1) == 1) 6770 return; 6771 6772 report_count(1); 6773 report_error("UNSUPPORTED"); 6774 } 6775 6776 6777 void 6778 cmd_mvin_wchstr(int nargs, char **args) 6779 { 6780 if (check_arg_count(nargs, 1) == 1) 6781 return; 6782 6783 report_count(1); 6784 report_error("UNSUPPORTED"); 6785 } 6786 6787 6788 void 6789 cmd_mvwin_wchnstr(int nargs, char **args) 6790 { 6791 if (check_arg_count(nargs, 1) == 1) 6792 return; 6793 6794 report_count(1); 6795 report_error("UNSUPPORTED"); 6796 } 6797 6798 6799 void 6800 cmd_mvwin_wchstr(int nargs, char **args) 6801 { 6802 if (check_arg_count(nargs, 1) == 1) 6803 return; 6804 6805 report_count(1); 6806 report_error("UNSUPPORTED"); 6807 } 6808 6809 6810 void 6811 cmd_win_wchnstr(int nargs, char **args) 6812 { 6813 if (check_arg_count(nargs, 1) == 1) 6814 return; 6815 6816 report_count(1); 6817 report_error("UNSUPPORTED"); 6818 } 6819 6820 6821 void 6822 cmd_win_wchstr(int nargs, char **args) 6823 { 6824 if (check_arg_count(nargs, 1) == 1) 6825 return; 6826 6827 report_count(1); 6828 report_error("UNSUPPORTED"); 6829 } 6830 6831 6832 6833 void 6834 cmd_innwstr(int nargs, char **args) 6835 { 6836 if (check_arg_count(nargs, 1) == 1) 6837 return; 6838 6839 report_count(1); 6840 report_error("UNSUPPORTED"); 6841 } 6842 6843 6844 void 6845 cmd_inwstr(int nargs, char **args) 6846 { 6847 if (check_arg_count(nargs, 1) == 1) 6848 return; 6849 6850 report_count(1); 6851 report_error("UNSUPPORTED"); 6852 } 6853 6854 6855 void 6856 cmd_mvinnwstr(int nargs, char **args) 6857 { 6858 if (check_arg_count(nargs, 1) == 1) 6859 return; 6860 6861 report_count(1); 6862 report_error("UNSUPPORTED"); 6863 } 6864 6865 6866 void 6867 cmd_mvinwstr(int nargs, char **args) 6868 { 6869 if (check_arg_count(nargs, 1) == 1) 6870 return; 6871 6872 report_count(1); 6873 report_error("UNSUPPORTED"); 6874 } 6875 6876 6877 void 6878 cmd_mvwinnwstr(int nargs, char **args) 6879 { 6880 if (check_arg_count(nargs, 1) == 1) 6881 return; 6882 6883 report_count(1); 6884 report_error("UNSUPPORTED"); 6885 } 6886 6887 6888 void 6889 cmd_mvwinwstr(int nargs, char **args) 6890 { 6891 if (check_arg_count(nargs, 1) == 1) 6892 return; 6893 6894 report_count(1); 6895 report_error("UNSUPPORTED"); 6896 } 6897 6898 6899 void 6900 cmd_winnwstr(int nargs, char **args) 6901 { 6902 if (check_arg_count(nargs, 1) == 1) 6903 return; 6904 6905 report_count(1); 6906 report_error("UNSUPPORTED"); 6907 } 6908 6909 6910 void 6911 cmd_winwstr(int nargs, char **args) 6912 { 6913 if (check_arg_count(nargs, 1) == 1) 6914 return; 6915 6916 report_count(1); 6917 report_error("UNSUPPORTED"); 6918 } 6919 6920 6921 6922 /* cchar handlgin */ 6923 void 6924 cmd_setcchar(int nargs, char **args) 6925 { 6926 if (check_arg_count(nargs, 1) == 1) 6927 return; 6928 6929 report_count(1); 6930 report_error("UNSUPPORTED"); 6931 } 6932 6933 6934 void 6935 cmd_getcchar(int nargs, char **args) 6936 { 6937 if (check_arg_count(nargs, 1) == 1) 6938 return; 6939 6940 report_count(1); 6941 report_error("UNSUPPORTED"); 6942 } 6943 6944 6945 6946 /* misc */ 6947 void 6948 cmd_key_name(int nargs, char **args) 6949 { 6950 int w; 6951 6952 if (check_arg_count(nargs, 1) == 1) 6953 return; 6954 6955 if (sscanf(args[0], "%d", &w) == 0) { 6956 report_count(1); 6957 report_error("BAD ARGUMENT"); 6958 return; 6959 } 6960 6961 report_count(1); 6962 report_status(key_name(w)); 6963 } 6964 6965 6966 void 6967 cmd_border_set(int nargs, char **args) 6968 { 6969 if (check_arg_count(nargs, 1) == 1) 6970 return; 6971 6972 report_count(1); 6973 report_error("UNSUPPORTED"); 6974 } 6975 6976 6977 void 6978 cmd_wborder_set(int nargs, char **args) 6979 { 6980 if (check_arg_count(nargs, 1) == 1) 6981 return; 6982 6983 report_count(1); 6984 report_error("UNSUPPORTED"); 6985 } 6986 6987 6988 void 6989 cmd_box_set(int nargs, char **args) 6990 { 6991 if (check_arg_count(nargs, 1) == 1) 6992 return; 6993 6994 report_count(1); 6995 report_error("UNSUPPORTED"); 6996 } 6997 6998 6999 void 7000 cmd_erasewchar(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_killwchar(int nargs, char **args) 7016 { 7017 wchar_t ch; 7018 7019 if (check_arg_count(nargs, 0) == 1) 7020 return; 7021 7022 /* XXX - call2 */ 7023 report_count(2); 7024 report_return(erasewchar(&ch)); 7025 report_int(ch); 7026 } 7027 7028 7029 void 7030 cmd_hline_set(int nargs, char **args) 7031 { 7032 if (check_arg_count(nargs, 1) == 1) 7033 return; 7034 7035 report_count(1); 7036 report_error("UNSUPPORTED"); 7037 } 7038 7039 7040 void 7041 cmd_mvhline_set(int nargs, char **args) 7042 { 7043 if (check_arg_count(nargs, 1) == 1) 7044 return; 7045 7046 report_count(1); 7047 report_error("UNSUPPORTED"); 7048 } 7049 7050 7051 void 7052 cmd_mvvline_set(int nargs, char **args) 7053 { 7054 if (check_arg_count(nargs, 1) == 1) 7055 return; 7056 7057 report_count(1); 7058 report_error("UNSUPPORTED"); 7059 } 7060 7061 7062 void 7063 cmd_mvwhline_set(int nargs, char **args) 7064 { 7065 if (check_arg_count(nargs, 1) == 1) 7066 return; 7067 7068 report_count(1); 7069 report_error("UNSUPPORTED"); 7070 } 7071 7072 7073 void 7074 cmd_mvwvline_set(int nargs, char **args) 7075 { 7076 if (check_arg_count(nargs, 1) == 1) 7077 return; 7078 7079 report_count(1); 7080 report_error("UNSUPPORTED"); 7081 } 7082 7083 7084 void 7085 cmd_vline_set(int nargs, char **args) 7086 { 7087 if (check_arg_count(nargs, 1) == 1) 7088 return; 7089 7090 report_count(1); 7091 report_error("UNSUPPORTED"); 7092 } 7093 7094 7095 void 7096 cmd_whline_set(int nargs, char **args) 7097 { 7098 if (check_arg_count(nargs, 1) == 1) 7099 return; 7100 7101 report_count(1); 7102 report_error("UNSUPPORTED"); 7103 } 7104 7105 7106 void 7107 cmd_wvline_set(int nargs, char **args) 7108 { 7109 if (check_arg_count(nargs, 1) == 1) 7110 return; 7111 7112 report_count(1); 7113 report_error("UNSUPPORTED"); 7114 } 7115 7116 7117 void 7118 cmd_bkgrnd(int nargs, char **args) 7119 { 7120 if (check_arg_count(nargs, 1) == 1) 7121 return; 7122 7123 report_count(1); 7124 report_error("UNSUPPORTED"); 7125 } 7126 7127 7128 void 7129 cmd_bkgrndset(int nargs, char **args) 7130 { 7131 if (check_arg_count(nargs, 1) == 1) 7132 return; 7133 7134 report_count(1); 7135 report_error("UNSUPPORTED"); 7136 } 7137 7138 7139 void 7140 cmd_getbkgrnd(int nargs, char **args) 7141 { 7142 if (check_arg_count(nargs, 1) == 1) 7143 return; 7144 7145 report_count(1); 7146 report_error("UNSUPPORTED"); 7147 } 7148 7149 7150 void 7151 cmd_wbkgrnd(int nargs, char **args) 7152 { 7153 if (check_arg_count(nargs, 1) == 1) 7154 return; 7155 7156 report_count(1); 7157 report_error("UNSUPPORTED"); 7158 } 7159 7160 7161 void 7162 cmd_wbkgrndset(int nargs, char **args) 7163 { 7164 if (check_arg_count(nargs, 1) == 1) 7165 return; 7166 7167 report_count(1); 7168 report_error("UNSUPPORTED"); 7169 } 7170 7171 7172 void 7173 cmd_wgetbkgrnd(int nargs, char **args) 7174 { 7175 if (check_arg_count(nargs, 1) == 1) 7176 return; 7177 7178 report_count(1); 7179 report_error("UNSUPPORTED"); 7180 } 7181