ncurses 6.2 - patch 20200926
[ncurses.git] / ncurses / llib-lncursestw
1 /****************************************************************************
2  * Copyright 2018-2019,2020 Thomas E. Dickey                                *
3  * Copyright 2009-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       2009-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 _nc_COLOR_PAIRS
259 int     _nc_COLOR_PAIRS(void)
260                 { return(*(int *)0); }
261
262 #undef _nc_COLORS
263 int     _nc_COLORS(void)
264                 { return(*(int *)0); }
265
266 #undef _nc_reset_colors_sp
267 NCURSES_BOOL _nc_reset_colors_sp(
268                 SCREEN  *sp)
269                 { return(*(NCURSES_BOOL *)0); }
270
271 #undef _nc_reset_colors
272 NCURSES_BOOL _nc_reset_colors(void)
273                 { return(*(NCURSES_BOOL *)0); }
274
275 #undef start_color_sp
276 int     start_color_sp(
277                 SCREEN  *sp)
278                 { return(*(int *)0); }
279
280 #undef start_color
281 int     start_color(void)
282                 { return(*(int *)0); }
283
284 #undef _nc_change_pair
285 void    _nc_change_pair(
286                 SCREEN  *sp, 
287                 int     pair)
288                 { /* void */ }
289
290 #undef _nc_reserve_pairs
291 void    _nc_reserve_pairs(
292                 SCREEN  *sp, 
293                 int     want)
294                 { /* void */ }
295
296 #undef _nc_init_pair
297 int     _nc_init_pair(
298                 SCREEN  *sp, 
299                 int     pair, 
300                 int     f, 
301                 int     b)
302                 { return(*(int *)0); }
303
304 #undef init_pair_sp
305 int     init_pair_sp(
306                 SCREEN  *sp, 
307                 short   pair, 
308                 short   f, 
309                 short   b)
310                 { return(*(int *)0); }
311
312 #undef init_pair
313 int     init_pair(
314                 short   pair, 
315                 short   f, 
316                 short   b)
317                 { return(*(int *)0); }
318
319 #undef _nc_init_color
320 int     _nc_init_color(
321                 SCREEN  *sp, 
322                 int     color, 
323                 int     r, 
324                 int     g, 
325                 int     b)
326                 { return(*(int *)0); }
327
328 #undef init_color_sp
329 int     init_color_sp(
330                 SCREEN  *sp, 
331                 short   color, 
332                 short   r, 
333                 short   g, 
334                 short   b)
335                 { return(*(int *)0); }
336
337 #undef init_color
338 int     init_color(
339                 short   color, 
340                 short   r, 
341                 short   g, 
342                 short   b)
343                 { return(*(int *)0); }
344
345 #undef can_change_color_sp
346 NCURSES_BOOL can_change_color_sp(
347                 SCREEN  *sp)
348                 { return(*(NCURSES_BOOL *)0); }
349
350 #undef can_change_color
351 NCURSES_BOOL can_change_color(void)
352                 { return(*(NCURSES_BOOL *)0); }
353
354 #undef has_colors_sp
355 NCURSES_BOOL has_colors_sp(
356                 SCREEN  *sp)
357                 { return(*(NCURSES_BOOL *)0); }
358
359 #undef has_colors
360 NCURSES_BOOL has_colors(void)
361                 { return(*(NCURSES_BOOL *)0); }
362
363 #undef color_content_sp
364 int     color_content_sp(
365                 SCREEN  *sp, 
366                 short   color, 
367                 short   *r, 
368                 short   *g, 
369                 short   *b)
370                 { return(*(int *)0); }
371
372 #undef color_content
373 int     color_content(
374                 short   color, 
375                 short   *r, 
376                 short   *g, 
377                 short   *b)
378                 { return(*(int *)0); }
379
380 #undef _nc_pair_content
381 int     _nc_pair_content(
382                 SCREEN  *sp, 
383                 int     pair, 
384                 int     *f, 
385                 int     *b)
386                 { return(*(int *)0); }
387
388 #undef pair_content_sp
389 int     pair_content_sp(
390                 SCREEN  *sp, 
391                 short   pair, 
392                 short   *f, 
393                 short   *b)
394                 { return(*(int *)0); }
395
396 #undef pair_content
397 int     pair_content(
398                 short   pair, 
399                 short   *f, 
400                 short   *b)
401                 { return(*(int *)0); }
402
403 #undef _nc_do_color_sp
404 void    _nc_do_color_sp(
405                 SCREEN  *sp, 
406                 int     old_pair, 
407                 int     pair, 
408                 int     reverse, 
409                 NCURSES_OUTC_sp outc)
410                 { /* void */ }
411
412 #undef _nc_do_color
413 void    _nc_do_color(
414                 int     old_pair, 
415                 int     pair, 
416                 int     reverse, 
417                 NCURSES_OUTC outc)
418                 { /* void */ }
419
420 #undef init_extended_pair_sp
421 int     init_extended_pair_sp(
422                 SCREEN  *sp, 
423                 int     pair, 
424                 int     f, 
425                 int     b)
426                 { return(*(int *)0); }
427
428 #undef init_extended_color_sp
429 int     init_extended_color_sp(
430                 SCREEN  *sp, 
431                 int     color, 
432                 int     r, 
433                 int     g, 
434                 int     b)
435                 { return(*(int *)0); }
436
437 #undef extended_color_content_sp
438 int     extended_color_content_sp(
439                 SCREEN  *sp, 
440                 int     color, 
441                 int     *r, 
442                 int     *g, 
443                 int     *b)
444                 { return(*(int *)0); }
445
446 #undef extended_pair_content_sp
447 int     extended_pair_content_sp(
448                 SCREEN  *sp, 
449                 int     pair, 
450                 int     *f, 
451                 int     *b)
452                 { return(*(int *)0); }
453
454 #undef reset_color_pairs_sp
455 void    reset_color_pairs_sp(
456                 SCREEN  *sp)
457                 { /* void */ }
458
459 #undef init_extended_pair
460 int     init_extended_pair(
461                 int     pair, 
462                 int     f, 
463                 int     b)
464                 { return(*(int *)0); }
465
466 #undef init_extended_color
467 int     init_extended_color(
468                 int     color, 
469                 int     r, 
470                 int     g, 
471                 int     b)
472                 { return(*(int *)0); }
473
474 #undef extended_color_content
475 int     extended_color_content(
476                 int     color, 
477                 int     *r, 
478                 int     *g, 
479                 int     *b)
480                 { return(*(int *)0); }
481
482 #undef extended_pair_content
483 int     extended_pair_content(
484                 int     pair, 
485                 int     *f, 
486                 int     *b)
487                 { return(*(int *)0); }
488
489 #undef reset_color_pairs
490 void    reset_color_pairs(void)
491                 { /* void */ }
492
493 /* ./base/lib_colorset.c */
494
495 #undef wcolor_set
496 int     wcolor_set(
497                 WINDOW  *win, 
498                 short   pair_arg, 
499                 void    *opts)
500                 { return(*(int *)0); }
501
502 /* ./base/lib_delch.c */
503
504 #undef wdelch
505 int     wdelch(
506                 WINDOW  *win)
507                 { return(*(int *)0); }
508
509 /* ./base/lib_delwin.c */
510
511 #undef delwin
512 int     delwin(
513                 WINDOW  *win)
514                 { return(*(int *)0); }
515
516 /* ./base/lib_echo.c */
517
518 #undef echo_sp
519 int     echo_sp(
520                 SCREEN  *sp)
521                 { return(*(int *)0); }
522
523 #undef echo
524 int     echo(void)
525                 { return(*(int *)0); }
526
527 #undef noecho_sp
528 int     noecho_sp(
529                 SCREEN  *sp)
530                 { return(*(int *)0); }
531
532 #undef noecho
533 int     noecho(void)
534                 { return(*(int *)0); }
535
536 /* ./base/lib_endwin.c */
537
538 #undef endwin_sp
539 int     endwin_sp(
540                 SCREEN  *sp)
541                 { return(*(int *)0); }
542
543 #undef endwin
544 int     endwin(void)
545                 { return(*(int *)0); }
546
547 /* ./base/lib_erase.c */
548
549 #undef werase
550 int     werase(
551                 WINDOW  *win)
552                 { return(*(int *)0); }
553
554 /* ./base/lib_flash.c */
555
556 #undef flash_sp
557 int     flash_sp(
558                 SCREEN  *sp)
559                 { return(*(int *)0); }
560
561 #undef flash
562 int     flash(void)
563                 { return(*(int *)0); }
564
565 /* ./lib_gen.c */
566
567 #undef addch
568 int     addch(
569                 const chtype z)
570                 { return(*(int *)0); }
571
572 #undef addchnstr
573 int     addchnstr(
574                 const chtype *a1, 
575                 int     z)
576                 { return(*(int *)0); }
577
578 #undef addchstr
579 int     addchstr(
580                 const chtype *z)
581                 { return(*(int *)0); }
582
583 #undef addnstr
584 int     addnstr(
585                 const char *a1, 
586                 int     z)
587                 { return(*(int *)0); }
588
589 #undef addstr
590 int     addstr(
591                 const char *z)
592                 { return(*(int *)0); }
593
594 #undef attroff
595 int     attroff(
596                 int     z)
597                 { return(*(int *)0); }
598
599 #undef attron
600 int     attron(
601                 int     z)
602                 { return(*(int *)0); }
603
604 #undef attrset
605 int     attrset(
606                 int     z)
607                 { return(*(int *)0); }
608
609 #undef attr_get
610 int     attr_get(
611                 attr_t  *a1, 
612                 short   *a2, 
613                 void    *z)
614                 { return(*(int *)0); }
615
616 #undef attr_off
617 int     attr_off(
618                 attr_t  a1, 
619                 void    *z)
620                 { return(*(int *)0); }
621
622 #undef attr_on
623 int     attr_on(
624                 attr_t  a1, 
625                 void    *z)
626                 { return(*(int *)0); }
627
628 #undef attr_set
629 int     attr_set(
630                 attr_t  a1, 
631                 short   a2, 
632                 void    *z)
633                 { return(*(int *)0); }
634
635 #undef bkgd
636 int     bkgd(
637                 chtype  z)
638                 { return(*(int *)0); }
639
640 #undef bkgdset
641 void    bkgdset(
642                 chtype  z)
643                 { /* void */ }
644
645 #undef border
646 int     border(
647                 chtype  a1, 
648                 chtype  a2, 
649                 chtype  a3, 
650                 chtype  a4, 
651                 chtype  a5, 
652                 chtype  a6, 
653                 chtype  a7, 
654                 chtype  z)
655                 { return(*(int *)0); }
656
657 #undef box
658 int     box(
659                 WINDOW  *a1, 
660                 chtype  a2, 
661                 chtype  z)
662                 { return(*(int *)0); }
663
664 #undef chgat
665 int     chgat(
666                 int     a1, 
667                 attr_t  a2, 
668                 short   a3, 
669                 const void *z)
670                 { return(*(int *)0); }
671
672 #undef clear
673 int     clear(void)
674                 { return(*(int *)0); }
675
676 #undef clrtobot
677 int     clrtobot(void)
678                 { return(*(int *)0); }
679
680 #undef clrtoeol
681 int     clrtoeol(void)
682                 { return(*(int *)0); }
683
684 #undef color_set
685 int     color_set(
686                 short   a1, 
687                 void    *z)
688                 { return(*(int *)0); }
689
690 #undef COLOR_PAIR
691 int     COLOR_PAIR(
692                 int     z)
693                 { return(*(int *)0); }
694
695 #undef delch
696 int     delch(void)
697                 { return(*(int *)0); }
698
699 #undef deleteln
700 int     deleteln(void)
701                 { return(*(int *)0); }
702
703 #undef echochar
704 int     echochar(
705                 const chtype z)
706                 { return(*(int *)0); }
707
708 #undef erase
709 int     erase(void)
710                 { return(*(int *)0); }
711
712 #undef getbkgd
713 chtype  getbkgd(
714                 WINDOW  *z)
715                 { return(*(chtype *)0); }
716
717 #undef getch
718 int     getch(void)
719                 { return(*(int *)0); }
720
721 #undef getnstr
722 int     getnstr(
723                 char    *a1, 
724                 int     z)
725                 { return(*(int *)0); }
726
727 #undef getstr
728 int     getstr(
729                 char    *z)
730                 { return(*(int *)0); }
731
732 #undef hline
733 int     hline(
734                 chtype  a1, 
735                 int     z)
736                 { return(*(int *)0); }
737
738 #undef inch
739 chtype  inch(void)
740                 { return(*(chtype *)0); }
741
742 #undef inchnstr
743 int     inchnstr(
744                 chtype  *a1, 
745                 int     z)
746                 { return(*(int *)0); }
747
748 #undef inchstr
749 int     inchstr(
750                 chtype  *z)
751                 { return(*(int *)0); }
752
753 #undef innstr
754 int     innstr(
755                 char    *a1, 
756                 int     z)
757                 { return(*(int *)0); }
758
759 #undef insch
760 int     insch(
761                 chtype  z)
762                 { return(*(int *)0); }
763
764 #undef insdelln
765 int     insdelln(
766                 int     z)
767                 { return(*(int *)0); }
768
769 #undef insertln
770 int     insertln(void)
771                 { return(*(int *)0); }
772
773 #undef insnstr
774 int     insnstr(
775                 const char *a1, 
776                 int     z)
777                 { return(*(int *)0); }
778
779 #undef insstr
780 int     insstr(
781                 const char *z)
782                 { return(*(int *)0); }
783
784 #undef instr
785 int     instr(
786                 char    *z)
787                 { return(*(int *)0); }
788
789 #undef move
790 int     move(
791                 int     a1, 
792                 int     z)
793                 { return(*(int *)0); }
794
795 #undef mvaddch
796 int     mvaddch(
797                 int     a1, 
798                 int     a2, 
799                 const chtype z)
800                 { return(*(int *)0); }
801
802 #undef mvaddchnstr
803 int     mvaddchnstr(
804                 int     a1, 
805                 int     a2, 
806                 const chtype *a3, 
807                 int     z)
808                 { return(*(int *)0); }
809
810 #undef mvaddchstr
811 int     mvaddchstr(
812                 int     a1, 
813                 int     a2, 
814                 const chtype *z)
815                 { return(*(int *)0); }
816
817 #undef mvaddnstr
818 int     mvaddnstr(
819                 int     a1, 
820                 int     a2, 
821                 const char *a3, 
822                 int     z)
823                 { return(*(int *)0); }
824
825 #undef mvaddstr
826 int     mvaddstr(
827                 int     a1, 
828                 int     a2, 
829                 const char *z)
830                 { return(*(int *)0); }
831
832 #undef mvchgat
833 int     mvchgat(
834                 int     a1, 
835                 int     a2, 
836                 int     a3, 
837                 attr_t  a4, 
838                 short   a5, 
839                 const void *z)
840                 { return(*(int *)0); }
841
842 #undef mvdelch
843 int     mvdelch(
844                 int     a1, 
845                 int     z)
846                 { return(*(int *)0); }
847
848 #undef mvgetch
849 int     mvgetch(
850                 int     a1, 
851                 int     z)
852                 { return(*(int *)0); }
853
854 #undef mvgetnstr
855 int     mvgetnstr(
856                 int     a1, 
857                 int     a2, 
858                 char    *a3, 
859                 int     z)
860                 { return(*(int *)0); }
861
862 #undef mvgetstr
863 int     mvgetstr(
864                 int     a1, 
865                 int     a2, 
866                 char    *z)
867                 { return(*(int *)0); }
868
869 #undef mvhline
870 int     mvhline(
871                 int     a1, 
872                 int     a2, 
873                 chtype  a3, 
874                 int     z)
875                 { return(*(int *)0); }
876
877 #undef mvinch
878 chtype  mvinch(
879                 int     a1, 
880                 int     z)
881                 { return(*(chtype *)0); }
882
883 #undef mvinchnstr
884 int     mvinchnstr(
885                 int     a1, 
886                 int     a2, 
887                 chtype  *a3, 
888                 int     z)
889                 { return(*(int *)0); }
890
891 #undef mvinchstr
892 int     mvinchstr(
893                 int     a1, 
894                 int     a2, 
895                 chtype  *z)
896                 { return(*(int *)0); }
897
898 #undef mvinnstr
899 int     mvinnstr(
900                 int     a1, 
901                 int     a2, 
902                 char    *a3, 
903                 int     z)
904                 { return(*(int *)0); }
905
906 #undef mvinsch
907 int     mvinsch(
908                 int     a1, 
909                 int     a2, 
910                 chtype  z)
911                 { return(*(int *)0); }
912
913 #undef mvinsnstr
914 int     mvinsnstr(
915                 int     a1, 
916                 int     a2, 
917                 const char *a3, 
918                 int     z)
919                 { return(*(int *)0); }
920
921 #undef mvinsstr
922 int     mvinsstr(
923                 int     a1, 
924                 int     a2, 
925                 const char *z)
926                 { return(*(int *)0); }
927
928 #undef mvinstr
929 int     mvinstr(
930                 int     a1, 
931                 int     a2, 
932                 char    *z)
933                 { return(*(int *)0); }
934
935 #undef mvvline
936 int     mvvline(
937                 int     a1, 
938                 int     a2, 
939                 chtype  a3, 
940                 int     z)
941                 { return(*(int *)0); }
942
943 #undef mvwaddch
944 int     mvwaddch(
945                 WINDOW  *a1, 
946                 int     a2, 
947                 int     a3, 
948                 const chtype z)
949                 { return(*(int *)0); }
950
951 #undef mvwaddchnstr
952 int     mvwaddchnstr(
953                 WINDOW  *a1, 
954                 int     a2, 
955                 int     a3, 
956                 const chtype *a4, 
957                 int     z)
958                 { return(*(int *)0); }
959
960 #undef mvwaddchstr
961 int     mvwaddchstr(
962                 WINDOW  *a1, 
963                 int     a2, 
964                 int     a3, 
965                 const chtype *z)
966                 { return(*(int *)0); }
967
968 #undef mvwaddnstr
969 int     mvwaddnstr(
970                 WINDOW  *a1, 
971                 int     a2, 
972                 int     a3, 
973                 const char *a4, 
974                 int     z)
975                 { return(*(int *)0); }
976
977 #undef mvwaddstr
978 int     mvwaddstr(
979                 WINDOW  *a1, 
980                 int     a2, 
981                 int     a3, 
982                 const char *z)
983                 { return(*(int *)0); }
984
985 #undef mvwchgat
986 int     mvwchgat(
987                 WINDOW  *a1, 
988                 int     a2, 
989                 int     a3, 
990                 int     a4, 
991                 attr_t  a5, 
992                 short   a6, 
993                 const void *z)
994                 { return(*(int *)0); }
995
996 #undef mvwdelch
997 int     mvwdelch(
998                 WINDOW  *a1, 
999                 int     a2, 
1000                 int     z)
1001                 { return(*(int *)0); }
1002
1003 #undef mvwgetch
1004 int     mvwgetch(
1005                 WINDOW  *a1, 
1006                 int     a2, 
1007                 int     z)
1008                 { return(*(int *)0); }
1009
1010 #undef mvwgetnstr
1011 int     mvwgetnstr(
1012                 WINDOW  *a1, 
1013                 int     a2, 
1014                 int     a3, 
1015                 char    *a4, 
1016                 int     z)
1017                 { return(*(int *)0); }
1018
1019 #undef mvwgetstr
1020 int     mvwgetstr(
1021                 WINDOW  *a1, 
1022                 int     a2, 
1023                 int     a3, 
1024                 char    *z)
1025                 { return(*(int *)0); }
1026
1027 #undef mvwhline
1028 int     mvwhline(
1029                 WINDOW  *a1, 
1030                 int     a2, 
1031                 int     a3, 
1032                 chtype  a4, 
1033                 int     z)
1034                 { return(*(int *)0); }
1035
1036 #undef mvwinch
1037 chtype  mvwinch(
1038                 WINDOW  *a1, 
1039                 int     a2, 
1040                 int     z)
1041                 { return(*(chtype *)0); }
1042
1043 #undef mvwinchnstr
1044 int     mvwinchnstr(
1045                 WINDOW  *a1, 
1046                 int     a2, 
1047                 int     a3, 
1048                 chtype  *a4, 
1049                 int     z)
1050                 { return(*(int *)0); }
1051
1052 #undef mvwinchstr
1053 int     mvwinchstr(
1054                 WINDOW  *a1, 
1055                 int     a2, 
1056                 int     a3, 
1057                 chtype  *z)
1058                 { return(*(int *)0); }
1059
1060 #undef mvwinnstr
1061 int     mvwinnstr(
1062                 WINDOW  *a1, 
1063                 int     a2, 
1064                 int     a3, 
1065                 char    *a4, 
1066                 int     z)
1067                 { return(*(int *)0); }
1068
1069 #undef mvwinsch
1070 int     mvwinsch(
1071                 WINDOW  *a1, 
1072                 int     a2, 
1073                 int     a3, 
1074                 chtype  z)
1075                 { return(*(int *)0); }
1076
1077 #undef mvwinsnstr
1078 int     mvwinsnstr(
1079                 WINDOW  *a1, 
1080                 int     a2, 
1081                 int     a3, 
1082                 const char *a4, 
1083                 int     z)
1084                 { return(*(int *)0); }
1085
1086 #undef mvwinsstr
1087 int     mvwinsstr(
1088                 WINDOW  *a1, 
1089                 int     a2, 
1090                 int     a3, 
1091                 const char *z)
1092                 { return(*(int *)0); }
1093
1094 #undef mvwinstr
1095 int     mvwinstr(
1096                 WINDOW  *a1, 
1097                 int     a2, 
1098                 int     a3, 
1099                 char    *z)
1100                 { return(*(int *)0); }
1101
1102 #undef mvwvline
1103 int     mvwvline(
1104                 WINDOW  *a1, 
1105                 int     a2, 
1106                 int     a3, 
1107                 chtype  a4, 
1108                 int     z)
1109                 { return(*(int *)0); }
1110
1111 #undef PAIR_NUMBER
1112 int     PAIR_NUMBER(
1113                 int     z)
1114                 { return(*(int *)0); }
1115
1116 #undef redrawwin
1117 int     redrawwin(
1118                 WINDOW  *z)
1119                 { return(*(int *)0); }
1120
1121 #undef refresh
1122 int     refresh(void)
1123                 { return(*(int *)0); }
1124
1125 #undef scrl
1126 int     scrl(
1127                 int     z)
1128                 { return(*(int *)0); }
1129
1130 #undef scroll
1131 int     scroll(
1132                 WINDOW  *z)
1133                 { return(*(int *)0); }
1134
1135 #undef setscrreg
1136 int     setscrreg(
1137                 int     a1, 
1138                 int     z)
1139                 { return(*(int *)0); }
1140
1141 #undef slk_attr_off
1142 int     slk_attr_off(
1143                 const attr_t a1, 
1144                 void    *z)
1145                 { return(*(int *)0); }
1146
1147 #undef slk_attr_on
1148 int     slk_attr_on(
1149                 attr_t  a1, 
1150                 void    *z)
1151                 { return(*(int *)0); }
1152
1153 #undef standout
1154 int     standout(void)
1155                 { return(*(int *)0); }
1156
1157 #undef standend
1158 int     standend(void)
1159                 { return(*(int *)0); }
1160
1161 #undef timeout
1162 void    timeout(
1163                 int     z)
1164                 { /* void */ }
1165
1166 #undef touchline
1167 int     touchline(
1168                 WINDOW  *a1, 
1169                 int     a2, 
1170                 int     z)
1171                 { return(*(int *)0); }
1172
1173 #undef touchwin
1174 int     touchwin(
1175                 WINDOW  *z)
1176                 { return(*(int *)0); }
1177
1178 #undef untouchwin
1179 int     untouchwin(
1180                 WINDOW  *z)
1181                 { return(*(int *)0); }
1182
1183 #undef vline
1184 int     vline(
1185                 chtype  a1, 
1186                 int     z)
1187                 { return(*(int *)0); }
1188
1189 #undef waddchstr
1190 int     waddchstr(
1191                 WINDOW  *a1, 
1192                 const chtype *z)
1193                 { return(*(int *)0); }
1194
1195 #undef waddstr
1196 int     waddstr(
1197                 WINDOW  *a1, 
1198                 const char *z)
1199                 { return(*(int *)0); }
1200
1201 #undef wattron
1202 int     wattron(
1203                 WINDOW  *a1, 
1204                 int     z)
1205                 { return(*(int *)0); }
1206
1207 #undef wattroff
1208 int     wattroff(
1209                 WINDOW  *a1, 
1210                 int     z)
1211                 { return(*(int *)0); }
1212
1213 #undef wattrset
1214 int     wattrset(
1215                 WINDOW  *a1, 
1216                 int     z)
1217                 { return(*(int *)0); }
1218
1219 #undef wattr_get
1220 int     wattr_get(
1221                 WINDOW  *a1, 
1222                 attr_t  *a2, 
1223                 short   *a3, 
1224                 void    *z)
1225                 { return(*(int *)0); }
1226
1227 #undef wattr_set
1228 int     wattr_set(
1229                 WINDOW  *a1, 
1230                 attr_t  a2, 
1231                 short   a3, 
1232                 void    *z)
1233                 { return(*(int *)0); }
1234
1235 #undef wdeleteln
1236 int     wdeleteln(
1237                 WINDOW  *z)
1238                 { return(*(int *)0); }
1239
1240 #undef wgetstr
1241 int     wgetstr(
1242                 WINDOW  *a1, 
1243                 char    *z)
1244                 { return(*(int *)0); }
1245
1246 #undef winchstr
1247 int     winchstr(
1248                 WINDOW  *a1, 
1249                 chtype  *z)
1250                 { return(*(int *)0); }
1251
1252 #undef winsertln
1253 int     winsertln(
1254                 WINDOW  *z)
1255                 { return(*(int *)0); }
1256
1257 #undef winsstr
1258 int     winsstr(
1259                 WINDOW  *a1, 
1260                 const char *z)
1261                 { return(*(int *)0); }
1262
1263 #undef winstr
1264 int     winstr(
1265                 WINDOW  *a1, 
1266                 char    *z)
1267                 { return(*(int *)0); }
1268
1269 #undef wstandout
1270 int     wstandout(
1271                 WINDOW  *z)
1272                 { return(*(int *)0); }
1273
1274 #undef wstandend
1275 int     wstandend(
1276                 WINDOW  *z)
1277                 { return(*(int *)0); }
1278
1279 #undef getattrs
1280 int     getattrs(
1281                 const WINDOW *z)
1282                 { return(*(int *)0); }
1283
1284 #undef getcurx
1285 int     getcurx(
1286                 const WINDOW *z)
1287                 { return(*(int *)0); }
1288
1289 #undef getcury
1290 int     getcury(
1291                 const WINDOW *z)
1292                 { return(*(int *)0); }
1293
1294 #undef getbegx
1295 int     getbegx(
1296                 const WINDOW *z)
1297                 { return(*(int *)0); }
1298
1299 #undef getbegy
1300 int     getbegy(
1301                 const WINDOW *z)
1302                 { return(*(int *)0); }
1303
1304 #undef getmaxx
1305 int     getmaxx(
1306                 const WINDOW *z)
1307                 { return(*(int *)0); }
1308
1309 #undef getmaxy
1310 int     getmaxy(
1311                 const WINDOW *z)
1312                 { return(*(int *)0); }
1313
1314 #undef getparx
1315 int     getparx(
1316                 const WINDOW *z)
1317                 { return(*(int *)0); }
1318
1319 #undef getpary
1320 int     getpary(
1321                 const WINDOW *z)
1322                 { return(*(int *)0); }
1323
1324 #undef wgetparent
1325 WINDOW  *wgetparent(
1326                 const WINDOW *z)
1327                 { return(*(WINDOW **)0); }
1328
1329 #undef is_cleared
1330 NCURSES_BOOL is_cleared(
1331                 const WINDOW *z)
1332                 { return(*(NCURSES_BOOL *)0); }
1333
1334 #undef is_idcok
1335 NCURSES_BOOL is_idcok(
1336                 const WINDOW *z)
1337                 { return(*(NCURSES_BOOL *)0); }
1338
1339 #undef is_idlok
1340 NCURSES_BOOL is_idlok(
1341                 const WINDOW *z)
1342                 { return(*(NCURSES_BOOL *)0); }
1343
1344 #undef is_immedok
1345 NCURSES_BOOL is_immedok(
1346                 const WINDOW *z)
1347                 { return(*(NCURSES_BOOL *)0); }
1348
1349 #undef is_keypad
1350 NCURSES_BOOL is_keypad(
1351                 const WINDOW *z)
1352                 { return(*(NCURSES_BOOL *)0); }
1353
1354 #undef is_leaveok
1355 NCURSES_BOOL is_leaveok(
1356                 const WINDOW *z)
1357                 { return(*(NCURSES_BOOL *)0); }
1358
1359 #undef is_nodelay
1360 NCURSES_BOOL is_nodelay(
1361                 const WINDOW *z)
1362                 { return(*(NCURSES_BOOL *)0); }
1363
1364 #undef is_notimeout
1365 NCURSES_BOOL is_notimeout(
1366                 const WINDOW *z)
1367                 { return(*(NCURSES_BOOL *)0); }
1368
1369 #undef is_pad
1370 NCURSES_BOOL is_pad(
1371                 const WINDOW *z)
1372                 { return(*(NCURSES_BOOL *)0); }
1373
1374 #undef is_scrollok
1375 NCURSES_BOOL is_scrollok(
1376                 const WINDOW *z)
1377                 { return(*(NCURSES_BOOL *)0); }
1378
1379 #undef is_subwin
1380 NCURSES_BOOL is_subwin(
1381                 const WINDOW *z)
1382                 { return(*(NCURSES_BOOL *)0); }
1383
1384 #undef is_syncok
1385 NCURSES_BOOL is_syncok(
1386                 const WINDOW *z)
1387                 { return(*(NCURSES_BOOL *)0); }
1388
1389 #undef wgetdelay
1390 int     wgetdelay(
1391                 const WINDOW *z)
1392                 { return(*(int *)0); }
1393
1394 #undef wgetscrreg
1395 int     wgetscrreg(
1396                 const WINDOW *a1, 
1397                 int     *a2, 
1398                 int     *z)
1399                 { return(*(int *)0); }
1400
1401 #undef add_wch
1402 int     add_wch(
1403                 const cchar_t *z)
1404                 { return(*(int *)0); }
1405
1406 #undef add_wchnstr
1407 int     add_wchnstr(
1408                 const cchar_t *a1, 
1409                 int     z)
1410                 { return(*(int *)0); }
1411
1412 #undef add_wchstr
1413 int     add_wchstr(
1414                 const cchar_t *z)
1415                 { return(*(int *)0); }
1416
1417 #undef addnwstr
1418 int     addnwstr(
1419                 const wchar_t *a1, 
1420                 int     z)
1421                 { return(*(int *)0); }
1422
1423 #undef addwstr
1424 int     addwstr(
1425                 const wchar_t *z)
1426                 { return(*(int *)0); }
1427
1428 #undef bkgrnd
1429 int     bkgrnd(
1430                 const cchar_t *z)
1431                 { return(*(int *)0); }
1432
1433 #undef bkgrndset
1434 void    bkgrndset(
1435                 const cchar_t *z)
1436                 { /* void */ }
1437
1438 #undef border_set
1439 int     border_set(
1440                 const cchar_t *a1, 
1441                 const cchar_t *a2, 
1442                 const cchar_t *a3, 
1443                 const cchar_t *a4, 
1444                 const cchar_t *a5, 
1445                 const cchar_t *a6, 
1446                 const cchar_t *a7, 
1447                 const cchar_t *z)
1448                 { return(*(int *)0); }
1449
1450 #undef box_set
1451 int     box_set(
1452                 WINDOW  *a1, 
1453                 const cchar_t *a2, 
1454                 const cchar_t *z)
1455                 { return(*(int *)0); }
1456
1457 #undef echo_wchar
1458 int     echo_wchar(
1459                 const cchar_t *z)
1460                 { return(*(int *)0); }
1461
1462 #undef get_wch
1463 int     get_wch(
1464                 wint_t  *z)
1465                 { return(*(int *)0); }
1466
1467 #undef get_wstr
1468 int     get_wstr(
1469                 wint_t  *z)
1470                 { return(*(int *)0); }
1471
1472 #undef getbkgrnd
1473 int     getbkgrnd(
1474                 cchar_t *z)
1475                 { return(*(int *)0); }
1476
1477 #undef getn_wstr
1478 int     getn_wstr(
1479                 wint_t  *a1, 
1480                 int     z)
1481                 { return(*(int *)0); }
1482
1483 #undef hline_set
1484 int     hline_set(
1485                 const cchar_t *a1, 
1486                 int     z)
1487                 { return(*(int *)0); }
1488
1489 #undef in_wch
1490 int     in_wch(
1491                 cchar_t *z)
1492                 { return(*(int *)0); }
1493
1494 #undef in_wchnstr
1495 int     in_wchnstr(
1496                 cchar_t *a1, 
1497                 int     z)
1498                 { return(*(int *)0); }
1499
1500 #undef in_wchstr
1501 int     in_wchstr(
1502                 cchar_t *z)
1503                 { return(*(int *)0); }
1504
1505 #undef innwstr
1506 int     innwstr(
1507                 wchar_t *a1, 
1508                 int     z)
1509                 { return(*(int *)0); }
1510
1511 #undef ins_nwstr
1512 int     ins_nwstr(
1513                 const wchar_t *a1, 
1514                 int     z)
1515                 { return(*(int *)0); }
1516
1517 #undef ins_wch
1518 int     ins_wch(
1519                 const cchar_t *z)
1520                 { return(*(int *)0); }
1521
1522 #undef ins_wstr
1523 int     ins_wstr(
1524                 const wchar_t *z)
1525                 { return(*(int *)0); }
1526
1527 #undef inwstr
1528 int     inwstr(
1529                 wchar_t *z)
1530                 { return(*(int *)0); }
1531
1532 #undef mvadd_wch
1533 int     mvadd_wch(
1534                 int     a1, 
1535                 int     a2, 
1536                 const cchar_t *z)
1537                 { return(*(int *)0); }
1538
1539 #undef mvadd_wchnstr
1540 int     mvadd_wchnstr(
1541                 int     a1, 
1542                 int     a2, 
1543                 const cchar_t *a3, 
1544                 int     z)
1545                 { return(*(int *)0); }
1546
1547 #undef mvadd_wchstr
1548 int     mvadd_wchstr(
1549                 int     a1, 
1550                 int     a2, 
1551                 const cchar_t *z)
1552                 { return(*(int *)0); }
1553
1554 #undef mvaddnwstr
1555 int     mvaddnwstr(
1556                 int     a1, 
1557                 int     a2, 
1558                 const wchar_t *a3, 
1559                 int     z)
1560                 { return(*(int *)0); }
1561
1562 #undef mvaddwstr
1563 int     mvaddwstr(
1564                 int     a1, 
1565                 int     a2, 
1566                 const wchar_t *z)
1567                 { return(*(int *)0); }
1568
1569 #undef mvget_wch
1570 int     mvget_wch(
1571                 int     a1, 
1572                 int     a2, 
1573                 wint_t  *z)
1574                 { return(*(int *)0); }
1575
1576 #undef mvget_wstr
1577 int     mvget_wstr(
1578                 int     a1, 
1579                 int     a2, 
1580                 wint_t  *z)
1581                 { return(*(int *)0); }
1582
1583 #undef mvgetn_wstr
1584 int     mvgetn_wstr(
1585                 int     a1, 
1586                 int     a2, 
1587                 wint_t  *a3, 
1588                 int     z)
1589                 { return(*(int *)0); }
1590
1591 #undef mvhline_set
1592 int     mvhline_set(
1593                 int     a1, 
1594                 int     a2, 
1595                 const cchar_t *a3, 
1596                 int     z)
1597                 { return(*(int *)0); }
1598
1599 #undef mvin_wch
1600 int     mvin_wch(
1601                 int     a1, 
1602                 int     a2, 
1603                 cchar_t *z)
1604                 { return(*(int *)0); }
1605
1606 #undef mvin_wchnstr
1607 int     mvin_wchnstr(
1608                 int     a1, 
1609                 int     a2, 
1610                 cchar_t *a3, 
1611                 int     z)
1612                 { return(*(int *)0); }
1613
1614 #undef mvin_wchstr
1615 int     mvin_wchstr(
1616                 int     a1, 
1617                 int     a2, 
1618                 cchar_t *z)
1619                 { return(*(int *)0); }
1620
1621 #undef mvinnwstr
1622 int     mvinnwstr(
1623                 int     a1, 
1624                 int     a2, 
1625                 wchar_t *a3, 
1626                 int     z)
1627                 { return(*(int *)0); }
1628
1629 #undef mvins_nwstr
1630 int     mvins_nwstr(
1631                 int     a1, 
1632                 int     a2, 
1633                 const wchar_t *a3, 
1634                 int     z)
1635                 { return(*(int *)0); }
1636
1637 #undef mvins_wch
1638 int     mvins_wch(
1639                 int     a1, 
1640                 int     a2, 
1641                 const cchar_t *z)
1642                 { return(*(int *)0); }
1643
1644 #undef mvins_wstr
1645 int     mvins_wstr(
1646                 int     a1, 
1647                 int     a2, 
1648                 const wchar_t *z)
1649                 { return(*(int *)0); }
1650
1651 #undef mvinwstr
1652 int     mvinwstr(
1653                 int     a1, 
1654                 int     a2, 
1655                 wchar_t *z)
1656                 { return(*(int *)0); }
1657
1658 #undef mvvline_set
1659 int     mvvline_set(
1660                 int     a1, 
1661                 int     a2, 
1662                 const cchar_t *a3, 
1663                 int     z)
1664                 { return(*(int *)0); }
1665
1666 #undef mvwadd_wch
1667 int     mvwadd_wch(
1668                 WINDOW  *a1, 
1669                 int     a2, 
1670                 int     a3, 
1671                 const cchar_t *z)
1672                 { return(*(int *)0); }
1673
1674 #undef mvwadd_wchnstr
1675 int     mvwadd_wchnstr(
1676                 WINDOW  *a1, 
1677                 int     a2, 
1678                 int     a3, 
1679                 const cchar_t *a4, 
1680                 int     z)
1681                 { return(*(int *)0); }
1682
1683 #undef mvwadd_wchstr
1684 int     mvwadd_wchstr(
1685                 WINDOW  *a1, 
1686                 int     a2, 
1687                 int     a3, 
1688                 const cchar_t *z)
1689                 { return(*(int *)0); }
1690
1691 #undef mvwaddnwstr
1692 int     mvwaddnwstr(
1693                 WINDOW  *a1, 
1694                 int     a2, 
1695                 int     a3, 
1696                 const wchar_t *a4, 
1697                 int     z)
1698                 { return(*(int *)0); }
1699
1700 #undef mvwaddwstr
1701 int     mvwaddwstr(
1702                 WINDOW  *a1, 
1703                 int     a2, 
1704                 int     a3, 
1705                 const wchar_t *z)
1706                 { return(*(int *)0); }
1707
1708 #undef mvwget_wch
1709 int     mvwget_wch(
1710                 WINDOW  *a1, 
1711                 int     a2, 
1712                 int     a3, 
1713                 wint_t  *z)
1714                 { return(*(int *)0); }
1715
1716 #undef mvwget_wstr
1717 int     mvwget_wstr(
1718                 WINDOW  *a1, 
1719                 int     a2, 
1720                 int     a3, 
1721                 wint_t  *z)
1722                 { return(*(int *)0); }
1723
1724 #undef mvwgetn_wstr
1725 int     mvwgetn_wstr(
1726                 WINDOW  *a1, 
1727                 int     a2, 
1728                 int     a3, 
1729                 wint_t  *a4, 
1730                 int     z)
1731                 { return(*(int *)0); }
1732
1733 #undef mvwhline_set
1734 int     mvwhline_set(
1735                 WINDOW  *a1, 
1736                 int     a2, 
1737                 int     a3, 
1738                 const cchar_t *a4, 
1739                 int     z)
1740                 { return(*(int *)0); }
1741
1742 #undef mvwin_wch
1743 int     mvwin_wch(
1744                 WINDOW  *a1, 
1745                 int     a2, 
1746                 int     a3, 
1747                 cchar_t *z)
1748                 { return(*(int *)0); }
1749
1750 #undef mvwin_wchnstr
1751 int     mvwin_wchnstr(
1752                 WINDOW  *a1, 
1753                 int     a2, 
1754                 int     a3, 
1755                 cchar_t *a4, 
1756                 int     z)
1757                 { return(*(int *)0); }
1758
1759 #undef mvwin_wchstr
1760 int     mvwin_wchstr(
1761                 WINDOW  *a1, 
1762                 int     a2, 
1763                 int     a3, 
1764                 cchar_t *z)
1765                 { return(*(int *)0); }
1766
1767 #undef mvwinnwstr
1768 int     mvwinnwstr(
1769                 WINDOW  *a1, 
1770                 int     a2, 
1771                 int     a3, 
1772                 wchar_t *a4, 
1773                 int     z)
1774                 { return(*(int *)0); }
1775
1776 #undef mvwins_nwstr
1777 int     mvwins_nwstr(
1778                 WINDOW  *a1, 
1779                 int     a2, 
1780                 int     a3, 
1781                 const wchar_t *a4, 
1782                 int     z)
1783                 { return(*(int *)0); }
1784
1785 #undef mvwins_wch
1786 int     mvwins_wch(
1787                 WINDOW  *a1, 
1788                 int     a2, 
1789                 int     a3, 
1790                 const cchar_t *z)
1791                 { return(*(int *)0); }
1792
1793 #undef mvwins_wstr
1794 int     mvwins_wstr(
1795                 WINDOW  *a1, 
1796                 int     a2, 
1797                 int     a3, 
1798                 const wchar_t *z)
1799                 { return(*(int *)0); }
1800
1801 #undef mvwinwstr
1802 int     mvwinwstr(
1803                 WINDOW  *a1, 
1804                 int     a2, 
1805                 int     a3, 
1806                 wchar_t *z)
1807                 { return(*(int *)0); }
1808
1809 #undef mvwvline_set
1810 int     mvwvline_set(
1811                 WINDOW  *a1, 
1812                 int     a2, 
1813                 int     a3, 
1814                 const cchar_t *a4, 
1815                 int     z)
1816                 { return(*(int *)0); }
1817
1818 #undef vline_set
1819 int     vline_set(
1820                 const cchar_t *a1, 
1821                 int     z)
1822                 { return(*(int *)0); }
1823
1824 #undef wadd_wchstr
1825 int     wadd_wchstr(
1826                 WINDOW  *a1, 
1827                 const cchar_t *z)
1828                 { return(*(int *)0); }
1829
1830 #undef waddwstr
1831 int     waddwstr(
1832                 WINDOW  *a1, 
1833                 const wchar_t *z)
1834                 { return(*(int *)0); }
1835
1836 #undef wget_wstr
1837 int     wget_wstr(
1838                 WINDOW  *a1, 
1839                 wint_t  *z)
1840                 { return(*(int *)0); }
1841
1842 #undef wgetbkgrnd
1843 int     wgetbkgrnd(
1844                 WINDOW  *a1, 
1845                 cchar_t *z)
1846                 { return(*(int *)0); }
1847
1848 #undef win_wchstr
1849 int     win_wchstr(
1850                 WINDOW  *a1, 
1851                 cchar_t *z)
1852                 { return(*(int *)0); }
1853
1854 #undef wins_wstr
1855 int     wins_wstr(
1856                 WINDOW  *a1, 
1857                 const wchar_t *z)
1858                 { return(*(int *)0); }
1859
1860 #undef mouse_trafo
1861 NCURSES_BOOL mouse_trafo(
1862                 int     *a1, 
1863                 int     *a2, 
1864                 NCURSES_BOOL z)
1865                 { return(*(NCURSES_BOOL *)0); }
1866
1867 /* ./base/lib_getch.c */
1868
1869 #undef _nc_ESCDELAY
1870 int     _nc_ESCDELAY(void)
1871                 { return(*(int *)0); }
1872
1873 #undef _nc_ptr_Escdelay
1874 int     *_nc_ptr_Escdelay(
1875                 SCREEN  *sp)
1876                 { return(*(int **)0); }
1877
1878 #undef set_escdelay_sp
1879 int     set_escdelay_sp(
1880                 SCREEN  *sp, 
1881                 int     value)
1882                 { return(*(int *)0); }
1883
1884 #undef set_escdelay
1885 int     set_escdelay(
1886                 int     value)
1887                 { return(*(int *)0); }
1888
1889 #undef get_escdelay_sp
1890 int     get_escdelay_sp(
1891                 SCREEN  *sp)
1892                 { return(*(int *)0); }
1893
1894 #undef get_escdelay
1895 int     get_escdelay(void)
1896                 { return(*(int *)0); }
1897
1898 #undef _nc_wgetch
1899 int     _nc_wgetch(
1900                 WINDOW  *win, 
1901                 int     *result, 
1902                 int     use_meta)
1903                 { return(*(int *)0); }
1904
1905 #undef wgetch
1906 int     wgetch(
1907                 WINDOW  *win)
1908                 { return(*(int *)0); }
1909
1910 /* ./base/lib_getstr.c */
1911
1912 #undef wgetnstr
1913 int     wgetnstr(
1914                 WINDOW  *win, 
1915                 char    *str, 
1916                 int     maxlen)
1917                 { return(*(int *)0); }
1918
1919 /* ./base/lib_hline.c */
1920
1921 #undef whline
1922 int     whline(
1923                 WINDOW  *win, 
1924                 chtype  ch, 
1925                 int     n)
1926                 { return(*(int *)0); }
1927
1928 /* ./base/lib_immedok.c */
1929
1930 #undef immedok
1931 void    immedok(
1932                 WINDOW  *win, 
1933                 NCURSES_BOOL flag)
1934                 { /* void */ }
1935
1936 /* ./base/lib_inchstr.c */
1937
1938 #undef winchnstr
1939 int     winchnstr(
1940                 WINDOW  *win, 
1941                 chtype  *str, 
1942                 int     n)
1943                 { return(*(int *)0); }
1944
1945 /* ./base/lib_initscr.c */
1946
1947 #undef initscr
1948 WINDOW  *initscr(void)
1949                 { return(*(WINDOW **)0); }
1950
1951 /* ./base/lib_insch.c */
1952
1953 #undef _nc_insert_ch
1954 int     _nc_insert_ch(
1955                 SCREEN  *sp, 
1956                 WINDOW  *win, 
1957                 chtype  ch)
1958                 { return(*(int *)0); }
1959
1960 #undef winsch
1961 int     winsch(
1962                 WINDOW  *win, 
1963                 chtype  c)
1964                 { return(*(int *)0); }
1965
1966 /* ./base/lib_insdel.c */
1967
1968 #undef winsdelln
1969 int     winsdelln(
1970                 WINDOW  *win, 
1971                 int     n)
1972                 { return(*(int *)0); }
1973
1974 /* ./base/lib_insnstr.c */
1975
1976 #undef winsnstr
1977 int     winsnstr(
1978                 WINDOW  *win, 
1979                 const char *s, 
1980                 int     n)
1981                 { return(*(int *)0); }
1982
1983 /* ./base/lib_instr.c */
1984
1985 #undef winnstr
1986 int     winnstr(
1987                 WINDOW  *win, 
1988                 char    *str, 
1989                 int     n)
1990                 { return(*(int *)0); }
1991
1992 /* ./base/lib_isendwin.c */
1993
1994 #undef isendwin_sp
1995 NCURSES_BOOL isendwin_sp(
1996                 SCREEN  *sp)
1997                 { return(*(NCURSES_BOOL *)0); }
1998
1999 #undef isendwin
2000 NCURSES_BOOL isendwin(void)
2001                 { return(*(NCURSES_BOOL *)0); }
2002
2003 /* ./base/lib_leaveok.c */
2004
2005 #undef leaveok
2006 int     leaveok(
2007                 WINDOW  *win, 
2008                 NCURSES_BOOL flag)
2009                 { return(*(int *)0); }
2010
2011 /* ./base/lib_mouse.c */
2012
2013 #undef getmouse_sp
2014 int     getmouse_sp(
2015                 SCREEN  *sp, 
2016                 MEVENT  *aevent)
2017                 { return(*(int *)0); }
2018
2019 #undef getmouse
2020 int     getmouse(
2021                 MEVENT  *aevent)
2022                 { return(*(int *)0); }
2023
2024 #undef ungetmouse_sp
2025 int     ungetmouse_sp(
2026                 SCREEN  *sp, 
2027                 MEVENT  *aevent)
2028                 { return(*(int *)0); }
2029
2030 #undef ungetmouse
2031 int     ungetmouse(
2032                 MEVENT  *aevent)
2033                 { return(*(int *)0); }
2034
2035 #undef mousemask_sp
2036 mmask_t mousemask_sp(
2037                 SCREEN  *sp, 
2038                 mmask_t newmask, 
2039                 mmask_t *oldmask)
2040                 { return(*(mmask_t *)0); }
2041
2042 #undef mousemask
2043 mmask_t mousemask(
2044                 mmask_t newmask, 
2045                 mmask_t *oldmask)
2046                 { return(*(mmask_t *)0); }
2047
2048 #undef wenclose
2049 NCURSES_BOOL wenclose(
2050                 const WINDOW *win, 
2051                 int     y, 
2052                 int     x)
2053                 { return(*(NCURSES_BOOL *)0); }
2054
2055 #undef mouseinterval_sp
2056 int     mouseinterval_sp(
2057                 SCREEN  *sp, 
2058                 int     maxclick)
2059                 { return(*(int *)0); }
2060
2061 #undef mouseinterval
2062 int     mouseinterval(
2063                 int     maxclick)
2064                 { return(*(int *)0); }
2065
2066 #undef _nc_has_mouse
2067 NCURSES_BOOL _nc_has_mouse(
2068                 SCREEN  *sp)
2069                 { return(*(NCURSES_BOOL *)0); }
2070
2071 #undef has_mouse_sp
2072 NCURSES_BOOL has_mouse_sp(
2073                 SCREEN  *sp)
2074                 { return(*(NCURSES_BOOL *)0); }
2075
2076 #undef has_mouse
2077 NCURSES_BOOL has_mouse(void)
2078                 { return(*(NCURSES_BOOL *)0); }
2079
2080 #undef wmouse_trafo
2081 NCURSES_BOOL wmouse_trafo(
2082                 const WINDOW *win, 
2083                 int     *pY, 
2084                 int     *pX, 
2085                 NCURSES_BOOL to_screen)
2086                 { return(*(NCURSES_BOOL *)0); }
2087
2088 /* ./base/lib_move.c */
2089
2090 #undef wmove
2091 int     wmove(
2092                 WINDOW  *win, 
2093                 int     y, 
2094                 int     x)
2095                 { return(*(int *)0); }
2096
2097 /* ./tty/lib_mvcur.c */
2098
2099 #undef _nc_msec_cost_sp
2100 int     _nc_msec_cost_sp(
2101                 SCREEN  *sp, 
2102                 const char *const cap, 
2103                 int     affcnt)
2104                 { return(*(int *)0); }
2105
2106 #undef _nc_msec_cost
2107 int     _nc_msec_cost(
2108                 const char *const cap, 
2109                 int     affcnt)
2110                 { return(*(int *)0); }
2111
2112 #undef _nc_mvcur_resume_sp
2113 void    _nc_mvcur_resume_sp(
2114                 SCREEN  *sp)
2115                 { /* void */ }
2116
2117 #undef _nc_mvcur_resume
2118 void    _nc_mvcur_resume(void)
2119                 { /* void */ }
2120
2121 #undef _nc_mvcur_init_sp
2122 void    _nc_mvcur_init_sp(
2123                 SCREEN  *sp)
2124                 { /* void */ }
2125
2126 #undef _nc_mvcur_init
2127 void    _nc_mvcur_init(void)
2128                 { /* void */ }
2129
2130 #undef _nc_mvcur_wrap_sp
2131 void    _nc_mvcur_wrap_sp(
2132                 SCREEN  *sp)
2133                 { /* void */ }
2134
2135 #undef _nc_mvcur_wrap
2136 void    _nc_mvcur_wrap(void)
2137                 { /* void */ }
2138
2139 #undef _nc_mvcur_sp
2140 int     _nc_mvcur_sp(
2141                 SCREEN  *sp, 
2142                 int     yold, 
2143                 int     xold, 
2144                 int     ynew, 
2145                 int     xnew)
2146                 { return(*(int *)0); }
2147
2148 #undef _nc_mvcur
2149 int     _nc_mvcur(
2150                 int     yold, 
2151                 int     xold, 
2152                 int     ynew, 
2153                 int     xnew)
2154                 { return(*(int *)0); }
2155
2156 #undef mvcur_sp
2157 int     mvcur_sp(
2158                 SCREEN  *sp, 
2159                 int     yold, 
2160                 int     xold, 
2161                 int     ynew, 
2162                 int     xnew)
2163                 { return(*(int *)0); }
2164
2165 #undef mvcur
2166 int     mvcur(
2167                 int     yold, 
2168                 int     xold, 
2169                 int     ynew, 
2170                 int     xnew)
2171                 { return(*(int *)0); }
2172
2173 #undef _nc_optimize_enable
2174 int     _nc_optimize_enable;
2175
2176 /* ./base/lib_mvwin.c */
2177
2178 #undef mvwin
2179 int     mvwin(
2180                 WINDOW  *win, 
2181                 int     by, 
2182                 int     bx)
2183                 { return(*(int *)0); }
2184
2185 /* ./base/lib_newterm.c */
2186
2187 #undef filter_sp
2188 void    filter_sp(
2189                 SCREEN  *sp)
2190                 { /* void */ }
2191
2192 #undef filter
2193 void    filter(void)
2194                 { /* void */ }
2195
2196 #undef nofilter_sp
2197 void    nofilter_sp(
2198                 SCREEN  *sp)
2199                 { /* void */ }
2200
2201 #undef nofilter
2202 void    nofilter(void)
2203                 { /* void */ }
2204
2205 #undef newterm_sp
2206 SCREEN  *newterm_sp(
2207                 SCREEN  *sp, 
2208                 const char *name, 
2209                 FILE    *ofp, 
2210                 FILE    *ifp)
2211                 { return(*(SCREEN **)0); }
2212
2213 #undef newterm
2214 SCREEN  *newterm(
2215                 const char *name, 
2216                 FILE    *ofp, 
2217                 FILE    *ifp)
2218                 { return(*(SCREEN **)0); }
2219
2220 /* ./base/lib_newwin.c */
2221
2222 #undef _nc_freewin
2223 int     _nc_freewin(
2224                 WINDOW  *win)
2225                 { return(*(int *)0); }
2226
2227 #undef newwin_sp
2228 WINDOW  *newwin_sp(
2229                 SCREEN  *sp, 
2230                 int     num_lines, 
2231                 int     num_columns, 
2232                 int     begy, 
2233                 int     begx)
2234                 { return(*(WINDOW **)0); }
2235
2236 #undef newwin
2237 WINDOW  *newwin(
2238                 int     num_lines, 
2239                 int     num_columns, 
2240                 int     begy, 
2241                 int     begx)
2242                 { return(*(WINDOW **)0); }
2243
2244 #undef derwin
2245 WINDOW  *derwin(
2246                 WINDOW  *orig, 
2247                 int     num_lines, 
2248                 int     num_columns, 
2249                 int     begy, 
2250                 int     begx)
2251                 { return(*(WINDOW **)0); }
2252
2253 #undef subwin
2254 WINDOW  *subwin(
2255                 WINDOW  *w, 
2256                 int     l, 
2257                 int     c, 
2258                 int     y, 
2259                 int     x)
2260                 { return(*(WINDOW **)0); }
2261
2262 #undef _nc_makenew_sp
2263 WINDOW  *_nc_makenew_sp(
2264                 SCREEN  *sp, 
2265                 int     num_lines, 
2266                 int     num_columns, 
2267                 int     begy, 
2268                 int     begx, 
2269                 int     flags)
2270                 { return(*(WINDOW **)0); }
2271
2272 #undef _nc_curscr_of
2273 WINDOW  *_nc_curscr_of(
2274                 SCREEN  *sp)
2275                 { return(*(WINDOW **)0); }
2276
2277 #undef _nc_newscr_of
2278 WINDOW  *_nc_newscr_of(
2279                 SCREEN  *sp)
2280                 { return(*(WINDOW **)0); }
2281
2282 #undef _nc_stdscr_of
2283 WINDOW  *_nc_stdscr_of(
2284                 SCREEN  *sp)
2285                 { return(*(WINDOW **)0); }
2286
2287 /* ./base/lib_nl.c */
2288
2289 #undef nl_sp
2290 int     nl_sp(
2291                 SCREEN  *sp)
2292                 { return(*(int *)0); }
2293
2294 #undef nl
2295 int     nl(void)
2296                 { return(*(int *)0); }
2297
2298 #undef nonl_sp
2299 int     nonl_sp(
2300                 SCREEN  *sp)
2301                 { return(*(int *)0); }
2302
2303 #undef nonl
2304 int     nonl(void)
2305                 { return(*(int *)0); }
2306
2307 /* ./base/lib_overlay.c */
2308
2309 #undef overlay
2310 int     overlay(
2311                 const WINDOW *win1, 
2312                 WINDOW  *win2)
2313                 { return(*(int *)0); }
2314
2315 #undef overwrite
2316 int     overwrite(
2317                 const WINDOW *win1, 
2318                 WINDOW  *win2)
2319                 { return(*(int *)0); }
2320
2321 #undef copywin
2322 int     copywin(
2323                 const WINDOW *src, 
2324                 WINDOW  *dst, 
2325                 int     sminrow, 
2326                 int     smincol, 
2327                 int     dminrow, 
2328                 int     dmincol, 
2329                 int     dmaxrow, 
2330                 int     dmaxcol, 
2331                 int     over)
2332                 { return(*(int *)0); }
2333
2334 /* ./base/lib_pad.c */
2335
2336 #undef newpad_sp
2337 WINDOW  *newpad_sp(
2338                 SCREEN  *sp, 
2339                 int     l, 
2340                 int     c)
2341                 { return(*(WINDOW **)0); }
2342
2343 #undef newpad
2344 WINDOW  *newpad(
2345                 int     l, 
2346                 int     c)
2347                 { return(*(WINDOW **)0); }
2348
2349 #undef subpad
2350 WINDOW  *subpad(
2351                 WINDOW  *orig, 
2352                 int     l, 
2353                 int     c, 
2354                 int     begy, 
2355                 int     begx)
2356                 { return(*(WINDOW **)0); }
2357
2358 #undef prefresh
2359 int     prefresh(
2360                 WINDOW  *win, 
2361                 int     pminrow, 
2362                 int     pmincol, 
2363                 int     sminrow, 
2364                 int     smincol, 
2365                 int     smaxrow, 
2366                 int     smaxcol)
2367                 { return(*(int *)0); }
2368
2369 #undef pnoutrefresh
2370 int     pnoutrefresh(
2371                 WINDOW  *win, 
2372                 int     pminrow, 
2373                 int     pmincol, 
2374                 int     sminrow, 
2375                 int     smincol, 
2376                 int     smaxrow, 
2377                 int     smaxcol)
2378                 { return(*(int *)0); }
2379
2380 #undef pechochar
2381 int     pechochar(
2382                 WINDOW  *pad, 
2383                 const chtype ch)
2384                 { return(*(int *)0); }
2385
2386 /* ./base/lib_printw.c */
2387
2388 #undef printw
2389 int     printw(
2390                 const char *fmt, 
2391                 ...)
2392                 { return(*(int *)0); }
2393
2394 #undef wprintw
2395 int     wprintw(
2396                 WINDOW  *win, 
2397                 const char *fmt, 
2398                 ...)
2399                 { return(*(int *)0); }
2400
2401 #undef mvprintw
2402 int     mvprintw(
2403                 int     y, 
2404                 int     x, 
2405                 const char *fmt, 
2406                 ...)
2407                 { return(*(int *)0); }
2408
2409 #undef mvwprintw
2410 int     mvwprintw(
2411                 WINDOW  *win, 
2412                 int     y, 
2413                 int     x, 
2414                 const char *fmt, 
2415                 ...)
2416                 { return(*(int *)0); }
2417
2418 #undef vwprintw
2419 int     vwprintw(
2420                 WINDOW  *win, 
2421                 const char *fmt, 
2422                 va_list argp)
2423                 { return(*(int *)0); }
2424
2425 #undef vw_printw
2426 int     vw_printw(
2427                 WINDOW  *win, 
2428                 const char *fmt, 
2429                 va_list argp)
2430                 { return(*(int *)0); }
2431
2432 /* ./base/lib_redrawln.c */
2433
2434 #undef wredrawln
2435 int     wredrawln(
2436                 WINDOW  *win, 
2437                 int     beg, 
2438                 int     num)
2439                 { return(*(int *)0); }
2440
2441 /* ./base/lib_refresh.c */
2442
2443 #undef wrefresh
2444 int     wrefresh(
2445                 WINDOW  *win)
2446                 { return(*(int *)0); }
2447
2448 #undef wnoutrefresh
2449 int     wnoutrefresh(
2450                 WINDOW  *win)
2451                 { return(*(int *)0); }
2452
2453 /* ./base/lib_restart.c */
2454
2455 #undef restartterm_sp
2456 int     restartterm_sp(
2457                 SCREEN  *sp, 
2458                 const char *termp, 
2459                 int     filenum, 
2460                 int     *errret)
2461                 { return(*(int *)0); }
2462
2463 #undef restartterm
2464 int     restartterm(
2465                 const char *termp, 
2466                 int     filenum, 
2467                 int     *errret)
2468                 { return(*(int *)0); }
2469
2470 /* ./base/lib_scanw.c */
2471
2472 #undef vwscanw
2473 int     vwscanw(
2474                 WINDOW  *win, 
2475                 const char *fmt, 
2476                 va_list argp)
2477                 { return(*(int *)0); }
2478
2479 #undef vw_scanw
2480 int     vw_scanw(
2481                 WINDOW  *win, 
2482                 const char *fmt, 
2483                 va_list argp)
2484                 { return(*(int *)0); }
2485
2486 #undef scanw
2487 int     scanw(
2488                 const char *fmt, 
2489                 ...)
2490                 { return(*(int *)0); }
2491
2492 #undef wscanw
2493 int     wscanw(
2494                 WINDOW  *win, 
2495                 const char *fmt, 
2496                 ...)
2497                 { return(*(int *)0); }
2498
2499 #undef mvscanw
2500 int     mvscanw(
2501                 int     y, 
2502                 int     x, 
2503                 const char *fmt, 
2504                 ...)
2505                 { return(*(int *)0); }
2506
2507 #undef mvwscanw
2508 int     mvwscanw(
2509                 WINDOW  *win, 
2510                 int     y, 
2511                 int     x, 
2512                 const char *fmt, 
2513                 ...)
2514                 { return(*(int *)0); }
2515
2516 /* ./base/lib_screen.c */
2517
2518 #undef getwin_sp
2519 WINDOW  *getwin_sp(
2520                 SCREEN  *sp, 
2521                 FILE    *filep)
2522                 { return(*(WINDOW **)0); }
2523
2524 #undef getwin
2525 WINDOW  *getwin(
2526                 FILE    *filep)
2527                 { return(*(WINDOW **)0); }
2528
2529 #undef putwin
2530 int     putwin(
2531                 WINDOW  *win, 
2532                 FILE    *filep)
2533                 { return(*(int *)0); }
2534
2535 #undef scr_restore_sp
2536 int     scr_restore_sp(
2537                 SCREEN  *sp, 
2538                 const char *file)
2539                 { return(*(int *)0); }
2540
2541 #undef scr_restore
2542 int     scr_restore(
2543                 const char *file)
2544                 { return(*(int *)0); }
2545
2546 #undef scr_dump
2547 int     scr_dump(
2548                 const char *file)
2549                 { return(*(int *)0); }
2550
2551 #undef scr_init_sp
2552 int     scr_init_sp(
2553                 SCREEN  *sp, 
2554                 const char *file)
2555                 { return(*(int *)0); }
2556
2557 #undef scr_init
2558 int     scr_init(
2559                 const char *file)
2560                 { return(*(int *)0); }
2561
2562 #undef scr_set_sp
2563 int     scr_set_sp(
2564                 SCREEN  *sp, 
2565                 const char *file)
2566                 { return(*(int *)0); }
2567
2568 #undef scr_set
2569 int     scr_set(
2570                 const char *file)
2571                 { return(*(int *)0); }
2572
2573 /* ./base/lib_scroll.c */
2574
2575 #undef _nc_scroll_window
2576 void    _nc_scroll_window(
2577                 WINDOW  *win, 
2578                 int const n, 
2579                 int const top, 
2580                 int const bottom, 
2581                 cchar_t blank)
2582                 { /* void */ }
2583
2584 #undef wscrl
2585 int     wscrl(
2586                 WINDOW  *win, 
2587                 int     n)
2588                 { return(*(int *)0); }
2589
2590 /* ./base/lib_scrollok.c */
2591
2592 #undef scrollok
2593 int     scrollok(
2594                 WINDOW  *win, 
2595                 NCURSES_BOOL flag)
2596                 { return(*(int *)0); }
2597
2598 /* ./base/lib_scrreg.c */
2599
2600 #undef wsetscrreg
2601 int     wsetscrreg(
2602                 WINDOW  *win, 
2603                 int     top, 
2604                 int     bottom)
2605                 { return(*(int *)0); }
2606
2607 /* ./base/lib_set_term.c */
2608
2609 #undef set_term
2610 SCREEN  *set_term(
2611                 SCREEN  *screenp)
2612                 { return(*(SCREEN **)0); }
2613
2614 #undef delscreen
2615 void    delscreen(
2616                 SCREEN  *sp)
2617                 { /* void */ }
2618
2619 #undef _nc_setupscreen_sp
2620 int     _nc_setupscreen_sp(
2621                 SCREEN  **spp, 
2622                 int     slines, 
2623                 int     scolumns, 
2624                 FILE    *output, 
2625                 int     filtered, 
2626                 int     slk_format)
2627                 { return(*(int *)0); }
2628
2629 #undef _nc_setupscreen
2630 int     _nc_setupscreen(
2631                 int     slines, 
2632                 int     scolumns, 
2633                 FILE    *output, 
2634                 int     filtered, 
2635                 int     slk_format)
2636                 { return(*(int *)0); }
2637
2638 #undef _nc_ripoffline_sp
2639 int     _nc_ripoffline_sp(
2640                 SCREEN  *sp, 
2641                 int     line, 
2642                 int     (*init)(
2643                 WINDOW  *p1, 
2644                 int     p2))
2645                 { return(*(int *)0); }
2646
2647 #undef _nc_ripoffline
2648 int     _nc_ripoffline(
2649                 int     line, 
2650                 int     (*init)(
2651                 WINDOW  *p1, 
2652                 int     p2))
2653                 { return(*(int *)0); }
2654
2655 #undef ripoffline_sp
2656 int     ripoffline_sp(
2657                 SCREEN  *sp, 
2658                 int     line, 
2659                 int     (*init)(
2660                 WINDOW  *p1, 
2661                 int     p2))
2662                 { return(*(int *)0); }
2663
2664 #undef ripoffline
2665 int     ripoffline(
2666                 int     line, 
2667                 int     (*init)(
2668                 WINDOW  *p1, 
2669                 int     p2))
2670                 { return(*(int *)0); }
2671
2672 /* ./base/lib_slk.c */
2673
2674 #undef _nc_format_slks
2675 int     _nc_format_slks(
2676                 SCREEN  *sp, 
2677                 int     cols)
2678                 { return(*(int *)0); }
2679
2680 #undef _nc_slk_initialize
2681 int     _nc_slk_initialize(
2682                 WINDOW  *stwin, 
2683                 int     cols)
2684                 { return(*(int *)0); }
2685
2686 #undef slk_restore_sp
2687 int     slk_restore_sp(
2688                 SCREEN  *sp)
2689                 { return(*(int *)0); }
2690
2691 #undef slk_restore
2692 int     slk_restore(void)
2693                 { return(*(int *)0); }
2694
2695 /* ./base/lib_slkatr_set.c */
2696
2697 #undef slk_attr_set_sp
2698 int     slk_attr_set_sp(
2699                 SCREEN  *sp, 
2700                 const attr_t attr, 
2701                 short   pair_arg, 
2702                 void    *opts)
2703                 { return(*(int *)0); }
2704
2705 #undef slk_attr_set
2706 int     slk_attr_set(
2707                 const attr_t attr, 
2708                 short   pair_arg, 
2709                 void    *opts)
2710                 { return(*(int *)0); }
2711
2712 /* ./base/lib_slkatrof.c */
2713
2714 #undef slk_attroff_sp
2715 int     slk_attroff_sp(
2716                 SCREEN  *sp, 
2717                 const chtype attr)
2718                 { return(*(int *)0); }
2719
2720 #undef slk_attroff
2721 int     slk_attroff(
2722                 const chtype attr)
2723                 { return(*(int *)0); }
2724
2725 /* ./base/lib_slkatron.c */
2726
2727 #undef slk_attron_sp
2728 int     slk_attron_sp(
2729                 SCREEN  *sp, 
2730                 const chtype attr)
2731                 { return(*(int *)0); }
2732
2733 #undef slk_attron
2734 int     slk_attron(
2735                 const chtype attr)
2736                 { return(*(int *)0); }
2737
2738 /* ./base/lib_slkatrset.c */
2739
2740 #undef slk_attrset_sp
2741 int     slk_attrset_sp(
2742                 SCREEN  *sp, 
2743                 const chtype attr)
2744                 { return(*(int *)0); }
2745
2746 #undef slk_attrset
2747 int     slk_attrset(
2748                 const chtype attr)
2749                 { return(*(int *)0); }
2750
2751 /* ./base/lib_slkattr.c */
2752
2753 #undef slk_attr_sp
2754 attr_t  slk_attr_sp(
2755                 SCREEN  *sp)
2756                 { return(*(attr_t *)0); }
2757
2758 #undef slk_attr
2759 attr_t  slk_attr(void)
2760                 { return(*(attr_t *)0); }
2761
2762 /* ./base/lib_slkclear.c */
2763
2764 #undef slk_clear_sp
2765 int     slk_clear_sp(
2766                 SCREEN  *sp)
2767                 { return(*(int *)0); }
2768
2769 #undef slk_clear
2770 int     slk_clear(void)
2771                 { return(*(int *)0); }
2772
2773 /* ./base/lib_slkcolor.c */
2774
2775 #undef slk_color_sp
2776 int     slk_color_sp(
2777                 SCREEN  *sp, 
2778                 short   pair_arg)
2779                 { return(*(int *)0); }
2780
2781 #undef slk_color
2782 int     slk_color(
2783                 short   pair_arg)
2784                 { return(*(int *)0); }
2785
2786 #undef extended_slk_color_sp
2787 int     extended_slk_color_sp(
2788                 SCREEN  *sp, 
2789                 int     pair_arg)
2790                 { return(*(int *)0); }
2791
2792 #undef extended_slk_color
2793 int     extended_slk_color(
2794                 int     pair_arg)
2795                 { return(*(int *)0); }
2796
2797 /* ./base/lib_slkinit.c */
2798
2799 #undef slk_init_sp
2800 int     slk_init_sp(
2801                 SCREEN  *sp, 
2802                 int     format)
2803                 { return(*(int *)0); }
2804
2805 #undef slk_init
2806 int     slk_init(
2807                 int     format)
2808                 { return(*(int *)0); }
2809
2810 /* ./base/lib_slklab.c */
2811
2812 #undef slk_label_sp
2813 char    *slk_label_sp(
2814                 SCREEN  *sp, 
2815                 int     n)
2816                 { return(*(char **)0); }
2817
2818 #undef slk_label
2819 char    *slk_label(
2820                 int     n)
2821                 { return(*(char **)0); }
2822
2823 /* ./base/lib_slkrefr.c */
2824
2825 #undef slk_noutrefresh_sp
2826 int     slk_noutrefresh_sp(
2827                 SCREEN  *sp)
2828                 { return(*(int *)0); }
2829
2830 #undef slk_noutrefresh
2831 int     slk_noutrefresh(void)
2832                 { return(*(int *)0); }
2833
2834 #undef slk_refresh_sp
2835 int     slk_refresh_sp(
2836                 SCREEN  *sp)
2837                 { return(*(int *)0); }
2838
2839 #undef slk_refresh
2840 int     slk_refresh(void)
2841                 { return(*(int *)0); }
2842
2843 /* ./base/lib_slkset.c */
2844
2845 #undef slk_set_sp
2846 int     slk_set_sp(
2847                 SCREEN  *sp, 
2848                 int     i, 
2849                 const char *astr, 
2850                 int     format)
2851                 { return(*(int *)0); }
2852
2853 #undef slk_set
2854 int     slk_set(
2855                 int     i, 
2856                 const char *astr, 
2857                 int     format)
2858                 { return(*(int *)0); }
2859
2860 /* ./base/lib_slktouch.c */
2861
2862 #undef slk_touch_sp
2863 int     slk_touch_sp(
2864                 SCREEN  *sp)
2865                 { return(*(int *)0); }
2866
2867 #undef slk_touch
2868 int     slk_touch(void)
2869                 { return(*(int *)0); }
2870
2871 /* ./base/lib_touch.c */
2872
2873 #undef is_linetouched
2874 NCURSES_BOOL is_linetouched(
2875                 WINDOW  *win, 
2876                 int     line)
2877                 { return(*(NCURSES_BOOL *)0); }
2878
2879 #undef is_wintouched
2880 NCURSES_BOOL is_wintouched(
2881                 WINDOW  *win)
2882                 { return(*(NCURSES_BOOL *)0); }
2883
2884 #undef wtouchln
2885 int     wtouchln(
2886                 WINDOW  *win, 
2887                 int     y, 
2888                 int     n, 
2889                 int     changed)
2890                 { return(*(int *)0); }
2891
2892 /* ./trace/lib_tracedmp.c */
2893
2894 #undef _tracedump
2895 void    _tracedump(
2896                 const char *name, 
2897                 WINDOW  *win)
2898                 { /* void */ }
2899
2900 /* ./trace/lib_tracemse.c */
2901
2902 #undef _nc_trace_mmask_t
2903 char    *_nc_trace_mmask_t(
2904                 SCREEN  *sp, 
2905                 mmask_t code)
2906                 { return(*(char **)0); }
2907
2908 #undef _nc_tracemouse
2909 char    *_nc_tracemouse(
2910                 SCREEN  *sp, 
2911                 MEVENT const *ep)
2912                 { return(*(char **)0); }
2913
2914 #undef _nc_retrace_mmask_t
2915 mmask_t _nc_retrace_mmask_t(
2916                 SCREEN  *sp, 
2917                 mmask_t code)
2918                 { return(*(mmask_t *)0); }
2919
2920 #undef _tracemouse
2921 char    *_tracemouse(
2922                 MEVENT const *ep)
2923                 { return(*(char **)0); }
2924
2925 /* ./tty/lib_tstp.c */
2926
2927 #undef _nc_signal_handler
2928 void    _nc_signal_handler(
2929                 int     enable)
2930                 { /* void */ }
2931
2932 /* ./base/lib_ungetch.c */
2933
2934 #undef _nc_fifo_dump
2935 void    _nc_fifo_dump(
2936                 SCREEN  *sp)
2937                 { /* void */ }
2938
2939 #undef ungetch_sp
2940 int     ungetch_sp(
2941                 SCREEN  *sp, 
2942                 int     ch)
2943                 { return(*(int *)0); }
2944
2945 #undef ungetch
2946 int     ungetch(
2947                 int     ch)
2948                 { return(*(int *)0); }
2949
2950 /* ./tty/lib_vidattr.c */
2951
2952 #undef vidputs_sp
2953 int     vidputs_sp(
2954                 SCREEN  *sp, 
2955                 chtype  newmode, 
2956                 NCURSES_OUTC_sp outc)
2957                 { return(*(int *)0); }
2958
2959 #undef vidputs
2960 int     vidputs(
2961                 chtype  newmode, 
2962                 NCURSES_OUTC outc)
2963                 { return(*(int *)0); }
2964
2965 #undef vidattr_sp
2966 int     vidattr_sp(
2967                 SCREEN  *sp, 
2968                 chtype  newmode)
2969                 { return(*(int *)0); }
2970
2971 #undef vidattr
2972 int     vidattr(
2973                 chtype  newmode)
2974                 { return(*(int *)0); }
2975
2976 #undef termattrs_sp
2977 chtype  termattrs_sp(
2978                 SCREEN  *sp)
2979                 { return(*(chtype *)0); }
2980
2981 #undef termattrs
2982 chtype  termattrs(void)
2983                 { return(*(chtype *)0); }
2984
2985 /* ./base/lib_vline.c */
2986
2987 #undef wvline
2988 int     wvline(
2989                 WINDOW  *win, 
2990                 chtype  ch, 
2991                 int     n)
2992                 { return(*(int *)0); }
2993
2994 /* ./base/lib_wattroff.c */
2995
2996 #undef wattr_off
2997 int     wattr_off(
2998                 WINDOW  *win, 
2999                 attr_t  at, 
3000                 void    *opts)
3001                 { return(*(int *)0); }
3002
3003 /* ./base/lib_wattron.c */
3004
3005 #undef wattr_on
3006 int     wattr_on(
3007                 WINDOW  *win, 
3008                 attr_t  at, 
3009                 void    *opts)
3010                 { return(*(int *)0); }
3011
3012 /* ./base/lib_winch.c */
3013
3014 #undef winch
3015 chtype  winch(
3016                 WINDOW  *win)
3017                 { return(*(chtype *)0); }
3018
3019 /* ./base/lib_window.c */
3020
3021 #undef _nc_synchook
3022 void    _nc_synchook(
3023                 WINDOW  *win)
3024                 { /* void */ }
3025
3026 #undef mvderwin
3027 int     mvderwin(
3028                 WINDOW  *win, 
3029                 int     y, 
3030                 int     x)
3031                 { return(*(int *)0); }
3032
3033 #undef syncok
3034 int     syncok(
3035                 WINDOW  *win, 
3036                 NCURSES_BOOL bf)
3037                 { return(*(int *)0); }
3038
3039 #undef wsyncup
3040 void    wsyncup(
3041                 WINDOW  *win)
3042                 { /* void */ }
3043
3044 #undef wsyncdown
3045 void    wsyncdown(
3046                 WINDOW  *win)
3047                 { /* void */ }
3048
3049 #undef wcursyncup
3050 void    wcursyncup(
3051                 WINDOW  *win)
3052                 { /* void */ }
3053
3054 #undef dupwin
3055 WINDOW  *dupwin(
3056                 WINDOW  *win)
3057                 { return(*(WINDOW **)0); }
3058
3059 /* ./base/nc_panel.c */
3060
3061 #undef _nc_panelhook_sp
3062 struct panelhook *_nc_panelhook_sp(
3063                 SCREEN  *sp)
3064                 { return(*(struct panelhook **)0); }
3065
3066 #undef _nc_panelhook
3067 struct panelhook *_nc_panelhook(void)
3068                 { return(*(struct panelhook **)0); }
3069
3070 /* ./base/safe_sprintf.c */
3071
3072 #undef _nc_printf_string_sp
3073 char    *_nc_printf_string_sp(
3074                 SCREEN  *sp, 
3075                 const char *fmt, 
3076                 va_list ap)
3077                 { return(*(char **)0); }
3078
3079 #undef _nc_printf_string
3080 char    *_nc_printf_string(
3081                 const char *fmt, 
3082                 va_list ap)
3083                 { return(*(char **)0); }
3084
3085 /* ./tty/tty_update.c */
3086
3087 #undef doupdate_sp
3088 int     doupdate_sp(
3089                 SCREEN  *sp)
3090                 { return(*(int *)0); }
3091
3092 #undef doupdate
3093 int     doupdate(void)
3094                 { return(*(int *)0); }
3095
3096 #undef _nc_scrolln_sp
3097 int     _nc_scrolln_sp(
3098                 SCREEN  *sp, 
3099                 int     n, 
3100                 int     top, 
3101                 int     bot, 
3102                 int     maxy)
3103                 { return(*(int *)0); }
3104
3105 #undef _nc_scrolln
3106 int     _nc_scrolln(
3107                 int     n, 
3108                 int     top, 
3109                 int     bot, 
3110                 int     maxy)
3111                 { return(*(int *)0); }
3112
3113 #undef _nc_screen_resume_sp
3114 void    _nc_screen_resume_sp(
3115                 SCREEN  *sp)
3116                 { /* void */ }
3117
3118 #undef _nc_screen_resume
3119 void    _nc_screen_resume(void)
3120                 { /* void */ }
3121
3122 #undef _nc_screen_init_sp
3123 void    _nc_screen_init_sp(
3124                 SCREEN  *sp)
3125                 { /* void */ }
3126
3127 #undef _nc_screen_init
3128 void    _nc_screen_init(void)
3129                 { /* void */ }
3130
3131 #undef _nc_screen_wrap_sp
3132 void    _nc_screen_wrap_sp(
3133                 SCREEN  *sp)
3134                 { /* void */ }
3135
3136 #undef _nc_screen_wrap
3137 void    _nc_screen_wrap(void)
3138                 { /* void */ }
3139
3140 #undef _nc_do_xmc_glitch_sp
3141 void    _nc_do_xmc_glitch_sp(
3142                 SCREEN  *sp, 
3143                 attr_t  previous)
3144                 { /* void */ }
3145
3146 #undef _nc_do_xmc_glitch
3147 void    _nc_do_xmc_glitch(
3148                 attr_t  previous)
3149                 { /* void */ }
3150
3151 /* ./trace/varargs.c */
3152
3153 #undef _nc_varargs
3154 char    *_nc_varargs(
3155                 const char *fmt, 
3156                 va_list ap)
3157                 { return(*(char **)0); }
3158
3159 /* ./base/vsscanf.c */
3160
3161 #undef _nc_vsscanf
3162 void    _nc_vsscanf(void)
3163                 { /* void */ }
3164
3165 /* ./base/lib_freeall.c */
3166
3167 #undef _nc_freeall
3168 void    _nc_freeall(void)
3169                 { /* void */ }
3170
3171 #undef _nc_free_and_exit_sp
3172 void    _nc_free_and_exit_sp(
3173                 SCREEN  *sp, 
3174                 int     code)
3175                 { /* void */ }
3176
3177 #undef _nc_free_and_exit
3178 void    _nc_free_and_exit(
3179                 int     code)
3180                 { /* void */ }
3181
3182 #undef exit_curses
3183 void    exit_curses(
3184                 int     code)
3185                 { /* void */ }
3186
3187 /* ./widechar/charable.c */
3188
3189 #undef _nc_is_charable
3190 NCURSES_BOOL _nc_is_charable(
3191                 wchar_t ch)
3192                 { return(*(NCURSES_BOOL *)0); }
3193
3194 #undef _nc_to_char
3195 int     _nc_to_char(
3196                 wint_t  ch)
3197                 { return(*(int *)0); }
3198
3199 #undef _nc_to_widechar
3200 wint_t  _nc_to_widechar(
3201                 int     ch)
3202                 { return(*(wint_t *)0); }
3203
3204 /* ./widechar/lib_add_wch.c */
3205
3206 #undef wadd_wch
3207 int     wadd_wch(
3208                 WINDOW  *win, 
3209                 const cchar_t *wch)
3210                 { return(*(int *)0); }
3211
3212 #undef wecho_wchar
3213 int     wecho_wchar(
3214                 WINDOW  *win, 
3215                 const cchar_t *wch)
3216                 { return(*(int *)0); }
3217
3218 /* ./widechar/lib_box_set.c */
3219
3220 #undef wborder_set
3221 int     wborder_set(
3222                 WINDOW  *win, 
3223                 const cchar_t *ls, 
3224                 const cchar_t *rs, 
3225                 const cchar_t *ts, 
3226                 const cchar_t *bs, 
3227                 const cchar_t *tl, 
3228                 const cchar_t *tr, 
3229                 const cchar_t *bl, 
3230                 const cchar_t *br)
3231                 { return(*(int *)0); }
3232
3233 /* ./widechar/lib_cchar.c */
3234
3235 #undef setcchar
3236 int     setcchar(
3237                 cchar_t *wcval, 
3238                 const wchar_t *wch, 
3239                 const attr_t attrs, 
3240                 short   pair_arg, 
3241                 const void *opts)
3242                 { return(*(int *)0); }
3243
3244 #undef getcchar
3245 int     getcchar(
3246                 const cchar_t *wcval, 
3247                 wchar_t *wch, 
3248                 attr_t  *attrs, 
3249                 short   *pair_arg, 
3250                 void    *opts)
3251                 { return(*(int *)0); }
3252
3253 /* ./widechar/lib_erasewchar.c */
3254
3255 #undef erasewchar
3256 int     erasewchar(
3257                 wchar_t *wch)
3258                 { return(*(int *)0); }
3259
3260 #undef killwchar
3261 int     killwchar(
3262                 wchar_t *wch)
3263                 { return(*(int *)0); }
3264
3265 /* ./widechar/lib_get_wch.c */
3266
3267 #undef wget_wch
3268 int     wget_wch(
3269                 WINDOW  *win, 
3270                 wint_t  *result)
3271                 { return(*(int *)0); }
3272
3273 /* ./widechar/lib_get_wstr.c */
3274
3275 #undef wgetn_wstr
3276 int     wgetn_wstr(
3277                 WINDOW  *win, 
3278                 wint_t  *str, 
3279                 int     maxlen)
3280                 { return(*(int *)0); }
3281
3282 /* ./widechar/lib_hline_set.c */
3283
3284 #undef whline_set
3285 int     whline_set(
3286                 WINDOW  *win, 
3287                 const cchar_t *ch, 
3288                 int     n)
3289                 { return(*(int *)0); }
3290
3291 /* ./widechar/lib_in_wch.c */
3292
3293 #undef win_wch
3294 int     win_wch(
3295                 WINDOW  *win, 
3296                 cchar_t *wcval)
3297                 { return(*(int *)0); }
3298
3299 /* ./widechar/lib_in_wchnstr.c */
3300
3301 #undef win_wchnstr
3302 int     win_wchnstr(
3303                 WINDOW  *win, 
3304                 cchar_t *wchstr, 
3305                 int     n)
3306                 { return(*(int *)0); }
3307
3308 /* ./widechar/lib_ins_wch.c */
3309
3310 #undef _nc_insert_wch
3311 int     _nc_insert_wch(
3312                 WINDOW  *win, 
3313                 const cchar_t *wch)
3314                 { return(*(int *)0); }
3315
3316 #undef wins_wch
3317 int     wins_wch(
3318                 WINDOW  *win, 
3319                 const cchar_t *wch)
3320                 { return(*(int *)0); }
3321
3322 #undef wins_nwstr
3323 int     wins_nwstr(
3324                 WINDOW  *win, 
3325                 const wchar_t *wstr, 
3326                 int     n)
3327                 { return(*(int *)0); }
3328
3329 /* ./widechar/lib_inwstr.c */
3330
3331 #undef winnwstr
3332 int     winnwstr(
3333                 WINDOW  *win, 
3334                 wchar_t *wstr, 
3335                 int     n)
3336                 { return(*(int *)0); }
3337
3338 #undef winwstr
3339 int     winwstr(
3340                 WINDOW  *win, 
3341                 wchar_t *wstr)
3342                 { return(*(int *)0); }
3343
3344 /* ./widechar/lib_key_name.c */
3345
3346 #undef key_name
3347 const char *key_name(
3348                 wchar_t c)
3349                 { return(*(const char **)0); }
3350
3351 /* ./widechar/lib_pecho_wchar.c */
3352
3353 #undef pecho_wchar
3354 int     pecho_wchar(
3355                 WINDOW  *pad, 
3356                 const cchar_t *wch)
3357                 { return(*(int *)0); }
3358
3359 /* ./widechar/lib_slk_wset.c */
3360
3361 #undef slk_wset
3362 int     slk_wset(
3363                 int     i, 
3364                 const wchar_t *astr, 
3365                 int     format)
3366                 { return(*(int *)0); }
3367
3368 /* ./widechar/lib_unget_wch.c */
3369
3370 #undef _nc_wcrtomb
3371 size_t  _nc_wcrtomb(
3372                 char    *target, 
3373                 wchar_t source, 
3374                 mbstate_t *state)
3375                 { return(*(size_t *)0); }
3376
3377 #undef unget_wch_sp
3378 int     unget_wch_sp(
3379                 SCREEN  *sp, 
3380                 const wchar_t wch)
3381                 { return(*(int *)0); }
3382
3383 #undef unget_wch
3384 int     unget_wch(
3385                 const wchar_t wch)
3386                 { return(*(int *)0); }
3387
3388 /* ./widechar/lib_vid_attr.c */
3389
3390 #undef vid_puts_sp
3391 int     vid_puts_sp(
3392                 SCREEN  *sp, 
3393                 attr_t  newmode, 
3394                 short   pair_arg, 
3395                 void    *opts, 
3396                 NCURSES_OUTC_sp outc)
3397                 { return(*(int *)0); }
3398
3399 #undef vid_puts
3400 int     vid_puts(
3401                 attr_t  newmode, 
3402                 short   pair_arg, 
3403                 void    *opts, 
3404                 NCURSES_OUTC outc)
3405                 { return(*(int *)0); }
3406
3407 #undef vid_attr_sp
3408 int     vid_attr_sp(
3409                 SCREEN  *sp, 
3410                 attr_t  newmode, 
3411                 short   pair_arg, 
3412                 void    *opts)
3413                 { return(*(int *)0); }
3414
3415 #undef vid_attr
3416 int     vid_attr(
3417                 attr_t  newmode, 
3418                 short   pair_arg, 
3419                 void    *opts)
3420                 { return(*(int *)0); }
3421
3422 #undef term_attrs_sp
3423 attr_t  term_attrs_sp(
3424                 SCREEN  *sp)
3425                 { return(*(attr_t *)0); }
3426
3427 #undef term_attrs
3428 attr_t  term_attrs(void)
3429                 { return(*(attr_t *)0); }
3430
3431 /* ./widechar/lib_vline_set.c */
3432
3433 #undef wvline_set
3434 int     wvline_set(
3435                 WINDOW  *win, 
3436                 const cchar_t *ch, 
3437                 int     n)
3438                 { return(*(int *)0); }
3439
3440 /* ./widechar/lib_wacs.c */
3441
3442 #undef _nc_wacs
3443 cchar_t *_nc_wacs;
3444
3445 #undef _nc_init_wacs
3446 void    _nc_init_wacs(void)
3447                 { /* void */ }
3448
3449 /* ./widechar/lib_wunctrl.c */
3450
3451 #undef wunctrl_sp
3452 wchar_t *wunctrl_sp(
3453                 SCREEN  *sp, 
3454                 cchar_t *wc)
3455                 { return(*(wchar_t **)0); }
3456
3457 #undef wunctrl
3458 wchar_t *wunctrl(
3459                 cchar_t *wc)
3460                 { return(*(wchar_t **)0); }
3461
3462 /* ./expanded.c */
3463
3464 #undef _nc_toggle_attr_on
3465 void    _nc_toggle_attr_on(
3466                 attr_t  *S, 
3467                 attr_t  at)
3468                 { /* void */ }
3469
3470 #undef _nc_toggle_attr_off
3471 void    _nc_toggle_attr_off(
3472                 attr_t  *S, 
3473                 attr_t  at)
3474                 { /* void */ }
3475
3476 #undef _nc_DelCharCost_sp
3477 int     _nc_DelCharCost_sp(
3478                 SCREEN  *sp, 
3479                 int     count)
3480                 { return(*(int *)0); }
3481
3482 #undef _nc_InsCharCost_sp
3483 int     _nc_InsCharCost_sp(
3484                 SCREEN  *sp, 
3485                 int     count)
3486                 { return(*(int *)0); }
3487
3488 #undef _nc_UpdateAttrs_sp
3489 void    _nc_UpdateAttrs_sp(
3490                 SCREEN  *sp, 
3491                 const cchar_t *c)
3492                 { /* void */ }
3493
3494 #undef _nc_DelCharCost
3495 int     _nc_DelCharCost(
3496                 int     count)
3497                 { return(*(int *)0); }
3498
3499 #undef _nc_InsCharCost
3500 int     _nc_InsCharCost(
3501                 int     count)
3502                 { return(*(int *)0); }
3503
3504 #undef _nc_UpdateAttrs
3505 void    _nc_UpdateAttrs(
3506                 const cchar_t *c)
3507                 { /* void */ }
3508
3509 /* ./base/legacy_coding.c */
3510
3511 #undef use_legacy_coding_sp
3512 int     use_legacy_coding_sp(
3513                 SCREEN  *sp, 
3514                 int     level)
3515                 { return(*(int *)0); }
3516
3517 #undef use_legacy_coding
3518 int     use_legacy_coding(
3519                 int     level)
3520                 { return(*(int *)0); }
3521
3522 /* ./base/lib_dft_fgbg.c */
3523
3524 #undef use_default_colors_sp
3525 int     use_default_colors_sp(
3526                 SCREEN  *sp)
3527                 { return(*(int *)0); }
3528
3529 #undef use_default_colors
3530 int     use_default_colors(void)
3531                 { return(*(int *)0); }
3532
3533 #undef assume_default_colors_sp
3534 int     assume_default_colors_sp(
3535                 SCREEN  *sp, 
3536                 int     fg, 
3537                 int     bg)
3538                 { return(*(int *)0); }
3539
3540 #undef assume_default_colors
3541 int     assume_default_colors(
3542                 int     fg, 
3543                 int     bg)
3544                 { return(*(int *)0); }
3545
3546 /* ./tinfo/lib_print.c */
3547
3548 #undef mcprint_sp
3549 int     mcprint_sp(
3550                 SCREEN  *sp, 
3551                 char    *data, 
3552                 int     len)
3553                 { return(*(int *)0); }
3554
3555 #undef mcprint
3556 int     mcprint(
3557                 char    *data, 
3558                 int     len)
3559                 { return(*(int *)0); }
3560
3561 /* ./base/new_pair.c */
3562
3563 #undef _nc_free_ordered_pairs
3564 void    _nc_free_ordered_pairs(
3565                 SCREEN  *sp)
3566                 { /* void */ }
3567
3568 #undef _nc_reset_color_pair
3569 void    _nc_reset_color_pair(
3570                 SCREEN  *sp, 
3571                 int     pair, 
3572                 colorpair_t *next)
3573                 { /* void */ }
3574
3575 #undef _nc_set_color_pair
3576 void    _nc_set_color_pair(
3577                 SCREEN  *sp, 
3578                 int     pair, 
3579                 int     mode)
3580                 { /* void */ }
3581
3582 #undef _nc_copy_pairs
3583 void    _nc_copy_pairs(
3584                 SCREEN  *sp, 
3585                 colorpair_t *target, 
3586                 colorpair_t *source, 
3587                 int     length)
3588                 { /* void */ }
3589
3590 #undef alloc_pair_sp
3591 int     alloc_pair_sp(
3592                 SCREEN  *sp, 
3593                 int     fg, 
3594                 int     bg)
3595                 { return(*(int *)0); }
3596
3597 #undef find_pair_sp
3598 int     find_pair_sp(
3599                 SCREEN  *sp, 
3600                 int     fg, 
3601                 int     bg)
3602                 { return(*(int *)0); }
3603
3604 #undef free_pair_sp
3605 int     free_pair_sp(
3606                 SCREEN  *sp, 
3607                 int     pair)
3608                 { return(*(int *)0); }
3609
3610 #undef alloc_pair
3611 int     alloc_pair(
3612                 int     f, 
3613                 int     b)
3614                 { return(*(int *)0); }
3615
3616 #undef find_pair
3617 int     find_pair(
3618                 int     f, 
3619                 int     b)
3620                 { return(*(int *)0); }
3621
3622 #undef free_pair
3623 int     free_pair(
3624                 int     pair)
3625                 { return(*(int *)0); }
3626
3627 /* ./base/resizeterm.c */
3628
3629 #undef is_term_resized_sp
3630 NCURSES_BOOL is_term_resized_sp(
3631                 SCREEN  *sp, 
3632                 int     ToLines, 
3633                 int     ToCols)
3634                 { return(*(NCURSES_BOOL *)0); }
3635
3636 #undef is_term_resized
3637 NCURSES_BOOL is_term_resized(
3638                 int     ToLines, 
3639                 int     ToCols)
3640                 { return(*(NCURSES_BOOL *)0); }
3641
3642 #undef resize_term_sp
3643 int     resize_term_sp(
3644                 SCREEN  *sp, 
3645                 int     ToLines, 
3646                 int     ToCols)
3647                 { return(*(int *)0); }
3648
3649 #undef resize_term
3650 int     resize_term(
3651                 int     ToLines, 
3652                 int     ToCols)
3653                 { return(*(int *)0); }
3654
3655 #undef resizeterm_sp
3656 int     resizeterm_sp(
3657                 SCREEN  *sp, 
3658                 int     ToLines, 
3659                 int     ToCols)
3660                 { return(*(int *)0); }
3661
3662 #undef resizeterm
3663 int     resizeterm(
3664                 int     ToLines, 
3665                 int     ToCols)
3666                 { return(*(int *)0); }
3667
3668 /* ./trace/trace_xnames.c */
3669
3670 #undef _nc_trace_xnames
3671 void    _nc_trace_xnames(
3672                 TERMTYPE *tp)
3673                 { /* void */ }
3674
3675 /* ./tinfo/use_screen.c */
3676
3677 #undef use_screen
3678 int     use_screen(
3679                 SCREEN  *screen, 
3680                 NCURSES_SCREEN_CB func, 
3681                 void    *data)
3682                 { return(*(int *)0); }
3683
3684 /* ./base/use_window.c */
3685
3686 #undef use_window
3687 int     use_window(
3688                 WINDOW  *win, 
3689                 NCURSES_WINDOW_CB func, 
3690                 void    *data)
3691                 { return(*(int *)0); }
3692
3693 /* ./base/wresize.c */
3694
3695 #undef wresize
3696 int     wresize(
3697                 WINDOW  *win, 
3698                 int     ToLines, 
3699                 int     ToCols)
3700                 { return(*(int *)0); }
3701
3702 /* ./tinfo/access.c */
3703
3704 #undef _nc_rootname
3705 char    *_nc_rootname(
3706                 char    *path)
3707                 { return(*(char **)0); }
3708
3709 #undef _nc_is_abs_path
3710 NCURSES_BOOL _nc_is_abs_path(
3711                 const char *path)
3712                 { return(*(NCURSES_BOOL *)0); }
3713
3714 #undef _nc_pathlast
3715 unsigned _nc_pathlast(
3716                 const char *path)
3717                 { return(*(unsigned *)0); }
3718
3719 #undef _nc_basename
3720 char    *_nc_basename(
3721                 char    *path)
3722                 { return(*(char **)0); }
3723
3724 #undef _nc_access
3725 int     _nc_access(
3726                 const char *path, 
3727                 int     mode)
3728                 { return(*(int *)0); }
3729
3730 #undef _nc_is_dir_path
3731 NCURSES_BOOL _nc_is_dir_path(
3732                 const char *path)
3733                 { return(*(NCURSES_BOOL *)0); }
3734
3735 #undef _nc_is_file_path
3736 NCURSES_BOOL _nc_is_file_path(
3737                 const char *path)
3738                 { return(*(NCURSES_BOOL *)0); }
3739
3740 #undef _nc_env_access
3741 int     _nc_env_access(void)
3742                 { return(*(int *)0); }
3743
3744 /* ./tinfo/add_tries.c */
3745
3746 #undef _nc_add_to_try
3747 int     _nc_add_to_try(
3748                 TRIES   **tree, 
3749                 const char *str, 
3750                 unsigned code)
3751                 { return(*(int *)0); }
3752
3753 /* ./tinfo/alloc_ttype.c */
3754
3755 #undef _nc_align_termtype
3756 void    _nc_align_termtype(
3757                 TERMTYPE2 *to, 
3758                 TERMTYPE2 *from)
3759                 { /* void */ }
3760
3761 #undef _nc_copy_termtype
3762 void    _nc_copy_termtype(
3763                 TERMTYPE *dst, 
3764                 const TERMTYPE *src)
3765                 { /* void */ }
3766
3767 #undef _nc_copy_termtype2
3768 void    _nc_copy_termtype2(
3769                 TERMTYPE2 *dst, 
3770                 const TERMTYPE2 *src)
3771                 { /* void */ }
3772
3773 #undef _nc_export_termtype2
3774 void    _nc_export_termtype2(
3775                 TERMTYPE *dst, 
3776                 const TERMTYPE2 *src)
3777                 { /* void */ }
3778
3779 /* ./codes.c */
3780
3781 #undef _nc_boolcodes
3782 const char *const *_nc_boolcodes(void)
3783                 { return(*(const char **)0); }
3784
3785 #undef _nc_numcodes
3786 const char *const *_nc_numcodes(void)
3787                 { return(*(const char **)0); }
3788
3789 #undef _nc_strcodes
3790 const char *const *_nc_strcodes(void)
3791                 { return(*(const char **)0); }
3792
3793 /* ./comp_captab.c */
3794
3795 #undef _nc_get_table
3796 const struct name_table_entry *_nc_get_table(
3797                 NCURSES_BOOL termcap)
3798                 { return(*(const struct name_table_entry **)0); }
3799
3800 #undef _nc_get_hash_table
3801 const HashValue *_nc_get_hash_table(
3802                 NCURSES_BOOL termcap)
3803                 { return(*(const HashValue **)0); }
3804
3805 #undef _nc_get_alias_table
3806 const struct alias *_nc_get_alias_table(
3807                 NCURSES_BOOL termcap)
3808                 { return(*(const struct alias **)0); }
3809
3810 #undef _nc_get_hash_info
3811 const HashData *_nc_get_hash_info(
3812                 NCURSES_BOOL termcap)
3813                 { return(*(const HashData **)0); }
3814
3815 /* ./tinfo/comp_error.c */
3816
3817 #undef _nc_suppress_warnings
3818 NCURSES_BOOL _nc_suppress_warnings;
3819 #undef _nc_curr_line
3820 int     _nc_curr_line;
3821 #undef _nc_curr_col
3822 int     _nc_curr_col;
3823
3824 #undef _nc_get_source
3825 const char *_nc_get_source(void)
3826                 { return(*(const char **)0); }
3827
3828 #undef _nc_set_source
3829 void    _nc_set_source(
3830                 const char *const name)
3831                 { /* void */ }
3832
3833 #undef _nc_set_type
3834 void    _nc_set_type(
3835                 const char *const name)
3836                 { /* void */ }
3837
3838 #undef _nc_get_type
3839 void    _nc_get_type(
3840                 char    *name)
3841                 { /* void */ }
3842
3843 #undef _nc_warning
3844 void    _nc_warning(
3845                 const char *const fmt, 
3846                 ...)
3847                 { /* void */ }
3848
3849 #undef _nc_err_abort
3850 void    _nc_err_abort(
3851                 const char *const fmt, 
3852                 ...)
3853                 { /* void */ }
3854
3855 #undef _nc_syserr_abort
3856 void    _nc_syserr_abort(
3857                 const char *const fmt, 
3858                 ...)
3859                 { /* void */ }
3860
3861 /* ./tinfo/comp_hash.c */
3862
3863 #undef _nc_find_entry
3864 struct name_table_entry const *_nc_find_entry(
3865                 const char *string, 
3866                 const HashValue *hash_table)
3867                 { return(*(struct name_table_entry const **)0); }
3868
3869 #undef _nc_find_type_entry
3870 struct name_table_entry const *_nc_find_type_entry(
3871                 const char *string, 
3872                 int     type, 
3873                 NCURSES_BOOL termcap)
3874                 { return(*(struct name_table_entry const **)0); }
3875
3876 #undef _nc_find_user_entry
3877 struct user_table_entry const *_nc_find_user_entry(
3878                 const char *string)
3879                 { return(*(struct user_table_entry const **)0); }
3880
3881 /* ./comp_userdefs.c */
3882
3883 #undef _nc_get_userdefs_table
3884 const struct user_table_entry *_nc_get_userdefs_table(void)
3885                 { return(*(const struct user_table_entry **)0); }
3886
3887 #undef _nc_get_hash_user
3888 const HashData *_nc_get_hash_user(void)
3889                 { return(*(const HashData **)0); }
3890
3891 /* ./tinfo/db_iterator.c */
3892
3893 #undef _nc_tic_dir
3894 const char *_nc_tic_dir(
3895                 const char *path)
3896                 { return(*(const char **)0); }
3897
3898 #undef _nc_keep_tic_dir
3899 void    _nc_keep_tic_dir(
3900                 const char *path)
3901                 { /* void */ }
3902
3903 #undef _nc_last_db
3904 void    _nc_last_db(void)
3905                 { /* void */ }
3906
3907 #undef _nc_next_db
3908 const char *_nc_next_db(
3909                 DBDIRS  *state, 
3910                 int     *offset)
3911                 { return(*(const char **)0); }
3912
3913 #undef _nc_first_db
3914 void    _nc_first_db(
3915                 DBDIRS  *state, 
3916                 int     *offset)
3917                 { /* void */ }
3918
3919 /* ./tinfo/doalloc.c */
3920
3921 #undef _nc_doalloc
3922 void    *_nc_doalloc(
3923                 void    *oldp, 
3924                 size_t  amount)
3925                 { return(*(void **)0); }
3926
3927 /* ./tinfo/entries.c */
3928
3929 #undef _nc_head
3930 ENTRY   *_nc_head;
3931 #undef _nc_tail
3932 ENTRY   *_nc_tail;
3933
3934 #undef _nc_free_entry
3935 void    _nc_free_entry(
3936                 ENTRY   *headp, 
3937                 TERMTYPE2 *tterm)
3938                 { /* void */ }
3939
3940 #undef _nc_free_entries
3941 void    _nc_free_entries(
3942                 ENTRY   *headp)
3943                 { /* void */ }
3944
3945 #undef _nc_leaks_tinfo
3946 void    _nc_leaks_tinfo(void)
3947                 { /* void */ }
3948
3949 #undef exit_terminfo
3950 void    exit_terminfo(
3951                 int     code)
3952                 { /* void */ }
3953
3954 /* ./fallback.c */
3955
3956 #undef _nc_fallback2
3957 const TERMTYPE2 *_nc_fallback2(
3958                 const char *name)
3959                 { return(*(const TERMTYPE2 **)0); }
3960
3961 #undef _nc_fallback
3962 const TERMTYPE *_nc_fallback(
3963                 const char *name)
3964                 { return(*(const TERMTYPE **)0); }
3965
3966 /* ./tinfo/free_ttype.c */
3967
3968 #undef _nc_free_termtype
3969 void    _nc_free_termtype(
3970                 TERMTYPE *ptr)
3971                 { /* void */ }
3972
3973 #undef _nc_free_termtype2
3974 void    _nc_free_termtype2(
3975                 TERMTYPE2 *ptr)
3976                 { /* void */ }
3977
3978 #undef _nc_user_definable
3979 NCURSES_BOOL _nc_user_definable;
3980
3981 #undef use_extended_names
3982 int     use_extended_names(
3983                 NCURSES_BOOL flag)
3984                 { return(*(int *)0); }
3985
3986 /* ./tinfo/getenv_num.c */
3987
3988 #undef _nc_getenv_num
3989 int     _nc_getenv_num(
3990                 const char *name)
3991                 { return(*(int *)0); }
3992
3993 #undef _nc_setenv_num
3994 void    _nc_setenv_num(
3995                 const char *name, 
3996                 int     value)
3997                 { /* void */ }
3998
3999 /* ./tinfo/home_terminfo.c */
4000
4001 #undef _nc_home_terminfo
4002 char    *_nc_home_terminfo(void)
4003                 { return(*(char **)0); }
4004
4005 /* ./tinfo/init_keytry.c */
4006
4007 #undef _nc_init_keytry
4008 void    _nc_init_keytry(
4009                 SCREEN  *sp)
4010                 { /* void */ }
4011
4012 /* ./tinfo/lib_acs.c */
4013
4014 #undef _nc_acs_map
4015 chtype  *_nc_acs_map(void)
4016                 { return(*(chtype **)0); }
4017
4018 #undef _nc_init_acs_sp
4019 void    _nc_init_acs_sp(
4020                 SCREEN  *sp)
4021                 { /* void */ }
4022
4023 #undef _nc_init_acs
4024 void    _nc_init_acs(void)
4025                 { /* void */ }
4026
4027 /* ./tinfo/lib_baudrate.c */
4028
4029 struct speed {
4030     int given_speed; 
4031     int actual_speed; 
4032 };
4033
4034 #undef _nc_baudrate
4035 int     _nc_baudrate(
4036                 int     OSpeed)
4037                 { return(*(int *)0); }
4038
4039 #undef _nc_ospeed
4040 int     _nc_ospeed(
4041                 int     BaudRate)
4042                 { return(*(int *)0); }
4043
4044 #undef baudrate_sp
4045 int     baudrate_sp(
4046                 SCREEN  *sp)
4047                 { return(*(int *)0); }
4048
4049 #undef baudrate
4050 int     baudrate(void)
4051                 { return(*(int *)0); }
4052
4053 /* ./tinfo/lib_cur_term.c */
4054
4055 #undef _nc_get_cur_term_sp
4056 TERMINAL *_nc_get_cur_term_sp(
4057                 SCREEN  *sp)
4058                 { return(*(TERMINAL **)0); }
4059
4060 #undef _nc_get_cur_term
4061 TERMINAL *_nc_get_cur_term(void)
4062                 { return(*(TERMINAL **)0); }
4063
4064 #undef _nc_cur_term
4065 TERMINAL *_nc_cur_term(void)
4066                 { return(*(TERMINAL **)0); }
4067
4068 #undef set_curterm_sp
4069 TERMINAL *set_curterm_sp(
4070                 SCREEN  *sp, 
4071                 TERMINAL *termp)
4072                 { return(*(TERMINAL **)0); }
4073
4074 #undef set_curterm
4075 TERMINAL *set_curterm(
4076                 TERMINAL *termp)
4077                 { return(*(TERMINAL **)0); }
4078
4079 #undef del_curterm_sp
4080 int     del_curterm_sp(
4081                 SCREEN  *sp, 
4082                 TERMINAL *termp)
4083                 { return(*(int *)0); }
4084
4085 #undef del_curterm
4086 int     del_curterm(
4087                 TERMINAL *termp)
4088                 { return(*(int *)0); }
4089
4090 /* ./tinfo/lib_data.c */
4091
4092 #undef _nc_stdscr
4093 WINDOW  *_nc_stdscr(void)
4094                 { return(*(WINDOW **)0); }
4095
4096 #undef _nc_curscr
4097 WINDOW  *_nc_curscr(void)
4098                 { return(*(WINDOW **)0); }
4099
4100 #undef _nc_newscr
4101 WINDOW  *_nc_newscr(void)
4102                 { return(*(WINDOW **)0); }
4103
4104 #undef _nc_screen_chain
4105 SCREEN  *_nc_screen_chain;
4106 #undef SP
4107 SCREEN  *SP;
4108 #undef _nc_globals
4109 NCURSES_GLOBALS _nc_globals;
4110 #undef _nc_prescreen
4111 NCURSES_PRESCREEN _nc_prescreen;
4112
4113 #undef _nc_screen_of
4114 SCREEN  *_nc_screen_of(
4115                 WINDOW  *win)
4116                 { return(*(SCREEN **)0); }
4117
4118 #undef _nc_init_pthreads
4119 void    _nc_init_pthreads(void)
4120                 { /* void */ }
4121
4122 #undef _nc_mutex_init
4123 void    _nc_mutex_init(
4124                 pthread_mutex_t *obj)
4125                 { /* void */ }
4126
4127 #undef _nc_mutex_lock
4128 int     _nc_mutex_lock(
4129                 pthread_mutex_t *obj)
4130                 { return(*(int *)0); }
4131
4132 #undef _nc_mutex_trylock
4133 int     _nc_mutex_trylock(
4134                 pthread_mutex_t *obj)
4135                 { return(*(int *)0); }
4136
4137 #undef _nc_mutex_unlock
4138 int     _nc_mutex_unlock(
4139                 pthread_mutex_t *obj)
4140                 { return(*(int *)0); }
4141
4142 /* ./tinfo/lib_has_cap.c */
4143
4144 #undef has_ic_sp
4145 NCURSES_BOOL has_ic_sp(
4146                 SCREEN  *sp)
4147                 { return(*(NCURSES_BOOL *)0); }
4148
4149 #undef has_ic
4150 NCURSES_BOOL has_ic(void)
4151                 { return(*(NCURSES_BOOL *)0); }
4152
4153 #undef has_il_sp
4154 NCURSES_BOOL has_il_sp(
4155                 SCREEN  *sp)
4156                 { return(*(NCURSES_BOOL *)0); }
4157
4158 #undef has_il
4159 NCURSES_BOOL has_il(void)
4160                 { return(*(NCURSES_BOOL *)0); }
4161
4162 /* ./tinfo/lib_kernel.c */
4163
4164 #undef erasechar_sp
4165 char    erasechar_sp(
4166                 SCREEN  *sp)
4167                 { return(*(char *)0); }
4168
4169 #undef erasechar
4170 char    erasechar(void)
4171                 { return(*(char *)0); }
4172
4173 #undef killchar_sp
4174 char    killchar_sp(
4175                 SCREEN  *sp)
4176                 { return(*(char *)0); }
4177
4178 #undef killchar
4179 char    killchar(void)
4180                 { return(*(char *)0); }
4181
4182 #undef flushinp_sp
4183 int     flushinp_sp(
4184                 SCREEN  *sp)
4185                 { return(*(int *)0); }
4186
4187 #undef flushinp
4188 int     flushinp(void)
4189                 { return(*(int *)0); }
4190
4191 /* ./lib_keyname.c */
4192
4193 struct kn { short offset; int code; };
4194
4195 #undef keyname_sp
4196 const char *keyname_sp(
4197                 SCREEN  *sp, 
4198                 int     c)
4199                 { return(*(const char **)0); }
4200
4201 #undef keyname
4202 const char *keyname(
4203                 int     c)
4204                 { return(*(const char **)0); }
4205
4206 /* ./tinfo/lib_longname.c */
4207
4208 #undef longname_sp
4209 char    *longname_sp(
4210                 SCREEN  *sp)
4211                 { return(*(char **)0); }
4212
4213 #undef longname
4214 char    *longname(void)
4215                 { return(*(char **)0); }
4216
4217 /* ./tinfo/lib_napms.c */
4218
4219 #undef napms_sp
4220 int     napms_sp(
4221                 SCREEN  *sp, 
4222                 int     ms)
4223                 { return(*(int *)0); }
4224
4225 #undef napms
4226 int     napms(
4227                 int     ms)
4228                 { return(*(int *)0); }
4229
4230 /* ./tinfo/lib_options.c */
4231
4232 #undef idlok
4233 int     idlok(
4234                 WINDOW  *win, 
4235                 NCURSES_BOOL flag)
4236                 { return(*(int *)0); }
4237
4238 #undef idcok
4239 void    idcok(
4240                 WINDOW  *win, 
4241                 NCURSES_BOOL flag)
4242                 { /* void */ }
4243
4244 #undef halfdelay_sp
4245 int     halfdelay_sp(
4246                 SCREEN  *sp, 
4247                 int     t)
4248                 { return(*(int *)0); }
4249
4250 #undef halfdelay
4251 int     halfdelay(
4252                 int     t)
4253                 { return(*(int *)0); }
4254
4255 #undef nodelay
4256 int     nodelay(
4257                 WINDOW  *win, 
4258                 NCURSES_BOOL flag)
4259                 { return(*(int *)0); }
4260
4261 #undef notimeout
4262 int     notimeout(
4263                 WINDOW  *win, 
4264                 NCURSES_BOOL f)
4265                 { return(*(int *)0); }
4266
4267 #undef wtimeout
4268 void    wtimeout(
4269                 WINDOW  *win, 
4270                 int     delay)
4271                 { /* void */ }
4272
4273 #undef keypad
4274 int     keypad(
4275                 WINDOW  *win, 
4276                 NCURSES_BOOL flag)
4277                 { return(*(int *)0); }
4278
4279 #undef meta
4280 int     meta(
4281                 WINDOW  *win, 
4282                 NCURSES_BOOL flag)
4283                 { return(*(int *)0); }
4284
4285 #undef curs_set_sp
4286 int     curs_set_sp(
4287                 SCREEN  *sp, 
4288                 int     vis)
4289                 { return(*(int *)0); }
4290
4291 #undef curs_set
4292 int     curs_set(
4293                 int     vis)
4294                 { return(*(int *)0); }
4295
4296 #undef typeahead_sp
4297 int     typeahead_sp(
4298                 SCREEN  *sp, 
4299                 int     fd)
4300                 { return(*(int *)0); }
4301
4302 #undef typeahead
4303 int     typeahead(
4304                 int     fd)
4305                 { return(*(int *)0); }
4306
4307 #undef has_key_sp
4308 int     has_key_sp(
4309                 SCREEN  *sp, 
4310                 int     keycode)
4311                 { return(*(int *)0); }
4312
4313 #undef has_key
4314 int     has_key(
4315                 int     keycode)
4316                 { return(*(int *)0); }
4317
4318 #undef _nc_putp_flush_sp
4319 int     _nc_putp_flush_sp(
4320                 SCREEN  *sp, 
4321                 const char *name, 
4322                 const char *value)
4323                 { return(*(int *)0); }
4324
4325 #undef _nc_keypad
4326 int     _nc_keypad(
4327                 SCREEN  *sp, 
4328                 int     flag)
4329                 { return(*(int *)0); }
4330
4331 /* ./tinfo/lib_raw.c */
4332
4333 #undef raw_sp
4334 int     raw_sp(
4335                 SCREEN  *sp)
4336                 { return(*(int *)0); }
4337
4338 #undef raw
4339 int     raw(void)
4340                 { return(*(int *)0); }
4341
4342 #undef cbreak_sp
4343 int     cbreak_sp(