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