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