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