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