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