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