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