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