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