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