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