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