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