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