ncurses 6.2 - patch 20200404
[ncurses.git] / ncurses / llib-lncursesw
1 /****************************************************************************
2  * Copyright 2018-2019,2020 Thomas E. Dickey                                *
3  * Copyright 2001-2016,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29
30 /****************************************************************************
31  *  Author: Thomas E. Dickey       2001-on                                  *
32  ****************************************************************************/
33 /* LINTLIBRARY */
34
35 /* ./tty/hardscroll.c */
36
37 #include <curses.priv.h>
38
39 #undef _nc_oldnums
40 int     *_nc_oldnums;
41
42 #undef _nc_scroll_optimize_sp
43 void    _nc_scroll_optimize_sp(
44                 SCREEN  *sp)
45                 { /* void */ }
46
47 #undef _nc_scroll_optimize
48 void    _nc_scroll_optimize(void)
49                 { /* void */ }
50
51 #undef _nc_linedump_sp
52 void    _nc_linedump_sp(
53                 SCREEN  *sp)
54                 { /* void */ }
55
56 #undef _nc_linedump
57 void    _nc_linedump(void)
58                 { /* void */ }
59
60 /* ./tty/hashmap.c */
61
62 #undef _nc_hash_map_sp
63 void    _nc_hash_map_sp(
64                 SCREEN  *sp)
65                 { /* void */ }
66
67 #undef _nc_hash_map
68 void    _nc_hash_map(void)
69                 { /* void */ }
70
71 #undef _nc_make_oldhash_sp
72 void    _nc_make_oldhash_sp(
73                 SCREEN  *sp, 
74                 int     i)
75                 { /* void */ }
76
77 #undef _nc_make_oldhash
78 void    _nc_make_oldhash(
79                 int     i)
80                 { /* void */ }
81
82 #undef _nc_scroll_oldhash_sp
83 void    _nc_scroll_oldhash_sp(
84                 SCREEN  *sp, 
85                 int     n, 
86                 int     top, 
87                 int     bot)
88                 { /* void */ }
89
90 #undef _nc_scroll_oldhash
91 void    _nc_scroll_oldhash(
92                 int     n, 
93                 int     top, 
94                 int     bot)
95                 { /* void */ }
96
97 /* ./base/lib_addch.c */
98
99 #undef _nc_render
100 cchar_t _nc_render(
101                 WINDOW  *win, 
102                 cchar_t ch)
103                 { return(*(cchar_t *)0); }
104
105 #undef _nc_build_wch
106 int     _nc_build_wch(
107                 WINDOW  *win, 
108                 cchar_t *ch)
109                 { return(*(int *)0); }
110
111 #undef _nc_waddch_nosync
112 int     _nc_waddch_nosync(
113                 WINDOW  *win, 
114                 const cchar_t c)
115                 { return(*(int *)0); }
116
117 #undef waddch
118 int     waddch(
119                 WINDOW  *win, 
120                 const chtype ch)
121                 { return(*(int *)0); }
122
123 #undef wechochar
124 int     wechochar(
125                 WINDOW  *win, 
126                 const chtype ch)
127                 { return(*(int *)0); }
128
129 /* ./base/lib_addstr.c */
130
131 #undef waddnstr
132 int     waddnstr(
133                 WINDOW  *win, 
134                 const char *astr, 
135                 int     n)
136                 { return(*(int *)0); }
137
138 #undef waddchnstr
139 int     waddchnstr(
140                 WINDOW  *win, 
141                 const chtype *astr, 
142                 int     n)
143                 { return(*(int *)0); }
144
145 #undef _nc_wchstrlen
146 int     _nc_wchstrlen(
147                 const cchar_t *s)
148                 { return(*(int *)0); }
149
150 #undef wadd_wchnstr
151 int     wadd_wchnstr(
152                 WINDOW  *win, 
153                 const cchar_t *astr, 
154                 int     n)
155                 { return(*(int *)0); }
156
157 #undef waddnwstr
158 int     waddnwstr(
159                 WINDOW  *win, 
160                 const wchar_t *str, 
161                 int     n)
162                 { return(*(int *)0); }
163
164 /* ./base/lib_beep.c */
165
166 #undef beep_sp
167 int     beep_sp(
168                 SCREEN  *sp)
169                 { return(*(int *)0); }
170
171 #undef beep
172 int     beep(void)
173                 { return(*(int *)0); }
174
175 /* ./base/lib_bkgd.c */
176
177 #undef wbkgrndset
178 void    wbkgrndset(
179                 WINDOW  *win, 
180                 const cchar_t *ch)
181                 { /* void */ }
182
183 #undef wbkgdset
184 void    wbkgdset(
185                 WINDOW  *win, 
186                 chtype  ch)
187                 { /* void */ }
188
189 #undef wbkgrnd
190 int     wbkgrnd(
191                 WINDOW  *win, 
192                 const cchar_t *ch)
193                 { return(*(int *)0); }
194
195 #undef wbkgd
196 int     wbkgd(
197                 WINDOW  *win, 
198                 chtype  ch)
199                 { return(*(int *)0); }
200
201 /* ./base/lib_box.c */
202
203 #undef wborder
204 int     wborder(
205                 WINDOW  *win, 
206                 chtype  ls, 
207                 chtype  rs, 
208                 chtype  ts, 
209                 chtype  bs, 
210                 chtype  tl, 
211                 chtype  tr, 
212                 chtype  bl, 
213                 chtype  br)
214                 { return(*(int *)0); }
215
216 /* ./base/lib_chgat.c */
217
218 #undef wchgat
219 int     wchgat(
220                 WINDOW  *win, 
221                 int     n, 
222                 attr_t  attr, 
223                 short   pair_arg, 
224                 const void *opts)
225                 { return(*(int *)0); }
226
227 /* ./base/lib_clear.c */
228
229 #undef wclear
230 int     wclear(
231                 WINDOW  *win)
232                 { return(*(int *)0); }
233
234 /* ./base/lib_clearok.c */
235
236 #undef clearok
237 int     clearok(
238                 WINDOW  *win, 
239                 NCURSES_BOOL flag)
240                 { return(*(int *)0); }
241
242 /* ./base/lib_clrbot.c */
243
244 #undef wclrtobot
245 int     wclrtobot(
246                 WINDOW  *win)
247                 { return(*(int *)0); }
248
249 /* ./base/lib_clreol.c */
250
251 #undef wclrtoeol
252 int     wclrtoeol(
253                 WINDOW  *win)
254                 { return(*(int *)0); }
255
256 /* ./base/lib_color.c */
257
258 #undef COLOR_PAIRS
259 int     COLOR_PAIRS;
260 #undef COLORS
261 int     COLORS;
262
263 #undef _nc_reset_colors_sp
264 NCURSES_BOOL _nc_reset_colors_sp(
265                 SCREEN  *sp)
266                 { return(*(NCURSES_BOOL *)0); }
267
268 #undef _nc_reset_colors
269 NCURSES_BOOL _nc_reset_colors(void)
270                 { return(*(NCURSES_BOOL *)0); }
271
272 #undef start_color_sp
273 int     start_color_sp(
274                 SCREEN  *sp)
275                 { return(*(int *)0); }
276
277 #undef start_color
278 int     start_color(void)
279                 { return(*(int *)0); }
280
281 #undef _nc_change_pair
282 void    _nc_change_pair(
283                 SCREEN  *sp, 
284                 int     pair)
285                 { /* void */ }
286
287 #undef _nc_reserve_pairs
288 void    _nc_reserve_pairs(
289                 SCREEN  *sp, 
290                 int     want)
291                 { /* void */ }
292
293 #undef _nc_init_pair
294 int     _nc_init_pair(
295                 SCREEN  *sp, 
296                 int     pair, 
297                 int     f, 
298                 int     b)
299                 { return(*(int *)0); }
300
301 #undef init_pair_sp
302 int     init_pair_sp(
303                 SCREEN  *sp, 
304                 short   pair, 
305                 short   f, 
306                 short   b)
307                 { return(*(int *)0); }
308
309 #undef init_pair
310 int     init_pair(
311                 short   pair, 
312                 short   f, 
313                 short   b)
314                 { return(*(int *)0); }
315
316 #undef _nc_init_color
317 int     _nc_init_color(
318                 SCREEN  *sp, 
319                 int     color, 
320                 int     r, 
321                 int     g, 
322                 int     b)
323                 { return(*(int *)0); }
324
325 #undef init_color_sp
326 int     init_color_sp(
327                 SCREEN  *sp, 
328                 short   color, 
329                 short   r, 
330                 short   g, 
331                 short   b)
332                 { return(*(int *)0); }
333
334 #undef init_color
335 int     init_color(
336                 short   color, 
337                 short   r, 
338                 short   g, 
339                 short   b)
340                 { return(*(int *)0); }
341
342 #undef can_change_color_sp
343 NCURSES_BOOL can_change_color_sp(
344                 SCREEN  *sp)
345                 { return(*(NCURSES_BOOL *)0); }
346
347 #undef can_change_color
348 NCURSES_BOOL can_change_color(void)
349                 { return(*(NCURSES_BOOL *)0); }
350
351 #undef has_colors_sp
352 NCURSES_BOOL has_colors_sp(
353                 SCREEN  *sp)
354                 { return(*(NCURSES_BOOL *)0); }
355
356 #undef has_colors
357 NCURSES_BOOL has_colors(void)
358                 { return(*(NCURSES_BOOL *)0); }
359
360 #undef color_content_sp
361 int     color_content_sp(
362                 SCREEN  *sp, 
363                 short   color, 
364                 short   *r, 
365                 short   *g, 
366                 short   *b)
367                 { return(*(int *)0); }
368
369 #undef color_content
370 int     color_content(
371                 short   color, 
372                 short   *r, 
373                 short   *g, 
374                 short   *b)
375                 { return(*(int *)0); }
376
377 #undef _nc_pair_content
378 int     _nc_pair_content(
379                 SCREEN  *sp, 
380                 int     pair, 
381                 int     *f, 
382                 int     *b)
383                 { return(*(int *)0); }
384
385 #undef pair_content_sp
386 int     pair_content_sp(
387                 SCREEN  *sp, 
388                 short   pair, 
389                 short   *f, 
390                 short   *b)
391                 { return(*(int *)0); }
392
393 #undef pair_content
394 int     pair_content(
395                 short   pair, 
396                 short   *f, 
397                 short   *b)
398                 { return(*(int *)0); }
399
400 #undef _nc_do_color_sp
401 void    _nc_do_color_sp(
402                 SCREEN  *sp, 
403                 int     old_pair, 
404                 int     pair, 
405                 int     reverse, 
406                 NCURSES_OUTC_sp outc)
407                 { /* void */ }
408
409 #undef _nc_do_color
410 void    _nc_do_color(
411                 int     old_pair, 
412                 int     pair, 
413                 int     reverse, 
414                 NCURSES_OUTC outc)
415                 { /* void */ }
416
417 #undef init_extended_pair_sp
418 int     init_extended_pair_sp(
419                 SCREEN  *sp, 
420                 int     pair, 
421                 int     f, 
422                 int     b)
423                 { return(*(int *)0); }
424
425 #undef init_extended_color_sp
426 int     init_extended_color_sp(
427                 SCREEN  *sp, 
428                 int     color, 
429                 int     r, 
430                 int     g, 
431                 int     b)
432                 { return(*(int *)0); }
433
434 #undef extended_color_content_sp
435 int     extended_color_content_sp(
436                 SCREEN  *sp, 
437                 int     color, 
438                 int     *r, 
439                 int     *g, 
440                 int     *b)
441                 { return(*(int *)0); }
442
443 #undef extended_pair_content_sp
444 int     extended_pair_content_sp(
445                 SCREEN  *sp, 
446                 int     pair, 
447                 int     *f, 
448                 int     *b)
449                 { return(*(int *)0); }
450
451 #undef reset_color_pairs_sp
452 void    reset_color_pairs_sp(
453                 SCREEN  *sp)
454                 { /* void */ }
455
456 #undef init_extended_pair
457 int     init_extended_pair(
458                 int     pair, 
459                 int     f, 
460                 int     b)
461                 { return(*(int *)0); }
462
463 #undef init_extended_color
464 int     init_extended_color(
465                 int     color, 
466                 int     r, 
467                 int     g, 
468                 int     b)
469                 { return(*(int *)0); }
470
471 #undef extended_color_content
472 int     extended_color_content(
473                 int     color, 
474                 int     *r, 
475                 int     *g, 
476                 int     *b)
477                 { return(*(int *)0); }
478
479 #undef extended_pair_content
480 int     extended_pair_content(
481                 int     pair, 
482                 int     *f, 
483                 int     *b)
484                 { return(*(int *)0); }
485
486 #undef reset_color_pairs
487 void    reset_color_pairs(void)
488                 { /* void */ }
489
490 /* ./base/lib_colorset.c */
491
492 #undef wcolor_set
493 int     wcolor_set(
494                 WINDOW  *win, 
495                 short   pair_arg, 
496                 void    *opts)
497                 { return(*(int *)0); }
498
499 /* ./base/lib_delch.c */
500
501 #undef wdelch
502 int     wdelch(
503                 WINDOW  *win)
504                 { return(*(int *)0); }
505
506 /* ./base/lib_delwin.c */
507
508 #undef delwin
509 int     delwin(
510                 WINDOW  *win)
511                 { return(*(int *)0); }
512
513 /* ./base/lib_echo.c */
514
515 #undef echo_sp
516 int     echo_sp(
517                 SCREEN  *sp)
518                 { return(*(int *)0); }
519
520 #undef echo
521 int     echo(void)
522                 { return(*(int *)0); }
523
524 #undef noecho_sp
525 int     noecho_sp(
526                 SCREEN  *sp)
527                 { return(*(int *)0); }
528
529 #undef noecho
530 int     noecho(void)
531                 { return(*(int *)0); }
532
533 /* ./base/lib_endwin.c */
534
535 #undef endwin_sp
536 int     endwin_sp(
537                 SCREEN  *sp)
538                 { return(*(int *)0); }
539
540 #undef endwin
541 int     endwin(void)
542                 { return(*(int *)0); }
543
544 /* ./base/lib_erase.c */
545
546 #undef werase
547 int     werase(
548                 WINDOW  *win)
549                 { return(*(int *)0); }
550
551 /* ./base/lib_flash.c */
552
553 #undef flash_sp
554 int     flash_sp(
555                 SCREEN  *sp)
556                 { return(*(int *)0); }
557
558 #undef flash
559 int     flash(void)
560                 { return(*(int *)0); }
561
562 /* ./lib_gen.c */
563
564 #undef addch
565 int     (addch)(
566                 const chtype z)
567                 { return(*(int *)0); }
568
569 #undef addchnstr
570 int     (addchnstr)(
571                 const chtype *a1, 
572                 int     z)
573                 { return(*(int *)0); }
574
575 #undef addchstr
576 int     (addchstr)(
577                 const chtype *z)
578                 { return(*(int *)0); }
579
580 #undef addnstr
581 int     (addnstr)(
582                 const char *a1, 
583                 int     z)
584                 { return(*(int *)0); }
585
586 #undef addstr
587 int     (addstr)(
588                 const char *z)
589                 { return(*(int *)0); }
590
591 #undef attroff
592 int     (attroff)(
593                 NCURSES_ATTR_T  z)
594                 { return(*(int *)0); }
595
596 #undef attron
597 int     (attron)(
598                 NCURSES_ATTR_T  z)
599                 { return(*(int *)0); }
600
601 #undef attrset
602 int     (attrset)(
603                 NCURSES_ATTR_T  z)
604                 { return(*(int *)0); }
605
606 #undef attr_get
607 int     (attr_get)(
608                 attr_t  *a1, 
609                 short   *a2, 
610                 void    *z)
611                 { return(*(int *)0); }
612
613 #undef attr_off
614 int     (attr_off)(
615                 attr_t  a1, 
616                 void    *z)
617                 { return(*(int *)0); }
618
619 #undef attr_on
620 int     (attr_on)(
621                 attr_t  a1, 
622                 void    *z)
623                 { return(*(int *)0); }
624
625 #undef attr_set
626 int     (attr_set)(
627                 attr_t  a1, 
628                 short   a2, 
629                 void    *z)
630                 { return(*(int *)0); }
631
632 #undef bkgd
633 int     (bkgd)(
634                 chtype  z)
635                 { return(*(int *)0); }
636
637 #undef bkgdset
638 void    (bkgdset)(
639                 chtype  z)
640                 { /* void */ }
641
642 #undef border
643 int     (border)(
644                 chtype  a1, 
645                 chtype  a2, 
646                 chtype  a3, 
647                 chtype  a4, 
648                 chtype  a5, 
649                 chtype  a6, 
650                 chtype  a7, 
651                 chtype  z)
652                 { return(*(int *)0); }
653
654 #undef box
655 int     (box)(
656                 WINDOW  *a1, 
657                 chtype  a2, 
658                 chtype  z)
659                 { return(*(int *)0); }
660
661 #undef chgat
662 int     (chgat)(
663                 int     a1, 
664                 attr_t  a2, 
665                 short   a3, 
666                 const void *z)
667                 { return(*(int *)0); }
668
669 #undef clear
670 int     (clear)(void)
671                 { return(*(int *)0); }
672
673 #undef clrtobot
674 int     (clrtobot)(void)
675                 { return(*(int *)0); }
676
677 #undef clrtoeol
678 int     (clrtoeol)(void)
679                 { return(*(int *)0); }
680
681 #undef color_set
682 int     (color_set)(
683                 short   a1, 
684                 void    *z)
685                 { return(*(int *)0); }
686
687 #undef COLOR_PAIR
688 int     (COLOR_PAIR)(
689                 int     z)
690                 { return(*(int *)0); }
691
692 #undef delch
693 int     (delch)(void)
694                 { return(*(int *)0); }
695
696 #undef deleteln
697 int     (deleteln)(void)
698                 { return(*(int *)0); }
699
700 #undef echochar
701 int     (echochar)(
702                 const chtype z)
703                 { return(*(int *)0); }
704
705 #undef erase
706 int     (erase)(void)
707                 { return(*(int *)0); }
708
709 #undef getbkgd
710 chtype  (getbkgd)(
711                 WINDOW  *z)
712                 { return(*(chtype *)0); }
713
714 #undef getch
715 int     (getch)(void)
716                 { return(*(int *)0); }
717
718 #undef getnstr
719 int     (getnstr)(
720                 char    *a1, 
721                 int     z)
722                 { return(*(int *)0); }
723
724 #undef getstr
725 int     (getstr)(
726                 char    *z)
727                 { return(*(int *)0); }
728
729 #undef hline
730 int     (hline)(
731                 chtype  a1, 
732                 int     z)
733                 { return(*(int *)0); }
734
735 #undef inch
736 chtype  (inch)(void)
737                 { return(*(chtype *)0); }
738
739 #undef inchnstr
740 int     (inchnstr)(
741                 chtype  *a1, 
742                 int     z)
743                 { return(*(int *)0); }
744
745 #undef inchstr
746 int     (inchstr)(
747                 chtype  *z)
748                 { return(*(int *)0); }
749
750 #undef innstr
751 int     (innstr)(
752                 char    *a1, 
753                 int     z)
754                 { return(*(int *)0); }
755
756 #undef insch
757 int     (insch)(
758                 chtype  z)
759                 { return(*(int *)0); }
760
761 #undef insdelln
762 int     (insdelln)(
763                 int     z)
764                 { return(*(int *)0); }
765
766 #undef insertln
767 int     (insertln)(void)
768                 { return(*(int *)0); }
769
770 #undef insnstr
771 int     (insnstr)(
772                 const char *a1, 
773                 int     z)
774                 { return(*(int *)0); }
775
776 #undef insstr
777 int     (insstr)(
778                 const char *z)
779                 { return(*(int *)0); }
780
781 #undef instr
782 int     (instr)(
783                 char    *z)
784                 { return(*(int *)0); }
785
786 #undef move
787 int     (move)(
788                 int     a1, 
789                 int     z)
790                 { return(*(int *)0); }
791
792 #undef mvaddch
793 int     (mvaddch)(
794                 int     a1, 
795                 int     a2, 
796                 const chtype z)
797                 { return(*(int *)0); }
798
799 #undef mvaddchnstr
800 int     (mvaddchnstr)(
801                 int     a1, 
802                 int     a2, 
803                 const chtype *a3, 
804                 int     z)
805                 { return(*(int *)0); }
806
807 #undef mvaddchstr
808 int     (mvaddchstr)(
809                 int     a1, 
810                 int     a2, 
811                 const chtype *z)
812                 { return(*(int *)0); }
813
814 #undef mvaddnstr
815 int     (mvaddnstr)(
816                 int     a1, 
817                 int     a2, 
818                 const char *a3, 
819                 int     z)
820                 { return(*(int *)0); }
821
822 #undef mvaddstr
823 int     (mvaddstr)(
824                 int     a1, 
825                 int     a2, 
826                 const char *z)
827                 { return(*(int *)0); }
828
829 #undef mvchgat
830 int     (mvchgat)(
831                 int     a1, 
832                 int     a2, 
833                 int     a3, 
834                 attr_t  a4, 
835                 short   a5, 
836                 const void *z)
837                 { return(*(int *)0); }
838
839 #undef mvdelch
840 int     (mvdelch)(
841                 int     a1, 
842                 int     z)
843                 { return(*(int *)0); }
844
845 #undef mvgetch
846 int     (mvgetch)(
847                 int     a1, 
848                 int     z)
849                 { return(*(int *)0); }
850
851 #undef mvgetnstr
852 int     (mvgetnstr)(
853                 int     a1, 
854                 int     a2, 
855                 char    *a3, 
856                 int     z)
857                 { return(*(int *)0); }
858
859 #undef mvgetstr
860 int     (mvgetstr)(
861                 int     a1, 
862                 int     a2, 
863                 char    *z)
864                 { return(*(int *)0); }
865
866 #undef mvhline
867 int     (mvhline)(
868                 int     a1, 
869                 int     a2, 
870                 chtype  a3, 
871                 int     z)
872                 { return(*(int *)0); }
873
874 #undef mvinch
875 chtype  (mvinch)(
876                 int     a1, 
877                 int     z)
878                 { return(*(chtype *)0); }
879
880 #undef mvinchnstr
881 int     (mvinchnstr)(
882                 int     a1, 
883                 int     a2, 
884                 chtype  *a3, 
885                 int     z)
886                 { return(*(int *)0); }
887
888 #undef mvinchstr
889 int     (mvinchstr)(
890                 int     a1, 
891                 int     a2, 
892                 chtype  *z)
893                 { return(*(int *)0); }
894
895 #undef mvinnstr
896 int     (mvinnstr)(
897                 int     a1, 
898                 int     a2, 
899                 char    *a3, 
900                 int     z)
901                 { return(*(int *)0); }
902
903 #undef mvinsch
904 int     (mvinsch)(
905                 int     a1, 
906                 int     a2, 
907                 chtype  z)
908                 { return(*(int *)0); }
909
910 #undef mvinsnstr
911 int     (mvinsnstr)(
912                 int     a1, 
913                 int     a2, 
914                 const char *a3, 
915                 int     z)
916                 { return(*(int *)0); }
917
918 #undef mvinsstr
919 int     (mvinsstr)(
920                 int     a1, 
921                 int     a2, 
922                 const char *z)
923                 { return(*(int *)0); }
924
925 #undef mvinstr
926 int     (mvinstr)(
927                 int     a1, 
928                 int     a2, 
929                 char    *z)
930                 { return(*(int *)0); }
931
932 #undef mvvline
933 int     (mvvline)(
934                 int     a1, 
935                 int     a2, 
936                 chtype  a3, 
937                 int     z)
938                 { return(*(int *)0); }
939
940 #undef mvwaddch
941 int     (mvwaddch)(
942                 WINDOW  *a1, 
943                 int     a2, 
944                 int     a3, 
945                 const chtype z)
946                 { return(*(int *)0); }
947
948 #undef mvwaddchnstr
949 int     (mvwaddchnstr)(
950                 WINDOW  *a1, 
951                 int     a2, 
952                 int     a3, 
953                 const chtype *a4, 
954                 int     z)
955                 { return(*(int *)0); }
956
957 #undef mvwaddchstr
958 int     (mvwaddchstr)(
959                 WINDOW  *a1, 
960                 int     a2, 
961                 int     a3, 
962                 const chtype *z)
963                 { return(*(int *)0); }
964
965 #undef mvwaddnstr
966 int     (mvwaddnstr)(
967                 WINDOW  *a1, 
968                 int     a2, 
969                 int     a3, 
970                 const char *a4, 
971                 int     z)
972                 { return(*(int *)0); }
973
974 #undef mvwaddstr
975 int     (mvwaddstr)(
976                 WINDOW  *a1, 
977                 int     a2, 
978                 int     a3, 
979                 const char *z)
980                 { return(*(int *)0); }
981
982 #undef mvwchgat
983 int     (mvwchgat)(
984                 WINDOW  *a1, 
985                 int     a2, 
986                 int     a3, 
987                 int     a4, 
988                 attr_t  a5, 
989                 short   a6, 
990                 const void *z)
991                 { return(*(int *)0); }
992
993 #undef mvwdelch
994 int     (mvwdelch)(
995                 WINDOW  *a1, 
996                 int     a2, 
997                 int     z)
998                 { return(*(int *)0); }
999
1000 #undef mvwgetch
1001 int     (mvwgetch)(
1002                 WINDOW  *a1, 
1003                 int     a2, 
1004                 int     z)
1005                 { return(*(int *)0); }
1006
1007 #undef mvwgetnstr
1008 int     (mvwgetnstr)(
1009                 WINDOW  *a1, 
1010                 int     a2, 
1011                 int     a3, 
1012                 char    *a4, 
1013                 int     z)
1014                 { return(*(int *)0); }
1015
1016 #undef mvwgetstr
1017 int     (mvwgetstr)(
1018                 WINDOW  *a1, 
1019                 int     a2, 
1020                 int     a3, 
1021                 char    *z)
1022                 { return(*(int *)0); }
1023
1024 #undef mvwhline
1025 int     (mvwhline)(
1026                 WINDOW  *a1, 
1027                 int     a2, 
1028                 int     a3, 
1029                 chtype  a4, 
1030                 int     z)
1031                 { return(*(int *)0); }
1032
1033 #undef mvwinch
1034 chtype  (mvwinch)(
1035                 WINDOW  *a1, 
1036                 int     a2, 
1037                 int     z)
1038                 { return(*(chtype *)0); }
1039
1040 #undef mvwinchnstr
1041 int     (mvwinchnstr)(
1042                 WINDOW  *a1, 
1043                 int     a2, 
1044                 int     a3, 
1045                 chtype  *a4, 
1046                 int     z)
1047                 { return(*(int *)0); }
1048
1049 #undef mvwinchstr
1050 int     (mvwinchstr)(
1051                 WINDOW  *a1, 
1052                 int     a2, 
1053                 int     a3, 
1054                 chtype  *z)
1055                 { return(*(int *)0); }
1056
1057 #undef mvwinnstr
1058 int     (mvwinnstr)(
1059                 WINDOW  *a1, 
1060                 int     a2, 
1061                 int     a3, 
1062                 char    *a4, 
1063                 int     z)
1064                 { return(*(int *)0); }
1065
1066 #undef mvwinsch
1067 int     (mvwinsch)(
1068                 WINDOW  *a1, 
1069                 int     a2, 
1070                 int     a3, 
1071                 chtype  z)
1072                 { return(*(int *)0); }
1073
1074 #undef mvwinsnstr
1075 int     (mvwinsnstr)(
1076                 WINDOW  *a1, 
1077                 int     a2, 
1078                 int     a3, 
1079                 const char *a4, 
1080                 int     z)
1081                 { return(*(int *)0); }
1082
1083 #undef mvwinsstr
1084 int     (mvwinsstr)(
1085                 WINDOW  *a1, 
1086                 int     a2, 
1087                 int     a3, 
1088                 const char *z)
1089                 { return(*(int *)0); }
1090
1091 #undef mvwinstr
1092 int     (mvwinstr)(
1093                 WINDOW  *a1, 
1094                 int     a2, 
1095                 int     a3, 
1096                 char    *z)
1097                 { return(*(int *)0); }
1098
1099 #undef mvwvline
1100 int     (mvwvline)(
1101                 WINDOW  *a1, 
1102                 int     a2, 
1103                 int     a3, 
1104                 chtype  a4, 
1105                 int     z)
1106                 { return(*(int *)0); }
1107
1108 #undef PAIR_NUMBER
1109 int     (PAIR_NUMBER)(
1110                 int     z)
1111                 { return(*(int *)0); }
1112
1113 #undef redrawwin
1114 int     (redrawwin)(
1115                 WINDOW  *z)
1116                 { return(*(int *)0); }
1117
1118 #undef refresh
1119 int     (refresh)(void)
1120                 { return(*(int *)0); }
1121
1122 #undef scrl
1123 int     (scrl)(
1124                 int     z)
1125                 { return(*(int *)0); }
1126
1127 #undef scroll
1128 int     (scroll)(
1129                 WINDOW  *z)
1130                 { return(*(int *)0); }
1131
1132 #undef setscrreg
1133 int     (setscrreg)(
1134                 int     a1, 
1135                 int     z)
1136                 { return(*(int *)0); }
1137
1138 #undef slk_attr_off
1139 int     (slk_attr_off)(
1140                 const attr_t a1, 
1141                 void    *z)
1142                 { return(*(int *)0); }
1143
1144 #undef slk_attr_on
1145 int     (slk_attr_on)(
1146                 attr_t  a1, 
1147                 void    *z)
1148                 { return(*(int *)0); }
1149
1150 #undef standout
1151 int     (standout)(void)
1152                 { return(*(int *)0); }
1153
1154 #undef standend
1155 int     (standend)(void)
1156                 { return(*(int *)0); }
1157
1158 #undef timeout
1159 void    (timeout)(
1160                 int     z)
1161                 { /* void */ }
1162
1163 #undef touchline
1164 int     (touchline)(
1165                 WINDOW  *a1, 
1166                 int     a2, 
1167                 int     z)
1168                 { return(*(int *)0); }
1169
1170 #undef touchwin
1171 int     (touchwin)(
1172                 WINDOW  *z)
1173                 { return(*(int *)0); }
1174
1175 #undef untouchwin
1176 int     (untouchwin)(
1177                 WINDOW  *z)
1178                 { return(*(int *)0); }
1179
1180 #undef vline
1181 int     (vline)(
1182                 chtype  a1, 
1183                 int     z)
1184                 { return(*(int *)0); }
1185
1186 #undef waddchstr
1187 int     (waddchstr)(
1188                 WINDOW  *a1, 
1189                 const chtype *z)
1190                 { return(*(int *)0); }
1191
1192 #undef waddstr
1193 int     (waddstr)(
1194                 WINDOW  *a1, 
1195                 const char *z)
1196                 { return(*(int *)0); }
1197
1198 #undef wattron
1199 int     (wattron)(
1200                 WINDOW  *a1, 
1201                 int     z)
1202                 { return(*(int *)0); }
1203
1204 #undef wattroff
1205 int     (wattroff)(
1206                 WINDOW  *a1, 
1207                 int     z)
1208                 { return(*(int *)0); }
1209
1210 #undef wattrset
1211 int     (wattrset)(
1212                 WINDOW  *a1, 
1213                 int     z)
1214                 { return(*(int *)0); }
1215
1216 #undef wattr_get
1217 int     (wattr_get)(
1218                 WINDOW  *a1, 
1219                 attr_t  *a2, 
1220                 short   *a3, 
1221                 void    *z)
1222                 { return(*(int *)0); }
1223
1224 #undef wattr_set
1225 int     (wattr_set)(
1226                 WINDOW  *a1, 
1227                 attr_t  a2, 
1228                 short   a3, 
1229                 void    *z)
1230                 { return(*(int *)0); }
1231
1232 #undef wdeleteln
1233 int     (wdeleteln)(
1234                 WINDOW  *z)
1235                 { return(*(int *)0); }
1236
1237 #undef wgetstr
1238 int     (wgetstr)(
1239                 WINDOW  *a1, 
1240                 char    *z)
1241                 { return(*(int *)0); }
1242
1243 #undef winchstr
1244 int     (winchstr)(
1245                 WINDOW  *a1, 
1246                 chtype  *z)
1247                 { return(*(int *)0); }
1248
1249 #undef winsertln
1250 int     (winsertln)(
1251                 WINDOW  *z)
1252                 { return(*(int *)0); }
1253
1254 #undef winsstr
1255 int     (winsstr)(
1256                 WINDOW  *a1, 
1257                 const char *z)
1258                 { return(*(int *)0); }
1259
1260 #undef winstr
1261 int     (winstr)(
1262                 WINDOW  *a1, 
1263                 char    *z)
1264                 { return(*(int *)0); }
1265
1266 #undef wstandout
1267 int     (wstandout)(
1268                 WINDOW  *z)
1269                 { return(*(int *)0); }
1270
1271 #undef wstandend
1272 int     (wstandend)(
1273                 WINDOW  *z)
1274                 { return(*(int *)0); }
1275
1276 #undef getattrs
1277 int     (getattrs)(
1278                 const WINDOW *z)
1279                 { return(*(int *)0); }
1280
1281 #undef getcurx
1282 int     (getcurx)(
1283                 const WINDOW *z)
1284                 { return(*(int *)0); }
1285
1286 #undef getcury
1287 int     (getcury)(
1288                 const WINDOW *z)
1289                 { return(*(int *)0); }
1290
1291 #undef getbegx
1292 int     (getbegx)(
1293                 const WINDOW *z)
1294                 { return(*(int *)0); }
1295
1296 #undef getbegy
1297 int     (getbegy)(
1298                 const WINDOW *z)
1299                 { return(*(int *)0); }
1300
1301 #undef getmaxx
1302 int     (getmaxx)(
1303                 const WINDOW *z)
1304                 { return(*(int *)0); }
1305
1306 #undef getmaxy
1307 int     (getmaxy)(
1308                 const WINDOW *z)
1309                 { return(*(int *)0); }
1310
1311 #undef getparx
1312 int     (getparx)(
1313                 const WINDOW *z)
1314                 { return(*(int *)0); }
1315
1316 #undef getpary
1317 int     (getpary)(
1318                 const WINDOW *z)
1319                 { return(*(int *)0); }
1320
1321 #undef wgetparent
1322 WINDOW  *(wgetparent)(
1323                 const WINDOW *z)
1324                 { return(*(WINDOW **)0); }
1325
1326 #undef is_cleared
1327 NCURSES_BOOL (is_cleared)(
1328                 const WINDOW *z)
1329                 { return(*(NCURSES_BOOL *)0); }
1330
1331 #undef is_idcok
1332 NCURSES_BOOL (is_idcok)(
1333                 const WINDOW *z)
1334                 { return(*(NCURSES_BOOL *)0); }
1335
1336 #undef is_idlok
1337 NCURSES_BOOL (is_idlok)(
1338                 const WINDOW *z)
1339                 { return(*(NCURSES_BOOL *)0); }
1340
1341 #undef is_immedok
1342 NCURSES_BOOL (is_immedok)(
1343                 const WINDOW *z)
1344                 { return(*(NCURSES_BOOL *)0); }
1345
1346 #undef is_keypad
1347 NCURSES_BOOL (is_keypad)(
1348                 const WINDOW *z)
1349                 { return(*(NCURSES_BOOL *)0); }
1350
1351 #undef is_leaveok
1352 NCURSES_BOOL (is_leaveok)(
1353                 const WINDOW *z)
1354                 { return(*(NCURSES_BOOL *)0); }
1355
1356 #undef is_nodelay
1357 NCURSES_BOOL (is_nodelay)(
1358                 const WINDOW *z)
1359                 { return(*(NCURSES_BOOL *)0); }
1360
1361 #undef is_notimeout
1362 NCURSES_BOOL (is_notimeout)(
1363                 const WINDOW *z)
1364                 { return(*(NCURSES_BOOL *)0); }
1365
1366 #undef is_pad
1367 NCURSES_BOOL (is_pad)(
1368                 const WINDOW *z)
1369                 { return(*(NCURSES_BOOL *)0); }
1370
1371 #undef is_scrollok
1372 NCURSES_BOOL (is_scrollok)(
1373                 const WINDOW *z)
1374                 { return(*(NCURSES_BOOL *)0); }
1375
1376 #undef is_subwin
1377 NCURSES_BOOL (is_subwin)(
1378                 const WINDOW *z)
1379                 { return(*(NCURSES_BOOL *)0); }
1380
1381 #undef is_syncok
1382 NCURSES_BOOL (is_syncok)(
1383                 const WINDOW *z)
1384                 { return(*(NCURSES_BOOL *)0); }
1385
1386 #undef wgetdelay
1387 int     (wgetdelay)(
1388                 const WINDOW *z)
1389                 { return(*(int *)0); }
1390
1391 #undef wgetscrreg
1392 int     (wgetscrreg)(
1393                 const WINDOW *a1, 
1394                 int     *a2, 
1395                 int     *z)
1396                 { return(*(int *)0); }
1397
1398 #undef add_wch
1399 int     (add_wch)(
1400                 const cchar_t *z)
1401                 { return(*(int *)0); }
1402
1403 #undef add_wchnstr
1404 int     (add_wchnstr)(
1405                 const cchar_t *a1, 
1406                 int     z)
1407                 { return(*(int *)0); }
1408
1409 #undef add_wchstr
1410 int     (add_wchstr)(
1411                 const cchar_t *z)
1412                 { return(*(int *)0); }
1413
1414 #undef addnwstr
1415 int     (addnwstr)(
1416                 const wchar_t *a1, 
1417                 int     z)
1418                 { return(*(int *)0); }
1419
1420 #undef addwstr
1421 int     (addwstr)(
1422                 const wchar_t *z)
1423                 { return(*(int *)0); }
1424
1425 #undef bkgrnd
1426 int     (bkgrnd)(
1427                 const cchar_t *z)
1428                 { return(*(int *)0); }
1429
1430 #undef bkgrndset
1431 void    (bkgrndset)(
1432                 const cchar_t *z)
1433                 { /* void */ }
1434
1435 #undef border_set
1436 int     (border_set)(
1437                 const cchar_t *a1, 
1438                 const cchar_t *a2, 
1439                 const cchar_t *a3, 
1440                 const cchar_t *a4, 
1441                 const cchar_t *a5, 
1442                 const cchar_t *a6, 
1443                 const cchar_t *a7, 
1444                 const cchar_t *z)
1445                 { return(*(int *)0); }
1446
1447 #undef box_set
1448 int     (box_set)(
1449                 WINDOW  *a1, 
1450                 const cchar_t *a2, 
1451                 const cchar_t *z)
1452                 { return(*(int *)0); }
1453
1454 #undef echo_wchar
1455 int     (echo_wchar)(
1456                 const cchar_t *z)
1457                 { return(*(int *)0); }
1458
1459 #undef get_wch
1460 int     (get_wch)(
1461                 wint_t  *z)
1462                 { return(*(int *)0); }
1463
1464 #undef get_wstr
1465 int     (get_wstr)(
1466                 wint_t  *z)
1467                 { return(*(int *)0); }
1468
1469 #undef getbkgrnd
1470 int     (getbkgrnd)(
1471                 cchar_t *z)
1472                 { return(*(int *)0); }
1473
1474 #undef getn_wstr
1475 int     (getn_wstr)(
1476                 wint_t  *a1, 
1477                 int     z)
1478                 { return(*(int *)0); }
1479
1480 #undef hline_set
1481 int     (hline_set)(
1482                 const cchar_t *a1, 
1483                 int     z)
1484                 { return(*(int *)0); }
1485
1486 #undef in_wch
1487 int     (in_wch)(
1488                 cchar_t *z)
1489                 { return(*(int *)0); }
1490
1491 #undef in_wchnstr
1492 int     (in_wchnstr)(
1493                 cchar_t *a1, 
1494                 int     z)
1495                 { return(*(int *)0); }
1496
1497 #undef in_wchstr
1498 int     (in_wchstr)(
1499                 cchar_t *z)
1500                 { return(*(int *)0); }
1501
1502 #undef innwstr
1503 int     (innwstr)(
1504                 wchar_t *a1, 
1505                 int     z)
1506                 { return(*(int *)0); }
1507
1508 #undef ins_nwstr
1509 int     (ins_nwstr)(
1510                 const wchar_t *a1, 
1511                 int     z)
1512                 { return(*(int *)0); }
1513
1514 #undef ins_wch
1515 int     (ins_wch)(
1516                 const cchar_t *z)
1517                 { return(*(int *)0); }
1518
1519 #undef ins_wstr
1520 int     (ins_wstr)(
1521                 const wchar_t *z)
1522                 { return(*(int *)0); }
1523
1524 #undef inwstr
1525 int     (inwstr)(
1526                 wchar_t *z)
1527                 { return(*(int *)0); }
1528
1529 #undef mvadd_wch
1530 int     (mvadd_wch)(
1531                 int     a1, 
1532                 int     a2, 
1533                 const cchar_t *z)
1534                 { return(*(int *)0); }
1535
1536 #undef mvadd_wchnstr
1537 int     (mvadd_wchnstr)(
1538                 int     a1, 
1539                 int     a2, 
1540                 const cchar_t *a3, 
1541                 int     z)
1542                 { return(*(int *)0); }
1543
1544 #undef mvadd_wchstr
1545 int     (mvadd_wchstr)(
1546                 int     a1, 
1547                 int     a2, 
1548                 const cchar_t *z)
1549                 { return(*(int *)0); }
1550
1551 #undef mvaddnwstr
1552 int     (mvaddnwstr)(
1553                 int     a1, 
1554                 int     a2, 
1555                 const wchar_t *a3, 
1556                 int     z)
1557                 { return(*(int *)0); }
1558
1559 #undef mvaddwstr
1560 int     (mvaddwstr)(
1561                 int     a1, 
1562                 int     a2, 
1563                 const wchar_t *z)
1564                 { return(*(int *)0); }
1565
1566 #undef mvget_wch
1567 int     (mvget_wch)(
1568                 int     a1, 
1569                 int     a2, 
1570                 wint_t  *z)
1571                 { return(*(int *)0); }
1572
1573 #undef mvget_wstr
1574 int     (mvget_wstr)(
1575                 int     a1, 
1576                 int     a2, 
1577                 wint_t  *z)
1578                 { return(*(int *)0); }
1579
1580 #undef mvgetn_wstr
1581 int     (mvgetn_wstr)(
1582                 int     a1, 
1583                 int     a2, 
1584                 wint_t  *a3, 
1585                 int     z)
1586                 { return(*(int *)0); }
1587
1588 #undef mvhline_set
1589 int     (mvhline_set)(
1590                 int     a1, 
1591                 int     a2, 
1592                 const cchar_t *a3, 
1593                 int     z)
1594                 { return(*(int *)0); }
1595
1596 #undef mvin_wch
1597 int     (mvin_wch)(
1598                 int     a1, 
1599                 int     a2, 
1600                 cchar_t *z)
1601                 { return(*(int *)0); }
1602
1603 #undef mvin_wchnstr
1604 int     (mvin_wchnstr)(
1605                 int     a1, 
1606                 int     a2, 
1607                 cchar_t *a3, 
1608                 int     z)
1609                 { return(*(int *)0); }
1610
1611 #undef mvin_wchstr
1612 int     (mvin_wchstr)(
1613                 int     a1, 
1614                 int     a2, 
1615                 cchar_t *z)
1616                 { return(*(int *)0); }
1617
1618 #undef mvinnwstr
1619 int     (mvinnwstr)(
1620                 int     a1, 
1621                 int     a2, 
1622                 wchar_t *a3, 
1623                 int     z)
1624                 { return(*(int *)0); }
1625
1626 #undef mvins_nwstr
1627 int     (mvins_nwstr)(
1628                 int     a1, 
1629                 int     a2, 
1630                 const wchar_t *a3, 
1631                 int     z)
1632                 { return(*(int *)0); }
1633
1634 #undef mvins_wch
1635 int     (mvins_wch)(
1636                 int     a1, 
1637                 int     a2, 
1638                 const cchar_t *z)
1639                 { return(*(int *)0); }
1640
1641 #undef mvins_wstr
1642 int     (mvins_wstr)(
1643                 int     a1, 
1644                 int     a2, 
1645                 const wchar_t *z)
1646                 { return(*(int *)0); }
1647
1648 #undef mvinwstr
1649 int     (mvinwstr)(
1650                 int     a1, 
1651                 int     a2, 
1652                 wchar_t *z)
1653                 { return(*(int *)0); }
1654
1655 #undef mvvline_set
1656 int     (mvvline_set)(
1657                 int     a1, 
1658                 int     a2, 
1659                 const cchar_t *a3, 
1660                 int     z)
1661                 { return(*(int *)0); }
1662
1663 #undef mvwadd_wch
1664 int     (mvwadd_wch)(
1665                 WINDOW  *a1, 
1666                 int     a2, 
1667                 int     a3, 
1668                 const cchar_t *z)
1669                 { return(*(int *)0); }
1670
1671 #undef mvwadd_wchnstr
1672 int     (mvwadd_wchnstr)(
1673                 WINDOW  *a1, 
1674                 int     a2, 
1675                 int     a3, 
1676                 const cchar_t *a4, 
1677                 int     z)
1678                 { return(*(int *)0); }
1679
1680 #undef mvwadd_wchstr
1681 int     (mvwadd_wchstr)(
1682                 WINDOW  *a1, 
1683                 int     a2, 
1684                 int     a3, 
1685                 const cchar_t *z)
1686                 { return(*(int *)0); }
1687
1688 #undef mvwaddnwstr
1689 int     (mvwaddnwstr)(
1690                 WINDOW  *a1, 
1691                 int     a2, 
1692                 int     a3, 
1693                 const wchar_t *a4, 
1694                 int     z)
1695                 { return(*(int *)0); }
1696
1697 #undef mvwaddwstr
1698 int     (mvwaddwstr)(
1699                 WINDOW  *a1, 
1700                 int     a2, 
1701                 int     a3, 
1702                 const wchar_t *z)
1703                 { return(*(int *)0); }
1704
1705 #undef mvwget_wch
1706 int     (mvwget_wch)(
1707                 WINDOW  *a1, 
1708                 int     a2, 
1709                 int     a3, 
1710                 wint_t  *z)
1711                 { return(*(int *)0); }
1712
1713 #undef mvwget_wstr
1714 int     (mvwget_wstr)(
1715                 WINDOW  *a1, 
1716                 int     a2, 
1717                 int     a3, 
1718                 wint_t  *z)
1719                 { return(*(int *)0); }
1720
1721 #undef mvwgetn_wstr
1722 int     (mvwgetn_wstr)(
1723                 WINDOW  *a1, 
1724                 int     a2, 
1725                 int     a3, 
1726                 wint_t  *a4, 
1727                 int     z)
1728                 { return(*(int *)0); }
1729
1730 #undef mvwhline_set
1731 int     (mvwhline_set)(
1732                 WINDOW  *a1, 
1733                 int     a2, 
1734                 int     a3, 
1735                 const cchar_t *a4, 
1736                 int     z)
1737                 { return(*(int *)0); }
1738
1739 #undef mvwin_wch
1740 int     (mvwin_wch)(
1741                 WINDOW  *a1, 
1742                 int     a2, 
1743                 int     a3, 
1744                 cchar_t *z)
1745                 { return(*(int *)0); }
1746
1747 #undef mvwin_wchnstr
1748 int     (mvwin_wchnstr)(
1749                 WINDOW  *a1, 
1750                 int     a2, 
1751                 int     a3, 
1752                 cchar_t *a4, 
1753                 int     z)
1754                 { return(*(int *)0); }
1755
1756 #undef mvwin_wchstr
1757 int     (mvwin_wchstr)(
1758                 WINDOW  *a1, 
1759                 int     a2, 
1760                 int     a3, 
1761                 cchar_t *z)
1762                 { return(*(int *)0); }
1763
1764 #undef mvwinnwstr
1765 int     (mvwinnwstr)(
1766                 WINDOW  *a1, 
1767                 int     a2, 
1768                 int     a3, 
1769                 wchar_t *a4, 
1770                 int     z)
1771                 { return(*(int *)0); }
1772
1773 #undef mvwins_nwstr
1774 int     (mvwins_nwstr)(
1775                 WINDOW  *a1, 
1776                 int     a2, 
1777                 int     a3, 
1778                 const wchar_t *a4, 
1779                 int     z)
1780                 { return(*(int *)0); }
1781
1782 #undef mvwins_wch
1783 int     (mvwins_wch)(
1784                 WINDOW  *a1, 
1785                 int     a2, 
1786                 int     a3, 
1787                 const cchar_t *z)
1788                 { return(*(int *)0); }
1789
1790 #undef mvwins_wstr
1791 int     (mvwins_wstr)(
1792                 WINDOW  *a1, 
1793                 int     a2, 
1794                 int     a3, 
1795                 const wchar_t *z)
1796                 { return(*(int *)0); }
1797
1798 #undef mvwinwstr
1799 int     (mvwinwstr)(
1800                 WINDOW  *a1, 
1801                 int     a2, 
1802                 int     a3, 
1803                 wchar_t *z)
1804                 { return(*(int *)0); }
1805
1806 #undef mvwvline_set
1807 int     (mvwvline_set)(
1808                 WINDOW  *a1, 
1809                 int     a2, 
1810                 int     a3, 
1811                 const cchar_t *a4, 
1812                 int     z)
1813                 { return(*(int *)0); }
1814
1815 #undef vline_set
1816 int     (vline_set)(
1817                 const cchar_t *a1, 
1818                 int     z)
1819                 { return(*(int *)0); }
1820
1821 #undef wadd_wchstr
1822 int     (wadd_wchstr)(
1823                 WINDOW  *a1, 
1824                 const cchar_t *z)
1825                 { return(*(int *)0); }
1826
1827 #undef waddwstr
1828 int     (waddwstr)(
1829                 WINDOW  *a1, 
1830                 const wchar_t *z)
1831                 { return(*(int *)0); }
1832
1833 #undef wget_wstr
1834 int     (wget_wstr)(
1835                 WINDOW  *a1, 
1836                 wint_t  *z)
1837                 { return(*(int *)0); }
1838
1839 #undef wgetbkgrnd
1840 int     (wgetbkgrnd)(
1841                 WINDOW  *a1, 
1842                 cchar_t *z)
1843                 { return(*(int *)0); }
1844
1845 #undef win_wchstr
1846 int     (win_wchstr)(
1847                 WINDOW  *a1, 
1848                 cchar_t *z)
1849                 { return(*(int *)0); }
1850
1851 #undef wins_wstr
1852 int     (wins_wstr)(
1853                 WINDOW  *a1, 
1854                 const wchar_t *z)
1855                 { return(*(int *)0); }
1856
1857 #undef mouse_trafo
1858 NCURSES_BOOL (mouse_trafo)(
1859                 int     *a1, 
1860                 int     *a2, 
1861                 NCURSES_BOOL z)
1862                 { return(*(NCURSES_BOOL *)0); }
1863
1864 /* ./base/lib_getch.c */
1865
1866 #undef ESCDELAY
1867 int     ESCDELAY;
1868
1869 #undef set_escdelay_sp
1870 int     set_escdelay_sp(
1871                 SCREEN  *sp, 
1872                 int     value)
1873                 { return(*(int *)0); }
1874
1875 #undef set_escdelay
1876 int     set_escdelay(
1877                 int     value)
1878                 { return(*(int *)0); }
1879
1880 #undef get_escdelay_sp
1881 int     get_escdelay_sp(
1882                 SCREEN  *sp)
1883                 { return(*(int *)0); }
1884
1885 #undef get_escdelay
1886 int     get_escdelay(void)
1887                 { return(*(int *)0); }
1888
1889 #undef _nc_wgetch
1890 int     _nc_wgetch(
1891                 WINDOW  *win, 
1892                 int     *result, 
1893                 int     use_meta)
1894                 { return(*(int *)0); }
1895
1896 #undef wgetch
1897 int     wgetch(
1898                 WINDOW  *win)
1899                 { return(*(int *)0); }
1900
1901 /* ./base/lib_getstr.c */
1902
1903 #undef wgetnstr
1904 int     wgetnstr(
1905                 WINDOW  *win, 
1906                 char    *str, 
1907                 int     maxlen)
1908                 { return(*(int *)0); }
1909
1910 /* ./base/lib_hline.c */
1911
1912 #undef whline
1913 int     whline(
1914                 WINDOW  *win, 
1915                 chtype  ch, 
1916                 int     n)
1917                 { return(*(int *)0); }
1918
1919 /* ./base/lib_immedok.c */
1920
1921 #undef immedok
1922 void    immedok(
1923                 WINDOW  *win, 
1924                 NCURSES_BOOL flag)
1925                 { /* void */ }
1926
1927 /* ./base/lib_inchstr.c */
1928
1929 #undef winchnstr
1930 int     winchnstr(
1931                 WINDOW  *win, 
1932                 chtype  *str, 
1933                 int     n)
1934                 { return(*(int *)0); }
1935
1936 /* ./base/lib_initscr.c */
1937
1938 #undef initscr
1939 WINDOW  *initscr(void)
1940                 { return(*(WINDOW **)0); }
1941
1942 /* ./base/lib_insch.c */
1943
1944 #undef _nc_insert_ch
1945 int     _nc_insert_ch(
1946                 SCREEN  *sp, 
1947                 WINDOW  *win, 
1948                 chtype  ch)
1949                 { return(*(int *)0); }
1950
1951 #undef winsch
1952 int     winsch(
1953                 WINDOW  *win, 
1954                 chtype  c)
1955                 { return(*(int *)0); }
1956
1957 /* ./base/lib_insdel.c */
1958
1959 #undef winsdelln
1960 int     winsdelln(
1961                 WINDOW  *win, 
1962                 int     n)
1963                 { return(*(int *)0); }
1964
1965 /* ./base/lib_insnstr.c */
1966
1967 #undef winsnstr
1968 int     winsnstr(
1969                 WINDOW  *win, 
1970                 const char *s, 
1971                 int     n)
1972                 { return(*(int *)0); }
1973
1974 /* ./base/lib_instr.c */
1975
1976 #undef winnstr
1977 int     winnstr(
1978                 WINDOW  *win, 
1979                 char    *str, 
1980                 int     n)
1981                 { return(*(int *)0); }
1982
1983 /* ./base/lib_isendwin.c */
1984
1985 #undef isendwin_sp
1986 NCURSES_BOOL isendwin_sp(
1987                 SCREEN  *sp)
1988                 { return(*(NCURSES_BOOL *)0); }
1989
1990 #undef isendwin
1991 NCURSES_BOOL isendwin(void)
1992                 { return(*(NCURSES_BOOL *)0); }
1993
1994 /* ./base/lib_leaveok.c */
1995
1996 #undef leaveok
1997 int     leaveok(
1998                 WINDOW  *win, 
1999                 NCURSES_BOOL flag)
2000                 { return(*(int *)0); }
2001
2002 /* ./base/lib_mouse.c */
2003
2004 #undef getmouse_sp
2005 int     getmouse_sp(
2006                 SCREEN  *sp, 
2007                 MEVENT  *aevent)
2008                 { return(*(int *)0); }
2009
2010 #undef getmouse
2011 int     getmouse(
2012                 MEVENT  *aevent)
2013                 { return(*(int *)0); }
2014
2015 #undef ungetmouse_sp
2016 int     ungetmouse_sp(
2017                 SCREEN  *sp, 
2018                 MEVENT  *aevent)
2019                 { return(*(int *)0); }
2020
2021 #undef ungetmouse
2022 int     ungetmouse(
2023                 MEVENT  *aevent)
2024                 { return(*(int *)0); }
2025
2026 #undef mousemask_sp
2027 mmask_t mousemask_sp(
2028                 SCREEN  *sp, 
2029                 mmask_t newmask, 
2030                 mmask_t *oldmask)
2031                 { return(*(mmask_t *)0); }
2032
2033 #undef mousemask
2034 mmask_t mousemask(
2035                 mmask_t newmask, 
2036                 mmask_t *oldmask)
2037                 { return(*(mmask_t *)0); }
2038
2039 #undef wenclose
2040 NCURSES_BOOL wenclose(
2041                 const WINDOW *win, 
2042                 int     y, 
2043                 int     x)
2044                 { return(*(NCURSES_BOOL *)0); }
2045
2046 #undef mouseinterval_sp
2047 int     mouseinterval_sp(
2048                 SCREEN  *sp, 
2049                 int     maxclick)
2050                 { return(*(int *)0); }
2051
2052 #undef mouseinterval
2053 int     mouseinterval(
2054                 int     maxclick)
2055                 { return(*(int *)0); }
2056
2057 #undef _nc_has_mouse
2058 NCURSES_BOOL _nc_has_mouse(
2059                 SCREEN  *sp)
2060                 { return(*(NCURSES_BOOL *)0); }
2061
2062 #undef has_mouse_sp
2063 NCURSES_BOOL has_mouse_sp(
2064                 SCREEN  *sp)
2065                 { return(*(NCURSES_BOOL *)0); }
2066
2067 #undef has_mouse
2068 NCURSES_BOOL has_mouse(void)
2069                 { return(*(NCURSES_BOOL *)0); }
2070
2071 #undef wmouse_trafo
2072 NCURSES_BOOL wmouse_trafo(
2073                 const WINDOW *win, 
2074                 int     *pY, 
2075                 int     *pX, 
2076                 NCURSES_BOOL to_screen)
2077                 { return(*(NCURSES_BOOL *)0); }
2078
2079 /* ./base/lib_move.c */
2080
2081 #undef wmove
2082 int     wmove(
2083                 WINDOW  *win, 
2084                 int     y, 
2085                 int     x)
2086                 { return(*(int *)0); }
2087
2088 /* ./tty/lib_mvcur.c */
2089
2090 #undef _nc_msec_cost_sp
2091 int     _nc_msec_cost_sp(
2092                 SCREEN  *sp, 
2093                 const char *const cap, 
2094                 int     affcnt)
2095                 { return(*(int *)0); }
2096
2097 #undef _nc_msec_cost
2098 int     _nc_msec_cost(
2099                 const char *const cap, 
2100                 int     affcnt)
2101                 { return(*(int *)0); }
2102
2103 #undef _nc_mvcur_resume_sp
2104 void    _nc_mvcur_resume_sp(
2105                 SCREEN  *sp)
2106                 { /* void */ }
2107
2108 #undef _nc_mvcur_resume
2109 void    _nc_mvcur_resume(void)
2110                 { /* void */ }
2111
2112 #undef _nc_mvcur_init_sp
2113 void    _nc_mvcur_init_sp(
2114                 SCREEN  *sp)
2115                 { /* void */ }
2116
2117 #undef _nc_mvcur_init
2118 void    _nc_mvcur_init(void)
2119                 { /* void */ }
2120
2121 #undef _nc_mvcur_wrap_sp
2122 void    _nc_mvcur_wrap_sp(
2123                 SCREEN  *sp)
2124                 { /* void */ }
2125
2126 #undef _nc_mvcur_wrap
2127 void    _nc_mvcur_wrap(void)
2128                 { /* void */ }
2129
2130 #undef _nc_mvcur_sp
2131 int     _nc_mvcur_sp(
2132                 SCREEN  *sp, 
2133                 int     yold, 
2134                 int     xold, 
2135                 int     ynew, 
2136                 int     xnew)
2137                 { return(*(int *)0); }
2138
2139 #undef _nc_mvcur
2140 int     _nc_mvcur(
2141                 int     yold, 
2142                 int     xold, 
2143                 int     ynew, 
2144                 int     xnew)
2145                 { return(*(int *)0); }
2146
2147 #undef mvcur_sp
2148 int     mvcur_sp(
2149                 SCREEN  *sp, 
2150                 int     yold, 
2151                 int     xold, 
2152                 int     ynew, 
2153                 int     xnew)
2154                 { return(*(int *)0); }
2155
2156 #undef mvcur
2157 int     mvcur(
2158                 int     yold, 
2159                 int     xold, 
2160                 int     ynew, 
2161                 int     xnew)
2162                 { return(*(int *)0); }
2163
2164 #undef _nc_optimize_enable
2165 int     _nc_optimize_enable;
2166
2167 /* ./base/lib_mvwin.c */
2168
2169 #undef mvwin
2170 int     mvwin(
2171                 WINDOW  *win, 
2172                 int     by, 
2173                 int     bx)
2174                 { return(*(int *)0); }
2175
2176 /* ./base/lib_newterm.c */
2177
2178 #undef filter_sp
2179 void    filter_sp(
2180                 SCREEN  *sp)
2181                 { /* void */ }
2182
2183 #undef filter
2184 void    filter(void)
2185                 { /* void */ }
2186
2187 #undef nofilter_sp
2188 void    nofilter_sp(
2189                 SCREEN  *sp)
2190                 { /* void */ }
2191
2192 #undef nofilter
2193 void    nofilter(void)
2194                 { /* void */ }
2195
2196 #undef newterm_sp
2197 SCREEN  *newterm_sp(
2198                 SCREEN  *sp, 
2199                 const char *name, 
2200                 FILE    *ofp, 
2201                 FILE    *ifp)
2202                 { return(*(SCREEN **)0); }
2203
2204 #undef newterm
2205 SCREEN  *newterm(
2206                 const char *name, 
2207                 FILE    *ofp, 
2208                 FILE    *ifp)
2209                 { return(*(SCREEN **)0); }
2210
2211 /* ./base/lib_newwin.c */
2212
2213 #undef _nc_freewin
2214 int     _nc_freewin(
2215                 WINDOW  *win)
2216                 { return(*(int *)0); }
2217
2218 #undef newwin_sp
2219 WINDOW  *newwin_sp(
2220                 SCREEN  *sp, 
2221                 int     num_lines, 
2222                 int     num_columns, 
2223                 int     begy, 
2224                 int     begx)
2225                 { return(*(WINDOW **)0); }
2226
2227 #undef newwin
2228 WINDOW  *newwin(
2229                 int     num_lines, 
2230                 int     num_columns, 
2231                 int     begy, 
2232                 int     begx)
2233                 { return(*(WINDOW **)0); }
2234
2235 #undef derwin
2236 WINDOW  *derwin(
2237                 WINDOW  *orig, 
2238                 int     num_lines, 
2239                 int     num_columns, 
2240                 int     begy, 
2241                 int     begx)
2242                 { return(*(WINDOW **)0); }
2243
2244 #undef subwin
2245 WINDOW  *subwin(
2246                 WINDOW  *w, 
2247                 int     l, 
2248                 int     c, 
2249                 int     y, 
2250                 int     x)
2251                 { return(*(WINDOW **)0); }
2252
2253 #undef _nc_makenew_sp
2254 WINDOW  *_nc_makenew_sp(
2255                 SCREEN  *sp, 
2256                 int     num_lines, 
2257                 int     num_columns, 
2258                 int     begy, 
2259                 int     begx, 
2260                 int     flags)
2261                 { return(*(WINDOW **)0); }
2262
2263 #undef _nc_curscr_of
2264 WINDOW  *_nc_curscr_of(
2265                 SCREEN  *sp)
2266                 { return(*(WINDOW **)0); }
2267
2268 #undef _nc_newscr_of
2269 WINDOW  *_nc_newscr_of(
2270                 SCREEN  *sp)
2271                 { return(*(WINDOW **)0); }
2272
2273 #undef _nc_stdscr_of
2274 WINDOW  *_nc_stdscr_of(
2275                 SCREEN  *sp)
2276                 { return(*(WINDOW **)0); }
2277
2278 /* ./base/lib_nl.c */
2279
2280 #undef nl_sp
2281 int     nl_sp(
2282                 SCREEN  *sp)
2283                 { return(*(int *)0); }
2284
2285 #undef nl
2286 int     nl(void)
2287                 { return(*(int *)0); }
2288
2289 #undef nonl_sp
2290 int     nonl_sp(
2291                 SCREEN  *sp)
2292                 { return(*(int *)0); }
2293
2294 #undef nonl
2295 int     nonl(void)
2296                 { return(*(int *)0); }
2297
2298 /* ./base/lib_overlay.c */
2299
2300 #undef overlay
2301 int     overlay(
2302                 const WINDOW *win1, 
2303                 WINDOW  *win2)
2304                 { return(*(int *)0); }
2305
2306 #undef overwrite
2307 int     overwrite(
2308                 const WINDOW *win1, 
2309                 WINDOW  *win2)
2310                 { return(*(int *)0); }
2311
2312 #undef copywin
2313 int     copywin(
2314                 const WINDOW *src, 
2315                 WINDOW  *dst, 
2316                 int     sminrow, 
2317                 int     smincol, 
2318                 int     dminrow, 
2319                 int     dmincol, 
2320                 int     dmaxrow, 
2321                 int     dmaxcol, 
2322                 int     over)
2323                 { return(*(int *)0); }
2324
2325 /* ./base/lib_pad.c */
2326
2327 #undef newpad_sp
2328 WINDOW  *newpad_sp(
2329                 SCREEN  *sp, 
2330                 int     l, 
2331                 int     c)
2332                 { return(*(WINDOW **)0); }
2333
2334 #undef newpad
2335 WINDOW  *newpad(
2336                 int     l, 
2337                 int     c)
2338                 { return(*(WINDOW **)0); }
2339
2340 #undef subpad
2341 WINDOW  *subpad(
2342                 WINDOW  *orig, 
2343                 int     l, 
2344                 int     c, 
2345                 int     begy, 
2346                 int     begx)
2347                 { return(*(WINDOW **)0); }
2348
2349 #undef prefresh
2350 int     prefresh(
2351                 WINDOW  *win, 
2352                 int     pminrow, 
2353                 int     pmincol, 
2354                 int     sminrow, 
2355                 int     smincol, 
2356                 int     smaxrow, 
2357                 int     smaxcol)
2358                 { return(*(int *)0); }
2359
2360 #undef pnoutrefresh
2361 int     pnoutrefresh(
2362                 WINDOW  *win, 
2363                 int     pminrow, 
2364                 int     pmincol, 
2365                 int     sminrow, 
2366                 int     smincol, 
2367                 int     smaxrow, 
2368                 int     smaxcol)
2369                 { return(*(int *)0); }
2370
2371 #undef pechochar
2372 int     pechochar(
2373                 WINDOW  *pad, 
2374                 const chtype ch)
2375                 { return(*(int *)0); }
2376
2377 /* ./base/lib_printw.c */
2378
2379 #undef printw
2380 int     printw(
2381                 const char *fmt, 
2382                 ...)
2383                 { return(*(int *)0); }
2384
2385 #undef wprintw
2386 int     wprintw(
2387                 WINDOW  *win, 
2388                 const char *fmt, 
2389                 ...)
2390                 { return(*(int *)0); }
2391
2392 #undef mvprintw
2393 int     mvprintw(
2394                 int     y, 
2395                 int     x, 
2396                 const char *fmt, 
2397                 ...)
2398                 { return(*(int *)0); }
2399
2400 #undef mvwprintw
2401 int     mvwprintw(
2402                 WINDOW  *win, 
2403                 int     y, 
2404                 int     x, 
2405                 const char *fmt, 
2406                 ...)
2407                 { return(*(int *)0); }
2408
2409 #undef vwprintw
2410 int     vwprintw(
2411                 WINDOW  *win, 
2412                 const char *fmt, 
2413                 va_list argp)
2414                 { return(*(int *)0); }
2415
2416 #undef vw_printw
2417 int     vw_printw(
2418                 WINDOW  *win, 
2419                 const char *fmt, 
2420                 va_list argp)
2421                 { return(*(int *)0); }
2422
2423 /* ./base/lib_redrawln.c */
2424
2425 #undef wredrawln
2426 int     wredrawln(
2427                 WINDOW  *win, 
2428                 int     beg, 
2429                 int     num)
2430                 { return(*(int *)0); }
2431
2432 /* ./base/lib_refresh.c */
2433
2434 #undef wrefresh
2435 int     wrefresh(
2436                 WINDOW  *win)
2437                 { return(*(int *)0); }
2438
2439 #undef wnoutrefresh
2440 int     wnoutrefresh(
2441                 WINDOW  *win)
2442                 { return(*(int *)0); }
2443
2444 /* ./base/lib_restart.c */
2445
2446 #undef restartterm_sp
2447 int     restartterm_sp(
2448                 SCREEN  *sp, 
2449                 const char *termp, 
2450                 int     filenum, 
2451                 int     *errret)
2452                 { return(*(int *)0); }
2453
2454 #undef restartterm
2455 int     restartterm(
2456                 const char *termp, 
2457                 int     filenum, 
2458                 int     *errret)
2459                 { return(*(int *)0); }
2460
2461 /* ./base/lib_scanw.c */
2462
2463 #undef vwscanw
2464 int     vwscanw(
2465                 WINDOW  *win, 
2466                 const char *fmt, 
2467                 va_list argp)
2468                 { return(*(int *)0); }
2469
2470 #undef vw_scanw
2471 int     vw_scanw(
2472                 WINDOW  *win, 
2473                 const char *fmt, 
2474                 va_list argp)
2475                 { return(*(int *)0); }
2476
2477 #undef scanw
2478 int     scanw(
2479                 const char *fmt, 
2480                 ...)
2481                 { return(*(int *)0); }
2482
2483 #undef wscanw
2484 int     wscanw(
2485                 WINDOW  *win, 
2486                 const char *fmt, 
2487                 ...)
2488                 { return(*(int *)0); }
2489
2490 #undef mvscanw
2491 int     mvscanw(
2492                 int     y, 
2493                 int     x, 
2494                 const char *fmt, 
2495                 ...)
2496                 { return(*(int *)0); }
2497
2498 #undef mvwscanw
2499 int     mvwscanw(
2500                 WINDOW  *win, 
2501                 int     y, 
2502                 int     x, 
2503                 const char *fmt, 
2504                 ...)
2505                 { return(*(int *)0); }
2506
2507 /* ./base/lib_screen.c */
2508
2509 #undef getwin_sp
2510 WINDOW  *getwin_sp(
2511                 SCREEN  *sp, 
2512                 FILE    *filep)
2513                 { return(*(WINDOW **)0); }
2514
2515 #undef getwin
2516 WINDOW  *getwin(
2517                 FILE    *filep)
2518                 { return(*(WINDOW **)0); }
2519
2520 #undef putwin
2521 int     putwin(
2522                 WINDOW  *win, 
2523                 FILE    *filep)
2524                 { return(*(int *)0); }
2525
2526 #undef scr_restore_sp
2527 int     scr_restore_sp(
2528                 SCREEN  *sp, 
2529                 const char *file)
2530                 { return(*(int *)0); }
2531
2532 #undef scr_restore
2533 int     scr_restore(
2534                 const char *file)
2535                 { return(*(int *)0); }
2536
2537 #undef scr_dump
2538 int     scr_dump(
2539                 const char *file)
2540                 { return(*(int *)0); }
2541
2542 #undef scr_init_sp
2543 int     scr_init_sp(
2544                 SCREEN  *sp, 
2545                 const char *file)
2546                 { return(*(int *)0); }
2547
2548 #undef scr_init
2549 int     scr_init(
2550                 const char *file)
2551                 { return(*(int *)0); }
2552
2553 #undef scr_set_sp
2554 int     scr_set_sp(
2555                 SCREEN  *sp, 
2556                 const char *file)
2557                 { return(*(int *)0); }
2558
2559 #undef scr_set
2560 int     scr_set(
2561                 const char *file)
2562                 { return(*(int *)0); }
2563
2564 /* ./base/lib_scroll.c */
2565
2566 #undef _nc_scroll_window
2567 void    _nc_scroll_window(
2568                 WINDOW  *win, 
2569                 int const n, 
2570                 int const top, 
2571                 int const bottom, 
2572                 cchar_t blank)
2573                 { /* void */ }
2574
2575 #undef wscrl
2576 int     wscrl(
2577                 WINDOW  *win, 
2578                 int     n)
2579                 { return(*(int *)0); }
2580
2581 /* ./base/lib_scrollok.c */
2582
2583 #undef scrollok
2584 int     scrollok(
2585                 WINDOW  *win, 
2586                 NCURSES_BOOL flag)
2587                 { return(*(int *)0); }
2588
2589 /* ./base/lib_scrreg.c */
2590
2591 #undef wsetscrreg
2592 int     wsetscrreg(
2593                 WINDOW  *win, 
2594                 int     top, 
2595                 int     bottom)
2596                 { return(*(int *)0); }
2597
2598 /* ./base/lib_set_term.c */
2599
2600 #undef set_term
2601 SCREEN  *set_term(
2602                 SCREEN  *screenp)
2603                 { return(*(SCREEN **)0); }
2604
2605 #undef delscreen
2606 void    delscreen(
2607                 SCREEN  *sp)
2608                 { /* void */ }
2609
2610 #undef _nc_setupscreen_sp
2611 int     _nc_setupscreen_sp(
2612                 SCREEN  **spp, 
2613                 int     slines, 
2614                 int     scolumns, 
2615                 FILE    *output, 
2616                 int     filtered, 
2617                 int     slk_format)
2618                 { return(*(int *)0); }
2619
2620 #undef _nc_setupscreen
2621 int     _nc_setupscreen(
2622                 int     slines, 
2623                 int     scolumns, 
2624                 FILE    *output, 
2625                 int     filtered, 
2626                 int     slk_format)
2627                 { return(*(int *)0); }
2628
2629 #undef _nc_ripoffline_sp
2630 int     _nc_ripoffline_sp(
2631                 SCREEN  *sp, 
2632                 int     line, 
2633                 int     (*init)(
2634                 WINDOW  *p1, 
2635                 int     p2))
2636                 { return(*(int *)0); }
2637
2638 #undef _nc_ripoffline
2639 int     _nc_ripoffline(
2640                 int     line, 
2641                 int     (*init)(
2642                 WINDOW  *p1, 
2643                 int     p2))
2644                 { return(*(int *)0); }
2645
2646 #undef ripoffline_sp
2647 int     ripoffline_sp(
2648                 SCREEN  *sp, 
2649                 int     line, 
2650                 int     (*init)(
2651                 WINDOW  *p1, 
2652                 int     p2))
2653                 { return(*(int *)0); }
2654
2655 #undef ripoffline
2656 int     ripoffline(
2657                 int     line, 
2658                 int     (*init)(
2659                 WINDOW  *p1, 
2660                 int     p2))
2661                 { return(*(int *)0); }
2662
2663 /* ./base/lib_slk.c */
2664
2665 #undef _nc_format_slks
2666 int     _nc_format_slks(
2667                 SCREEN  *sp, 
2668                 int     cols)
2669                 { return(*(int *)0); }
2670
2671 #undef _nc_slk_initialize
2672 int     _nc_slk_initialize(
2673                 WINDOW  *stwin, 
2674                 int     cols)
2675                 { return(*(int *)0); }
2676
2677 #undef slk_restore_sp
2678 int     slk_restore_sp(
2679                 SCREEN  *sp)
2680                 { return(*(int *)0); }
2681
2682 #undef slk_restore
2683 int     slk_restore(void)
2684                 { return(*(int *)0); }
2685
2686 /* ./base/lib_slkatr_set.c */
2687
2688 #undef slk_attr_set_sp
2689 int     slk_attr_set_sp(
2690                 SCREEN  *sp, 
2691                 const attr_t attr, 
2692                 short   pair_arg, 
2693                 void    *opts)
2694                 { return(*(int *)0); }
2695
2696 #undef slk_attr_set
2697 int     slk_attr_set(
2698                 const attr_t attr, 
2699                 short   pair_arg, 
2700                 void    *opts)
2701                 { return(*(int *)0); }
2702
2703 /* ./base/lib_slkatrof.c */
2704
2705 #undef slk_attroff_sp
2706 int     slk_attroff_sp(
2707                 SCREEN  *sp, 
2708                 const chtype attr)
2709                 { return(*(int *)0); }
2710
2711 #undef slk_attroff
2712 int     slk_attroff(
2713                 const chtype attr)
2714                 { return(*(int *)0); }
2715
2716 /* ./base/lib_slkatron.c */
2717
2718 #undef slk_attron_sp
2719 int     slk_attron_sp(
2720                 SCREEN  *sp, 
2721                 const chtype attr)
2722                 { return(*(int *)0); }
2723
2724 #undef slk_attron
2725 int     slk_attron(
2726                 const chtype attr)
2727                 { return(*(int *)0); }
2728
2729 /* ./base/lib_slkatrset.c */
2730
2731 #undef slk_attrset_sp
2732 int     slk_attrset_sp(
2733                 SCREEN  *sp, 
2734                 const chtype attr)
2735                 { return(*(int *)0); }
2736
2737 #undef slk_attrset
2738 int     slk_attrset(
2739                 const chtype attr)
2740                 { return(*(int *)0); }
2741
2742 /* ./base/lib_slkattr.c */
2743
2744 #undef slk_attr_sp
2745 attr_t  slk_attr_sp(
2746                 SCREEN  *sp)
2747                 { return(*(attr_t *)0); }
2748
2749 #undef slk_attr
2750 attr_t  slk_attr(void)
2751                 { return(*(attr_t *)0); }
2752
2753 /* ./base/lib_slkclear.c */
2754
2755 #undef slk_clear_sp
2756 int     slk_clear_sp(
2757                 SCREEN  *sp)
2758                 { return(*(int *)0); }
2759
2760 #undef slk_clear
2761 int     slk_clear(void)
2762                 { return(*(int *)0); }
2763
2764 /* ./base/lib_slkcolor.c */
2765
2766 #undef slk_color_sp
2767 int     slk_color_sp(
2768                 SCREEN  *sp, 
2769                 short   pair_arg)
2770                 { return(*(int *)0); }
2771
2772 #undef slk_color
2773 int     slk_color(
2774                 short   pair_arg)
2775                 { return(*(int *)0); }
2776
2777 #undef extended_slk_color_sp
2778 int     extended_slk_color_sp(
2779                 SCREEN  *sp, 
2780                 int     pair_arg)
2781                 { return(*(int *)0); }
2782
2783 #undef extended_slk_color
2784 int     extended_slk_color(
2785                 int     pair_arg)
2786                 { return(*(int *)0); }
2787
2788 /* ./base/lib_slkinit.c */
2789
2790 #undef slk_init_sp
2791 int     slk_init_sp(
2792                 SCREEN  *sp, 
2793                 int     format)
2794                 { return(*(int *)0); }
2795
2796 #undef slk_init
2797 int     slk_init(
2798                 int     format)
2799                 { return(*(int *)0); }
2800
2801 /* ./base/lib_slklab.c */
2802
2803 #undef slk_label_sp
2804 char    *slk_label_sp(
2805                 SCREEN  *sp, 
2806                 int     n)
2807                 { return(*(char **)0); }
2808
2809 #undef slk_label
2810 char    *slk_label(
2811                 int     n)
2812                 { return(*(char **)0); }
2813
2814 /* ./base/lib_slkrefr.c */
2815
2816 #undef slk_noutrefresh_sp
2817 int     slk_noutrefresh_sp(
2818                 SCREEN  *sp)
2819                 { return(*(int *)0); }
2820
2821 #undef slk_noutrefresh
2822 int     slk_noutrefresh(void)
2823                 { return(*(int *)0); }
2824
2825 #undef slk_refresh_sp
2826 int     slk_refresh_sp(
2827                 SCREEN  *sp)
2828                 { return(*(int *)0); }
2829
2830 #undef slk_refresh
2831 int     slk_refresh(void)
2832                 { return(*(int *)0); }
2833
2834 /* ./base/lib_slkset.c */
2835
2836 #undef slk_set_sp
2837 int     slk_set_sp(
2838                 SCREEN  *sp, 
2839                 int     i, 
2840                 const char *astr, 
2841                 int     format)
2842                 { return(*(int *)0); }
2843
2844 #undef slk_set
2845 int     slk_set(
2846                 int     i, 
2847                 const char *astr, 
2848                 int     format)
2849                 { return(*(int *)0); }
2850
2851 /* ./base/lib_slktouch.c */
2852
2853 #undef slk_touch_sp
2854 int     slk_touch_sp(
2855                 SCREEN  *sp)
2856                 { return(*(int *)0); }
2857
2858 #undef slk_touch
2859 int     slk_touch(void)
2860                 { return(*(int *)0); }
2861
2862 /* ./base/lib_touch.c */
2863
2864 #undef is_linetouched
2865 NCURSES_BOOL is_linetouched(
2866                 WINDOW  *win, 
2867                 int     line)
2868                 { return(*(NCURSES_BOOL *)0); }
2869
2870 #undef is_wintouched
2871 NCURSES_BOOL is_wintouched(
2872                 WINDOW  *win)
2873                 { return(*(NCURSES_BOOL *)0); }
2874
2875 #undef wtouchln
2876 int     wtouchln(
2877                 WINDOW  *win, 
2878                 int     y, 
2879                 int     n, 
2880                 int     changed)
2881                 { return(*(int *)0); }
2882
2883 /* ./trace/lib_tracedmp.c */
2884
2885 #undef _tracedump
2886 void    _tracedump(
2887                 const char *name, 
2888                 WINDOW  *win)
2889                 { /* void */ }
2890
2891 /* ./trace/lib_tracemse.c */
2892
2893 #undef _nc_trace_mmask_t
2894 char    *_nc_trace_mmask_t(
2895                 SCREEN  *sp, 
2896                 mmask_t code)
2897                 { return(*(char **)0); }
2898
2899 #undef _nc_tracemouse
2900 char    *_nc_tracemouse(
2901                 SCREEN  *sp, 
2902                 MEVENT const *ep)
2903                 { return(*(char **)0); }
2904
2905 #undef _nc_retrace_mmask_t
2906 mmask_t _nc_retrace_mmask_t(
2907                 SCREEN  *sp, 
2908                 mmask_t code)
2909                 { return(*(mmask_t *)0); }
2910
2911 #undef _tracemouse
2912 char    *_tracemouse(
2913                 MEVENT const *ep)
2914                 { return(*(char **)0); }
2915
2916 /* ./tty/lib_tstp.c */
2917
2918 #undef _nc_signal_handler
2919 void    _nc_signal_handler(
2920                 int     enable)
2921                 { /* void */ }
2922
2923 /* ./base/lib_ungetch.c */
2924
2925 #undef _nc_fifo_dump
2926 void    _nc_fifo_dump(
2927                 SCREEN  *sp)
2928                 { /* void */ }
2929
2930 #undef ungetch_sp
2931 int     ungetch_sp(
2932                 SCREEN  *sp, 
2933                 int     ch)
2934                 { return(*(int *)0); }
2935
2936 #undef ungetch
2937 int     ungetch(
2938                 int     ch)
2939                 { return(*(int *)0); }
2940
2941 /* ./tty/lib_vidattr.c */
2942
2943 #undef vidputs_sp
2944 int     vidputs_sp(
2945                 SCREEN  *sp, 
2946                 chtype  newmode, 
2947                 NCURSES_OUTC_sp outc)
2948                 { return(*(int *)0); }
2949
2950 #undef vidputs
2951 int     vidputs(
2952                 chtype  newmode, 
2953                 NCURSES_OUTC outc)
2954                 { return(*(int *)0); }
2955
2956 #undef vidattr_sp
2957 int     vidattr_sp(
2958                 SCREEN  *sp, 
2959                 chtype  newmode)
2960                 { return(*(int *)0); }
2961
2962 #undef vidattr
2963 int     vidattr(
2964                 chtype  newmode)
2965                 { return(*(int *)0); }
2966
2967 #undef termattrs_sp
2968 chtype  termattrs_sp(
2969                 SCREEN  *sp)
2970                 { return(*(chtype *)0); }
2971
2972 #undef termattrs
2973 chtype  termattrs(void)
2974                 { return(*(chtype *)0); }
2975
2976 /* ./base/lib_vline.c */
2977
2978 #undef wvline
2979 int     wvline(
2980                 WINDOW  *win, 
2981                 chtype  ch, 
2982                 int     n)
2983                 { return(*(int *)0); }
2984
2985 /* ./base/lib_wattroff.c */
2986
2987 #undef wattr_off
2988 int     wattr_off(
2989                 WINDOW  *win, 
2990                 attr_t  at, 
2991                 void    *opts)
2992                 { return(*(int *)0); }
2993
2994 /* ./base/lib_wattron.c */
2995
2996 #undef wattr_on
2997 int     wattr_on(
2998                 WINDOW  *win, 
2999                 attr_t  at, 
3000                 void    *opts)
3001                 { return(*(int *)0); }
3002
3003 /* ./base/lib_winch.c */
3004
3005 #undef winch
3006 chtype  winch(
3007                 WINDOW  *win)
3008                 { return(*(chtype *)0); }
3009
3010 /* ./base/lib_window.c */
3011
3012 #undef _nc_synchook
3013 void    _nc_synchook(
3014                 WINDOW  *win)
3015                 { /* void */ }
3016
3017 #undef mvderwin
3018 int     mvderwin(
3019                 WINDOW  *win, 
3020                 int     y, 
3021                 int     x)
3022                 { return(*(int *)0); }
3023
3024 #undef syncok
3025 int     syncok(
3026                 WINDOW  *win, 
3027                 NCURSES_BOOL bf)
3028                 { return(*(int *)0); }
3029
3030 #undef wsyncup
3031 void    wsyncup(
3032                 WINDOW  *win)
3033                 { /* void */ }
3034
3035 #undef wsyncdown
3036 void    wsyncdown(
3037                 WINDOW  *win)
3038                 { /* void */ }
3039
3040 #undef wcursyncup
3041 void    wcursyncup(
3042                 WINDOW  *win)
3043                 { /* void */ }
3044
3045 #undef dupwin
3046 WINDOW  *dupwin(
3047                 WINDOW  *win)
3048                 { return(*(WINDOW **)0); }
3049
3050 /* ./base/nc_panel.c */
3051
3052 #undef _nc_panelhook_sp
3053 struct panelhook *_nc_panelhook_sp(
3054                 SCREEN  *sp)
3055                 { return(*(struct panelhook **)0); }
3056
3057 #undef _nc_panelhook
3058 struct panelhook *_nc_panelhook(void)
3059                 { return(*(struct panelhook **)0); }
3060
3061 /* ./base/safe_sprintf.c */
3062
3063 #undef _nc_printf_string_sp
3064 char    *_nc_printf_string_sp(
3065                 SCREEN  *sp, 
3066                 const char *fmt, 
3067                 va_list ap)
3068                 { return(*(char **)0); }
3069
3070 #undef _nc_printf_string
3071 char    *_nc_printf_string(
3072                 const char *fmt, 
3073                 va_list ap)
3074                 { return(*(char **)0); }
3075
3076 /* ./tty/tty_update.c */
3077
3078 #undef doupdate_sp
3079 int     doupdate_sp(
3080                 SCREEN  *sp)
3081                 { return(*(int *)0); }
3082
3083 #undef doupdate
3084 int     doupdate(void)
3085                 { return(*(int *)0); }
3086
3087 #undef _nc_scrolln_sp
3088 int     _nc_scrolln_sp(
3089                 SCREEN  *sp, 
3090                 int     n, 
3091                 int     top, 
3092                 int     bot, 
3093                 int     maxy)
3094                 { return(*(int *)0); }
3095
3096 #undef _nc_scrolln
3097 int     _nc_scrolln(
3098                 int     n, 
3099                 int     top, 
3100                 int     bot, 
3101                 int     maxy)
3102                 { return(*(int *)0); }
3103
3104 #undef _nc_screen_resume_sp
3105 void    _nc_screen_resume_sp(
3106                 SCREEN  *sp)
3107                 { /* void */ }
3108
3109 #undef _nc_screen_resume
3110 void    _nc_screen_resume(void)
3111                 { /* void */ }
3112
3113 #undef _nc_screen_init_sp
3114 void    _nc_screen_init_sp(
3115                 SCREEN  *sp)
3116                 { /* void */ }
3117
3118 #undef _nc_screen_init
3119 void    _nc_screen_init(void)
3120                 { /* void */ }
3121
3122 #undef _nc_screen_wrap_sp
3123 void    _nc_screen_wrap_sp(
3124                 SCREEN  *sp)
3125                 { /* void */ }
3126
3127 #undef _nc_screen_wrap
3128 void    _nc_screen_wrap(void)
3129                 { /* void */ }
3130
3131 #undef _nc_do_xmc_glitch_sp
3132 void    _nc_do_xmc_glitch_sp(
3133                 SCREEN  *sp, 
3134                 attr_t  previous)
3135                 { /* void */ }
3136
3137 #undef _nc_do_xmc_glitch
3138 void    _nc_do_xmc_glitch(
3139                 attr_t  previous)
3140                 { /* void */ }
3141
3142 /* ./trace/varargs.c */
3143
3144 #undef _nc_varargs
3145 char    *_nc_varargs(
3146                 const char *fmt, 
3147                 va_list ap)
3148                 { return(*(char **)0); }
3149
3150 /* ./base/vsscanf.c */
3151
3152 #undef _nc_vsscanf
3153 void    _nc_vsscanf(void)
3154                 { /* void */ }
3155
3156 /* ./base/lib_freeall.c */
3157
3158 #undef _nc_freeall
3159 void    _nc_freeall(void)
3160                 { /* void */ }
3161
3162 #undef _nc_free_and_exit_sp
3163 void    _nc_free_and_exit_sp(
3164                 SCREEN  *sp, 
3165                 int     code)
3166                 { /* void */ }
3167
3168 #undef _nc_free_and_exit
3169 void    _nc_free_and_exit(
3170                 int     code)
3171                 { /* void */ }
3172
3173 #undef exit_curses
3174 void    exit_curses(
3175                 int     code)
3176                 { /* void */ }
3177
3178 /* ./widechar/charable.c */
3179
3180 #undef _nc_is_charable
3181 NCURSES_BOOL _nc_is_charable(
3182                 wchar_t ch)
3183                 { return(*(NCURSES_BOOL *)0); }
3184
3185 #undef _nc_to_char
3186 int     _nc_to_char(
3187                 wint_t  ch)
3188                 { return(*(int *)0); }
3189
3190 #undef _nc_to_widechar
3191 wint_t  _nc_to_widechar(
3192                 int     ch)
3193                 { return(*(wint_t *)0); }
3194
3195 /* ./widechar/lib_add_wch.c */
3196
3197 #undef wadd_wch
3198 int     wadd_wch(
3199                 WINDOW  *win, 
3200                 const cchar_t *wch)
3201                 { return(*(int *)0); }
3202
3203 #undef wecho_wchar
3204 int     wecho_wchar(
3205                 WINDOW  *win, 
3206                 const cchar_t *wch)
3207                 { return(*(int *)0); }
3208
3209 /* ./widechar/lib_box_set.c */
3210
3211 #undef wborder_set
3212 int     wborder_set(
3213                 WINDOW  *win, 
3214                 const cchar_t *ls, 
3215                 const cchar_t *rs, 
3216                 const cchar_t *ts, 
3217                 const cchar_t *bs, 
3218                 const cchar_t *tl, 
3219                 const cchar_t *tr, 
3220                 const cchar_t *bl, 
3221                 const cchar_t *br)
3222                 { return(*(int *)0); }
3223
3224 /* ./widechar/lib_cchar.c */
3225
3226 #undef setcchar
3227 int     setcchar(
3228                 cchar_t *wcval, 
3229                 const wchar_t *wch, 
3230                 const attr_t attrs, 
3231                 short   pair_arg, 
3232                 const void *opts)
3233                 { return(*(int *)0); }
3234
3235 #undef getcchar
3236 int     getcchar(
3237                 const cchar_t *wcval, 
3238                 wchar_t *wch, 
3239                 attr_t  *attrs, 
3240                 short   *pair_arg, 
3241                 void    *opts)
3242                 { return(*(int *)0); }
3243
3244 /* ./widechar/lib_erasewchar.c */
3245
3246 #undef erasewchar
3247 int     erasewchar(
3248                 wchar_t *wch)
3249                 { return(*(int *)0); }
3250
3251 #undef killwchar
3252 int     killwchar(
3253                 wchar_t *wch)
3254                 { return(*(int *)0); }
3255
3256 /* ./widechar/lib_get_wch.c */
3257
3258 #undef wget_wch
3259 int     wget_wch(
3260                 WINDOW  *win, 
3261                 wint_t  *result)
3262                 { return(*(int *)0); }
3263
3264 /* ./widechar/lib_get_wstr.c */
3265
3266 #undef wgetn_wstr
3267 int     wgetn_wstr(
3268                 WINDOW  *win, 
3269                 wint_t  *str, 
3270                 int     maxlen)
3271                 { return(*(int *)0); }
3272
3273 /* ./widechar/lib_hline_set.c */
3274
3275 #undef whline_set
3276 int     whline_set(
3277                 WINDOW  *win, 
3278                 const cchar_t *ch, 
3279                 int     n)
3280                 { return(*(int *)0); }
3281
3282 /* ./widechar/lib_in_wch.c */
3283
3284 #undef win_wch
3285 int     win_wch(
3286                 WINDOW  *win, 
3287                 cchar_t *wcval)
3288                 { return(*(int *)0); }
3289
3290 /* ./widechar/lib_in_wchnstr.c */
3291
3292 #undef win_wchnstr
3293 int     win_wchnstr(
3294                 WINDOW  *win, 
3295                 cchar_t *wchstr, 
3296                 int     n)
3297                 { return(*(int *)0); }
3298
3299 /* ./widechar/lib_ins_wch.c */
3300
3301 #undef _nc_insert_wch
3302 int     _nc_insert_wch(
3303                 WINDOW  *win, 
3304                 const cchar_t *wch)
3305                 { return(*(int *)0); }
3306
3307 #undef wins_wch
3308 int     wins_wch(
3309                 WINDOW  *win, 
3310                 const cchar_t *wch)
3311                 { return(*(int *)0); }
3312
3313 #undef wins_nwstr
3314 int     wins_nwstr(
3315                 WINDOW  *win, 
3316                 const wchar_t *wstr, 
3317                 int     n)
3318                 { return(*(int *)0); }
3319
3320 /* ./widechar/lib_inwstr.c */
3321
3322 #undef winnwstr
3323 int     winnwstr(
3324                 WINDOW  *win, 
3325                 wchar_t *wstr, 
3326                 int     n)
3327                 { return(*(int *)0); }
3328
3329 #undef winwstr
3330 int     winwstr(
3331                 WINDOW  *win, 
3332                 wchar_t *wstr)
3333                 { return(*(int *)0); }
3334
3335 /* ./widechar/lib_key_name.c */
3336
3337 #undef key_name
3338 const char *key_name(
3339                 wchar_t c)
3340                 { return(*(const char **)0); }
3341
3342 /* ./widechar/lib_pecho_wchar.c */
3343
3344 #undef pecho_wchar
3345 int     pecho_wchar(
3346                 WINDOW  *pad, 
3347                 const cchar_t *wch)
3348                 { return(*(int *)0); }
3349
3350 /* ./widechar/lib_slk_wset.c */
3351
3352 #undef slk_wset
3353 int     slk_wset(
3354                 int     i, 
3355                 const wchar_t *astr, 
3356                 int     format)
3357                 { return(*(int *)0); }
3358
3359 /* ./widechar/lib_unget_wch.c */
3360
3361 #undef _nc_wcrtomb
3362 size_t  _nc_wcrtomb(
3363                 char    *target, 
3364                 wchar_t source, 
3365                 mbstate_t *state)
3366                 { return(*(size_t *)0); }
3367
3368 #undef unget_wch_sp
3369 int     unget_wch_sp(
3370                 SCREEN  *sp, 
3371                 const wchar_t wch)
3372                 { return(*(int *)0); }
3373
3374 #undef unget_wch
3375 int     unget_wch(
3376                 const wchar_t wch)
3377                 { return(*(int *)0); }
3378
3379 /* ./widechar/lib_vid_attr.c */
3380
3381 #undef vid_puts_sp
3382 int     vid_puts_sp(
3383                 SCREEN  *sp, 
3384                 attr_t  newmode, 
3385                 short   pair_arg, 
3386                 void    *opts, 
3387                 NCURSES_OUTC_sp outc)
3388                 { return(*(int *)0); }
3389
3390 #undef vid_puts
3391 int     vid_puts(
3392                 attr_t  newmode, 
3393                 short   pair_arg, 
3394                 void    *opts, 
3395                 NCURSES_OUTC outc)
3396                 { return(*(int *)0); }
3397
3398 #undef vid_attr_sp
3399 int     vid_attr_sp(
3400                 SCREEN  *sp, 
3401                 attr_t  newmode, 
3402                 short   pair_arg, 
3403                 void    *opts)
3404                 { return(*(int *)0); }
3405
3406 #undef vid_attr
3407 int     vid_attr(
3408                 attr_t  newmode, 
3409                 short   pair_arg, 
3410                 void    *opts)
3411                 { return(*(int *)0); }
3412
3413 #undef term_attrs_sp
3414 attr_t  term_attrs_sp(
3415                 SCREEN  *sp)
3416                 { return(*(attr_t *)0); }
3417
3418 #undef term_attrs
3419 attr_t  term_attrs(void)
3420                 { return(*(attr_t *)0); }
3421
3422 /* ./widechar/lib_vline_set.c */
3423
3424 #undef wvline_set
3425 int     wvline_set(
3426                 WINDOW  *win, 
3427                 const cchar_t *ch, 
3428                 int     n)
3429                 { return(*(int *)0); }
3430
3431 /* ./widechar/lib_wacs.c */
3432
3433 #undef _nc_wacs
3434 cchar_t *_nc_wacs;
3435
3436 #undef _nc_init_wacs
3437 void    _nc_init_wacs(void)
3438                 { /* void */ }
3439
3440 /* ./widechar/lib_wunctrl.c */
3441
3442 #undef wunctrl_sp
3443 wchar_t *wunctrl_sp(
3444                 SCREEN  *sp, 
3445                 cchar_t *wc)
3446                 { return(*(wchar_t **)0); }
3447
3448 #undef wunctrl
3449 wchar_t *wunctrl(
3450                 cchar_t *wc)
3451                 { return(*(wchar_t **)0); }
3452
3453 /* ./expanded.c */
3454
3455 #undef _nc_toggle_attr_on
3456 void    _nc_toggle_attr_on(
3457                 attr_t  *S, 
3458                 attr_t  at)
3459                 { /* void */ }
3460
3461 #undef _nc_toggle_attr_off
3462 void    _nc_toggle_attr_off(
3463                 attr_t  *S, 
3464                 attr_t  at)
3465                 { /* void */ }
3466
3467 #undef _nc_DelCharCost_sp
3468 int     _nc_DelCharCost_sp(
3469                 SCREEN  *sp, 
3470                 int     count)
3471                 { return(*(int *)0); }
3472
3473 #undef _nc_InsCharCost_sp
3474 int     _nc_InsCharCost_sp(
3475                 SCREEN  *sp, 
3476                 int     count)
3477                 { return(*(int *)0); }
3478
3479 #undef _nc_UpdateAttrs_sp
3480 void    _nc_UpdateAttrs_sp(
3481                 SCREEN  *sp, 
3482                 const cchar_t *c)
3483                 { /* void */ }
3484
3485 #undef _nc_DelCharCost
3486 int     _nc_DelCharCost(
3487                 int     count)
3488                 { return(*(int *)0); }
3489
3490 #undef _nc_InsCharCost
3491 int     _nc_InsCharCost(
3492                 int     count)
3493                 { return(*(int *)0); }
3494
3495 #undef _nc_UpdateAttrs
3496 void    _nc_UpdateAttrs(
3497                 const cchar_t *c)
3498                 { /* void */ }
3499
3500 /* ./base/legacy_coding.c */
3501
3502 #undef use_legacy_coding_sp
3503 int     use_legacy_coding_sp(
3504                 SCREEN  *sp, 
3505                 int     level)
3506                 { return(*(int *)0); }
3507
3508 #undef use_legacy_coding
3509 int     use_legacy_coding(
3510                 int     level)
3511                 { return(*(int *)0); }
3512
3513 /* ./base/lib_dft_fgbg.c */
3514
3515 #undef use_default_colors_sp
3516 int     use_default_colors_sp(
3517                 SCREEN  *sp)
3518                 { return(*(int *)0); }
3519
3520 #undef use_default_colors
3521 int     use_default_colors(void)
3522                 { return(*(int *)0); }
3523
3524 #undef assume_default_colors_sp
3525 int     assume_default_colors_sp(
3526                 SCREEN  *sp, 
3527                 int     fg, 
3528                 int     bg)
3529                 { return(*(int *)0); }
3530
3531 #undef assume_default_colors
3532 int     assume_default_colors(
3533                 int     fg, 
3534                 int     bg)
3535                 { return(*(int *)0); }
3536
3537 /* ./tinfo/lib_print.c */
3538
3539 #undef mcprint_sp
3540 int     mcprint_sp(
3541                 SCREEN  *sp, 
3542                 char    *data, 
3543                 int     len)
3544                 { return(*(int *)0); }
3545
3546 #undef mcprint
3547 int     mcprint(
3548                 char    *data, 
3549                 int     len)
3550                 { return(*(int *)0); }
3551
3552 /* ./base/new_pair.c */
3553
3554 #undef _nc_free_ordered_pairs
3555 void    _nc_free_ordered_pairs(
3556                 SCREEN  *sp)
3557                 { /* void */ }
3558
3559 #undef _nc_reset_color_pair
3560 void    _nc_reset_color_pair(
3561                 SCREEN  *sp, 
3562                 int     pair, 
3563                 colorpair_t *next)
3564                 { /* void */ }
3565
3566 #undef _nc_set_color_pair
3567 void    _nc_set_color_pair(
3568                 SCREEN  *sp, 
3569                 int     pair, 
3570                 int     mode)
3571                 { /* void */ }
3572
3573 #undef _nc_copy_pairs
3574 void    _nc_copy_pairs(
3575                 SCREEN  *sp, 
3576                 colorpair_t *target, 
3577                 colorpair_t *source, 
3578                 int     length)
3579                 { /* void */ }
3580
3581 #undef alloc_pair_sp
3582 int     alloc_pair_sp(
3583                 SCREEN  *sp, 
3584                 int     fg, 
3585                 int     bg)
3586                 { return(*(int *)0); }
3587
3588 #undef find_pair_sp
3589 int     find_pair_sp(
3590                 SCREEN  *sp, 
3591                 int     fg, 
3592                 int     bg)
3593                 { return(*(int *)0); }
3594
3595 #undef free_pair_sp
3596 int     free_pair_sp(
3597                 SCREEN  *sp, 
3598                 int     pair)
3599                 { return(*(int *)0); }
3600
3601 #undef alloc_pair
3602 int     alloc_pair(
3603                 int     f, 
3604                 int     b)
3605                 { return(*(int *)0); }
3606
3607 #undef find_pair
3608 int     find_pair(
3609                 int     f, 
3610                 int     b)
3611                 { return(*(int *)0); }
3612
3613 #undef free_pair
3614 int     free_pair(
3615                 int     pair)
3616                 { return(*(int *)0); }
3617
3618 /* ./base/resizeterm.c */
3619
3620 #undef is_term_resized_sp
3621 NCURSES_BOOL is_term_resized_sp(
3622                 SCREEN  *sp, 
3623                 int     ToLines, 
3624                 int     ToCols)
3625                 { return(*(NCURSES_BOOL *)0); }
3626
3627 #undef is_term_resized
3628 NCURSES_BOOL is_term_resized(
3629                 int     ToLines, 
3630                 int     ToCols)
3631                 { return(*(NCURSES_BOOL *)0); }
3632
3633 #undef resize_term_sp
3634 int     resize_term_sp(
3635                 SCREEN  *sp, 
3636                 int     ToLines, 
3637                 int     ToCols)
3638                 { return(*(int *)0); }
3639
3640 #undef resize_term
3641 int     resize_term(
3642                 int     ToLines, 
3643                 int     ToCols)
3644                 { return(*(int *)0); }
3645
3646 #undef resizeterm_sp
3647 int     resizeterm_sp(
3648                 SCREEN  *sp, 
3649                 int     ToLines, 
3650                 int     ToCols)
3651                 { return(*(int *)0); }
3652
3653 #undef resizeterm
3654 int     resizeterm(
3655                 int     ToLines, 
3656                 int     ToCols)
3657                 { return(*(int *)0); }
3658
3659 /* ./trace/trace_xnames.c */
3660
3661 #undef _nc_trace_xnames
3662 void    _nc_trace_xnames(
3663                 TERMTYPE *tp)
3664                 { /* void */ }
3665
3666 /* ./tinfo/use_screen.c */
3667
3668 #undef use_screen
3669 int     use_screen(
3670             &