ee4a5f29cd2c2107b3c1276e679f473961a0dca3
[ncurses.git] / ncurses / llib-lncursest
1 /****************************************************************************
2  * Copyright (c) 2008-2015,2016 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 #undef _nc_varargs
2524 char    *_nc_varargs(
2525                 const char *fmt, 
2526                 va_list ap)
2527                 { return(*(char **)0); }
2528
2529 /* ./base/vsscanf.c */
2530
2531 #undef _nc_vsscanf
2532 void    _nc_vsscanf(void)
2533                 { /* void */ }
2534
2535 /* ./base/lib_freeall.c */
2536
2537 #undef _nc_freeall
2538 void    _nc_freeall(void)
2539                 { /* void */ }
2540
2541 #undef _nc_free_and_exit_sp
2542 void    _nc_free_and_exit_sp(
2543                 SCREEN  *sp, 
2544                 int     code)
2545                 { /* void */ }
2546
2547 #undef _nc_free_and_exit
2548 void    _nc_free_and_exit(
2549                 int     code)
2550                 { /* void */ }
2551
2552 /* ./expanded.c */
2553
2554 #undef _nc_toggle_attr_on
2555 void    _nc_toggle_attr_on(
2556                 attr_t  *S, 
2557                 attr_t  at)
2558                 { /* void */ }
2559
2560 #undef _nc_toggle_attr_off
2561 void    _nc_toggle_attr_off(
2562                 attr_t  *S, 
2563                 attr_t  at)
2564                 { /* void */ }
2565
2566 #undef _nc_DelCharCost_sp
2567 int     _nc_DelCharCost_sp(
2568                 SCREEN  *sp, 
2569                 int     count)
2570                 { return(*(int *)0); }
2571
2572 #undef _nc_InsCharCost_sp
2573 int     _nc_InsCharCost_sp(
2574                 SCREEN  *sp, 
2575                 int     count)
2576                 { return(*(int *)0); }
2577
2578 #undef _nc_UpdateAttrs_sp
2579 void    _nc_UpdateAttrs_sp(
2580                 SCREEN  *sp, 
2581                 chtype  c)
2582                 { /* void */ }
2583
2584 #undef _nc_DelCharCost
2585 int     _nc_DelCharCost(
2586                 int     count)
2587                 { return(*(int *)0); }
2588
2589 #undef _nc_InsCharCost
2590 int     _nc_InsCharCost(
2591                 int     count)
2592                 { return(*(int *)0); }
2593
2594 #undef _nc_UpdateAttrs
2595 void    _nc_UpdateAttrs(
2596                 chtype  c)
2597                 { /* void */ }
2598
2599 /* ./base/legacy_coding.c */
2600
2601 #undef use_legacy_coding_sp
2602 int     use_legacy_coding_sp(
2603                 SCREEN  *sp, 
2604                 int     level)
2605                 { return(*(int *)0); }
2606
2607 #undef use_legacy_coding
2608 int     use_legacy_coding(
2609                 int     level)
2610                 { return(*(int *)0); }
2611
2612 /* ./base/lib_dft_fgbg.c */
2613
2614 #undef use_default_colors_sp
2615 int     use_default_colors_sp(
2616                 SCREEN  *sp)
2617                 { return(*(int *)0); }
2618
2619 #undef use_default_colors
2620 int     use_default_colors(void)
2621                 { return(*(int *)0); }
2622
2623 #undef assume_default_colors_sp
2624 int     assume_default_colors_sp(
2625                 SCREEN  *sp, 
2626                 int     fg, 
2627                 int     bg)
2628                 { return(*(int *)0); }
2629
2630 #undef assume_default_colors
2631 int     assume_default_colors(
2632                 int     fg, 
2633                 int     bg)
2634                 { return(*(int *)0); }
2635
2636 /* ./tinfo/lib_print.c */
2637
2638 #undef mcprint_sp
2639 int     mcprint_sp(
2640                 SCREEN  *sp, 
2641                 char    *data, 
2642                 int     len)
2643                 { return(*(int *)0); }
2644
2645 #undef mcprint
2646 int     mcprint(
2647                 char    *data, 
2648                 int     len)
2649                 { return(*(int *)0); }
2650
2651 /* ./base/resizeterm.c */
2652
2653 #undef is_term_resized_sp
2654 NCURSES_BOOL is_term_resized_sp(
2655                 SCREEN  *sp, 
2656                 int     ToLines, 
2657                 int     ToCols)
2658                 { return(*(NCURSES_BOOL *)0); }
2659
2660 #undef is_term_resized
2661 NCURSES_BOOL is_term_resized(
2662                 int     ToLines, 
2663                 int     ToCols)
2664                 { return(*(NCURSES_BOOL *)0); }
2665
2666 #undef resize_term_sp
2667 int     resize_term_sp(
2668                 SCREEN  *sp, 
2669                 int     ToLines, 
2670                 int     ToCols)
2671                 { return(*(int *)0); }
2672
2673 #undef resize_term
2674 int     resize_term(
2675                 int     ToLines, 
2676                 int     ToCols)
2677                 { return(*(int *)0); }
2678
2679 #undef resizeterm_sp
2680 int     resizeterm_sp(
2681                 SCREEN  *sp, 
2682                 int     ToLines, 
2683                 int     ToCols)
2684                 { return(*(int *)0); }
2685
2686 #undef resizeterm
2687 int     resizeterm(
2688                 int     ToLines, 
2689                 int     ToCols)
2690                 { return(*(int *)0); }
2691
2692 /* ./trace/trace_xnames.c */
2693
2694 #undef _nc_trace_xnames
2695 void    _nc_trace_xnames(
2696                 TERMTYPE *tp)
2697                 { /* void */ }
2698
2699 /* ./tinfo/use_screen.c */
2700
2701 #undef use_screen
2702 int     use_screen(
2703                 SCREEN  *screen, 
2704                 NCURSES_SCREEN_CB func, 
2705                 void    *data)
2706                 { return(*(int *)0); }
2707
2708 /* ./base/use_window.c */
2709
2710 #undef use_window
2711 int     use_window(
2712                 WINDOW  *win, 
2713                 NCURSES_WINDOW_CB func, 
2714                 void    *data)
2715                 { return(*(int *)0); }
2716
2717 /* ./base/wresize.c */
2718
2719 #undef wresize
2720 int     wresize(
2721                 WINDOW  *win, 
2722                 int     ToLines, 
2723                 int     ToCols)
2724                 { return(*(int *)0); }
2725
2726 /* ./tinfo/access.c */
2727
2728 #undef _nc_rootname
2729 char    *_nc_rootname(
2730                 char    *path)
2731                 { return(*(char **)0); }
2732
2733 #undef _nc_is_abs_path
2734 NCURSES_BOOL _nc_is_abs_path(
2735                 const char *path)
2736                 { return(*(NCURSES_BOOL *)0); }
2737
2738 #undef _nc_pathlast
2739 unsigned _nc_pathlast(
2740                 const char *path)
2741                 { return(*(unsigned *)0); }
2742
2743 #undef _nc_basename
2744 char    *_nc_basename(
2745                 char    *path)
2746                 { return(*(char **)0); }
2747
2748 #undef _nc_access
2749 int     _nc_access(
2750                 const char *path, 
2751                 int     mode)
2752                 { return(*(int *)0); }
2753
2754 #undef _nc_is_dir_path
2755 NCURSES_BOOL _nc_is_dir_path(
2756                 const char *path)
2757                 { return(*(NCURSES_BOOL *)0); }
2758
2759 #undef _nc_is_file_path
2760 NCURSES_BOOL _nc_is_file_path(
2761                 const char *path)
2762                 { return(*(NCURSES_BOOL *)0); }
2763
2764 #undef _nc_env_access
2765 int     _nc_env_access(void)
2766                 { return(*(int *)0); }
2767
2768 /* ./tinfo/add_tries.c */
2769
2770 #undef _nc_add_to_try
2771 int     _nc_add_to_try(
2772                 TRIES   **tree, 
2773                 const char *str, 
2774                 unsigned code)
2775                 { return(*(int *)0); }
2776
2777 /* ./tinfo/alloc_ttype.c */
2778
2779 #undef _nc_align_termtype
2780 void    _nc_align_termtype(
2781                 TERMTYPE *to, 
2782                 TERMTYPE *from)
2783                 { /* void */ }
2784
2785 #undef _nc_copy_termtype
2786 void    _nc_copy_termtype(
2787                 TERMTYPE *dst, 
2788                 const TERMTYPE *src)
2789                 { /* void */ }
2790
2791 /* ./codes.c */
2792
2793 #undef _nc_boolcodes
2794 const char *const *_nc_boolcodes(void)
2795                 { return(*(const char **)0); }
2796
2797 #undef _nc_numcodes
2798 const char *const *_nc_numcodes(void)
2799                 { return(*(const char **)0); }
2800
2801 #undef _nc_strcodes
2802 const char *const *_nc_strcodes(void)
2803                 { return(*(const char **)0); }
2804
2805 /* ./comp_captab.c */
2806
2807 #undef _nc_get_table
2808 const struct name_table_entry *_nc_get_table(
2809                 NCURSES_BOOL termcap)
2810                 { return(*(const struct name_table_entry **)0); }
2811
2812 #undef _nc_get_hash_table
2813 const HashValue *_nc_get_hash_table(
2814                 NCURSES_BOOL termcap)
2815                 { return(*(const HashValue **)0); }
2816
2817 #undef _nc_get_alias_table
2818 const struct alias *_nc_get_alias_table(
2819                 NCURSES_BOOL termcap)
2820                 { return(*(const struct alias **)0); }
2821
2822 #undef _nc_get_hash_info
2823 const HashData *_nc_get_hash_info(
2824                 NCURSES_BOOL termcap)
2825                 { return(*(const HashData **)0); }
2826
2827 /* ./tinfo/comp_error.c */
2828
2829 #undef _nc_suppress_warnings
2830 NCURSES_BOOL _nc_suppress_warnings;
2831 #undef _nc_curr_line
2832 int     _nc_curr_line;
2833 #undef _nc_curr_col
2834 int     _nc_curr_col;
2835
2836 #undef _nc_get_source
2837 const char *_nc_get_source(void)
2838                 { return(*(const char **)0); }
2839
2840 #undef _nc_set_source
2841 void    _nc_set_source(
2842                 const char *const name)
2843                 { /* void */ }
2844
2845 #undef _nc_set_type
2846 void    _nc_set_type(
2847                 const char *const name)
2848                 { /* void */ }
2849
2850 #undef _nc_get_type
2851 void    _nc_get_type(
2852                 char    *name)
2853                 { /* void */ }
2854
2855 #undef _nc_warning
2856 void    _nc_warning(
2857                 const char *const fmt, 
2858                 ...)
2859                 { /* void */ }
2860
2861 #undef _nc_err_abort
2862 void    _nc_err_abort(
2863                 const char *const fmt, 
2864                 ...)
2865                 { /* void */ }
2866
2867 #undef _nc_syserr_abort
2868 void    _nc_syserr_abort(
2869                 const char *const fmt, 
2870                 ...)
2871                 { /* void */ }
2872
2873 /* ./tinfo/comp_hash.c */
2874
2875 #undef _nc_find_entry
2876 struct name_table_entry const *_nc_find_entry(
2877                 const char *string, 
2878                 const HashValue *hash_table)
2879                 { return(*(struct name_table_entry const **)0); }
2880
2881 #undef _nc_find_type_entry
2882 struct name_table_entry const *_nc_find_type_entry(
2883                 const char *string, 
2884                 int     type, 
2885                 NCURSES_BOOL termcap)
2886                 { return(*(struct name_table_entry const **)0); }
2887
2888 /* ./tinfo/db_iterator.c */
2889
2890 #undef _nc_tic_dir
2891 const char *_nc_tic_dir(
2892                 const char *path)
2893                 { return(*(const char **)0); }
2894
2895 #undef _nc_keep_tic_dir
2896 void    _nc_keep_tic_dir(
2897                 const char *path)
2898                 { /* void */ }
2899
2900 #undef _nc_last_db
2901 void    _nc_last_db(void)
2902                 { /* void */ }
2903
2904 #undef _nc_next_db
2905 const char *_nc_next_db(
2906                 DBDIRS  *state, 
2907                 int     *offset)
2908                 { return(*(const char **)0); }
2909
2910 #undef _nc_first_db
2911 void    _nc_first_db(
2912                 DBDIRS  *state, 
2913                 int     *offset)
2914                 { /* void */ }
2915
2916 /* ./tinfo/doalloc.c */
2917
2918 #undef _nc_doalloc
2919 void    *_nc_doalloc(
2920                 void    *oldp, 
2921                 size_t  amount)
2922                 { return(*(void **)0); }
2923
2924 /* ./tinfo/entries.c */
2925
2926 #undef _nc_head
2927 ENTRY   *_nc_head;
2928 #undef _nc_tail
2929 ENTRY   *_nc_tail;
2930
2931 #undef _nc_free_entry
2932 void    _nc_free_entry(
2933                 ENTRY   *headp, 
2934                 TERMTYPE *tterm)
2935                 { /* void */ }
2936
2937 #undef _nc_free_entries
2938 void    _nc_free_entries(
2939                 ENTRY   *headp)
2940                 { /* void */ }
2941
2942 #undef _nc_delink_entry
2943 ENTRY   *_nc_delink_entry(
2944                 ENTRY   *headp, 
2945                 TERMTYPE *tterm)
2946                 { return(*(ENTRY **)0); }
2947
2948 #undef _nc_leaks_tinfo
2949 void    _nc_leaks_tinfo(void)
2950                 { /* void */ }
2951
2952 /* ./fallback.c */
2953
2954 #undef _nc_fallback
2955 const TERMTYPE *_nc_fallback(
2956                 const char *name)
2957                 { return(*(const TERMTYPE **)0); }
2958
2959 /* ./tinfo/free_ttype.c */
2960
2961 #undef _nc_free_termtype
2962 void    _nc_free_termtype(
2963                 TERMTYPE *ptr)
2964                 { /* void */ }
2965
2966 #undef _nc_user_definable
2967 NCURSES_BOOL _nc_user_definable;
2968
2969 #undef use_extended_names
2970 int     use_extended_names(
2971                 NCURSES_BOOL flag)
2972                 { return(*(int *)0); }
2973
2974 /* ./tinfo/getenv_num.c */
2975
2976 #undef _nc_getenv_num
2977 int     _nc_getenv_num(
2978                 const char *name)
2979                 { return(*(int *)0); }
2980
2981 #undef _nc_setenv_num
2982 void    _nc_setenv_num(
2983                 const char *name, 
2984                 int     value)
2985                 { /* void */ }
2986
2987 /* ./tinfo/home_terminfo.c */
2988
2989 #undef _nc_home_terminfo
2990 char    *_nc_home_terminfo(void)
2991                 { return(*(char **)0); }
2992
2993 /* ./tinfo/init_keytry.c */
2994
2995 #undef _nc_init_keytry
2996 void    _nc_init_keytry(
2997                 SCREEN  *sp)
2998                 { /* void */ }
2999
3000 /* ./tinfo/lib_acs.c */
3001
3002 #undef _nc_acs_map
3003 chtype  *_nc_acs_map(void)
3004                 { return(*(chtype **)0); }
3005
3006 #undef _nc_init_acs_sp
3007 void    _nc_init_acs_sp(
3008                 SCREEN  *sp)
3009                 { /* void */ }
3010
3011 #undef _nc_init_acs
3012 void    _nc_init_acs(void)
3013                 { /* void */ }
3014
3015 /* ./tinfo/lib_baudrate.c */
3016
3017 struct speed {
3018     int given_speed; 
3019     int actual_speed; 
3020 };
3021
3022 #undef _nc_baudrate
3023 int     _nc_baudrate(
3024                 int     OSpeed)
3025                 { return(*(int *)0); }
3026
3027 #undef _nc_ospeed
3028 int     _nc_ospeed(
3029                 int     BaudRate)
3030                 { return(*(int *)0); }
3031
3032 #undef baudrate_sp
3033 int     baudrate_sp(
3034                 SCREEN  *sp)
3035                 { return(*(int *)0); }
3036
3037 #undef baudrate
3038 int     baudrate(void)
3039                 { return(*(int *)0); }
3040
3041 /* ./tinfo/lib_cur_term.c */
3042
3043 #undef _nc_get_cur_term_sp
3044 TERMINAL *_nc_get_cur_term_sp(
3045                 SCREEN  *sp)
3046                 { return(*(TERMINAL **)0); }
3047
3048 #undef _nc_get_cur_term
3049 TERMINAL *_nc_get_cur_term(void)
3050                 { return(*(TERMINAL **)0); }
3051
3052 #undef _nc_cur_term
3053 TERMINAL *_nc_cur_term(void)
3054                 { return(*(TERMINAL **)0); }
3055
3056 #undef set_curterm_sp
3057 TERMINAL *set_curterm_sp(
3058                 SCREEN  *sp, 
3059                 TERMINAL *termp)
3060                 { return(*(TERMINAL **)0); }
3061
3062 #undef set_curterm
3063 TERMINAL *set_curterm(
3064                 TERMINAL *termp)
3065                 { return(*(TERMINAL **)0); }
3066
3067 #undef del_curterm_sp
3068 int     del_curterm_sp(
3069                 SCREEN  *sp, 
3070                 TERMINAL *termp)
3071                 { return(*(int *)0); }
3072
3073 #undef del_curterm
3074 int     del_curterm(
3075                 TERMINAL *termp)
3076                 { return(*(int *)0); }
3077
3078 /* ./tinfo/lib_data.c */
3079
3080 #undef _nc_stdscr
3081 WINDOW  *_nc_stdscr(void)
3082                 { return(*(WINDOW **)0); }
3083
3084 #undef _nc_curscr
3085 WINDOW  *_nc_curscr(void)
3086                 { return(*(WINDOW **)0); }
3087
3088 #undef _nc_newscr
3089 WINDOW  *_nc_newscr(void)
3090                 { return(*(WINDOW **)0); }
3091
3092 #undef _nc_screen_chain
3093 SCREEN  *_nc_screen_chain;
3094 #undef SP
3095 SCREEN  *SP;
3096 #undef _nc_globals
3097 NCURSES_GLOBALS _nc_globals;
3098 #undef _nc_prescreen
3099 NCURSES_PRESCREEN _nc_prescreen;
3100
3101 #undef _nc_screen_of
3102 SCREEN  *_nc_screen_of(
3103                 WINDOW  *win)
3104                 { return(*(SCREEN **)0); }
3105
3106 #undef _nc_init_pthreads
3107 void    _nc_init_pthreads(void)
3108                 { /* void */ }
3109
3110 #undef _nc_mutex_init
3111 void    _nc_mutex_init(
3112                 pthread_mutex_t *obj)
3113                 { /* void */ }
3114
3115 #undef _nc_mutex_lock
3116 int     _nc_mutex_lock(
3117                 pthread_mutex_t *obj)
3118                 { return(*(int *)0); }
3119
3120 #undef _nc_mutex_trylock
3121 int     _nc_mutex_trylock(
3122                 pthread_mutex_t *obj)
3123                 { return(*(int *)0); }
3124
3125 #undef _nc_mutex_unlock
3126 int     _nc_mutex_unlock(
3127                 pthread_mutex_t *obj)
3128                 { return(*(int *)0); }
3129
3130 /* ./tinfo/lib_has_cap.c */
3131
3132 #undef has_ic_sp
3133 NCURSES_BOOL has_ic_sp(
3134                 SCREEN  *sp)
3135                 { return(*(NCURSES_BOOL *)0); }
3136
3137 #undef has_ic
3138 NCURSES_BOOL has_ic(void)
3139                 { return(*(NCURSES_BOOL *)0); }
3140
3141 #undef has_il_sp
3142 NCURSES_BOOL has_il_sp(
3143                 SCREEN  *sp)
3144                 { return(*(NCURSES_BOOL *)0); }
3145
3146 #undef has_il
3147 NCURSES_BOOL has_il(void)
3148                 { return(*(NCURSES_BOOL *)0); }
3149
3150 /* ./tinfo/lib_kernel.c */
3151
3152 #undef erasechar_sp
3153 char    erasechar_sp(
3154                 SCREEN  *sp)
3155                 { return(*(char *)0); }
3156
3157 #undef erasechar
3158 char    erasechar(void)
3159                 { return(*(char *)0); }
3160
3161 #undef killchar_sp
3162 char    killchar_sp(
3163                 SCREEN  *sp)
3164                 { return(*(char *)0); }
3165
3166 #undef killchar
3167 char    killchar(void)
3168                 { return(*(char *)0); }
3169
3170 #undef flushinp_sp
3171 int     flushinp_sp(
3172                 SCREEN  *sp)
3173                 { return(*(int *)0); }
3174
3175 #undef flushinp
3176 int     flushinp(void)
3177                 { return(*(int *)0); }
3178
3179 /* ./lib_keyname.c */
3180
3181 struct kn { short offset; int code; };
3182
3183 #undef keyname_sp
3184 const char *keyname_sp(
3185                 SCREEN  *sp, 
3186                 int     c)
3187                 { return(*(const char **)0); }
3188
3189 #undef keyname
3190 const char *keyname(
3191                 int     c)
3192                 { return(*(const char **)0); }
3193
3194 /* ./tinfo/lib_longname.c */
3195
3196 #undef longname_sp
3197 char    *longname_sp(
3198                 SCREEN  *sp)
3199                 { return(*(char **)0); }
3200
3201 #undef longname
3202 char    *longname(void)
3203                 { return(*(char **)0); }
3204
3205 /* ./tinfo/lib_napms.c */
3206
3207 #undef napms_sp
3208 int     napms_sp(
3209                 SCREEN  *sp, 
3210                 int     ms)
3211                 { return(*(int *)0); }
3212
3213 #undef napms
3214 int     napms(
3215                 int     ms)
3216                 { return(*(int *)0); }
3217
3218 /* ./tinfo/lib_options.c */
3219
3220 #undef idlok
3221 int     idlok(
3222                 WINDOW  *win, 
3223                 NCURSES_BOOL flag)
3224                 { return(*(int *)0); }
3225
3226 #undef idcok
3227 void    idcok(
3228                 WINDOW  *win, 
3229                 NCURSES_BOOL flag)
3230                 { /* void */ }
3231
3232 #undef halfdelay_sp
3233 int     halfdelay_sp(
3234                 SCREEN  *sp, 
3235                 int     t)
3236                 { return(*(int *)0); }
3237
3238 #undef halfdelay
3239 int     halfdelay(
3240                 int     t)
3241                 { return(*(int *)0); }
3242
3243 #undef nodelay
3244 int     nodelay(
3245                 WINDOW  *win, 
3246                 NCURSES_BOOL flag)
3247                 { return(*(int *)0); }
3248
3249 #undef notimeout
3250 int     notimeout(
3251                 WINDOW  *win, 
3252                 NCURSES_BOOL f)
3253                 { return(*(int *)0); }
3254
3255 #undef wtimeout
3256 void    wtimeout(
3257                 WINDOW  *win, 
3258                 int     delay)
3259                 { /* void */ }
3260
3261 #undef keypad
3262 int     keypad(
3263                 WINDOW  *win, 
3264                 NCURSES_BOOL flag)
3265                 { return(*(int *)0); }
3266
3267 #undef meta
3268 int     meta(
3269                 WINDOW  *win, 
3270                 NCURSES_BOOL flag)
3271                 { return(*(int *)0); }
3272
3273 #undef curs_set_sp
3274 int     curs_set_sp(
3275                 SCREEN  *sp, 
3276                 int     vis)
3277                 { return(*(int *)0); }
3278
3279 #undef curs_set
3280 int     curs_set(
3281                 int     vis)
3282                 { return(*(int *)0); }
3283
3284 #undef typeahead_sp
3285 int     typeahead_sp(
3286                 SCREEN  *sp, 
3287                 int     fd)
3288                 { return(*(int *)0); }
3289
3290 #undef typeahead
3291 int     typeahead(
3292                 int     fd)
3293                 { return(*(int *)0); }
3294
3295 #undef has_key_sp
3296 int     has_key_sp(
3297                 SCREEN  *sp, 
3298                 int     keycode)
3299                 { return(*(int *)0); }
3300
3301 #undef has_key
3302 int     has_key(
3303                 int     keycode)
3304                 { return(*(int *)0); }
3305
3306 #undef _nc_putp_flush_sp
3307 int     _nc_putp_flush_sp(
3308                 SCREEN  *sp, 
3309                 const char *name, 
3310                 const char *value)
3311                 { return(*(int *)0); }
3312
3313 #undef _nc_keypad
3314 int     _nc_keypad(
3315                 SCREEN  *sp, 
3316                 int     flag)
3317                 { return(*(int *)0); }
3318
3319 /* ./tinfo/lib_raw.c */
3320
3321 #undef raw_sp
3322 int     raw_sp(
3323                 SCREEN  *sp)
3324                 { return(*(int *)0); }
3325
3326 #undef raw
3327 int     raw(void)
3328                 { return(*(int *)0); }
3329
3330 #undef cbreak_sp
3331 int     cbreak_sp(
3332                 SCREEN  *sp)
3333                 { return(*(int *)0); }
3334
3335 #undef cbreak
3336 int     cbreak(void)
3337                 { return(*(int *)0); }
3338
3339 #undef qiflush_sp
3340 void    qiflush_sp(
3341                 SCREEN  *sp)
3342                 { /* void */ }
3343
3344 #undef qiflush
3345 void    qiflush(void)
3346                 { /* void */ }
3347
3348 #undef noraw_sp
3349 int     noraw_sp(
3350                 SCREEN  *sp)
3351                 { return(*(int *)0); }
3352
3353 #undef noraw
3354 int     noraw(void)
3355                 { return(*(int *)0); }
3356
3357 #undef nocbreak_sp
3358 int     nocbreak_sp(
3359                 SCREEN  *sp)
3360                 { return(*(int *)0); }
3361
3362 #undef nocbreak
3363 int     nocbreak(void)
3364                 { return(*(int *)0); }
3365
3366 #undef noqiflush_sp
3367 void    noqiflush_sp(
3368                 SCREEN  *sp)
3369                 { /* void */ }
3370
3371 #undef noqiflush
3372 void    noqiflush(void)
3373                 { /* void */ }
3374
3375 #undef intrflush_sp
3376 int     intrflush_sp(
3377                 SCREEN  *sp, 
3378                 WINDOW  *win, 
3379                 NCURSES_BOOL flag)
3380                 { return(*(int *)0); }
3381
3382 #undef intrflush
3383 int     intrflush(
3384                 WINDOW  *win, 
3385                 NCURSES_BOOL flag)
3386                 { return(*(int *)0); }
3387
3388 /* ./tinfo/lib_setup.c */
3389
3390 #undef _nc_ttytype
3391 char    *_nc_ttytype(void)
3392                 { return(*(char **)0); }
3393
3394 #undef _nc_ptr_Lines
3395 int     *_nc_ptr_Lines(
3396                 SCREEN  *sp)
3397                 { return(*(int **)0); }
3398
3399 #undef _nc_LINES
3400 int     _nc_LINES(void)
3401                 { return(*(int *)0); }
3402
3403 #undef _nc_ptr_Cols
3404 int     *_nc_ptr_Cols(
3405                 SCREEN  *sp)
3406                 { return(*(int **)0); }
3407
3408 #undef _nc_COLS
3409 int     _nc_COLS(void)
3410                 { return(*(int *)0); }
3411
3412 #undef _nc_ptr_Tabsize
3413 int     *_nc_ptr_Tabsize(
3414                 SCREEN  *sp)
3415                 { return(*(int **)0); }
3416
3417 #undef _nc_TABSIZE
3418 int     _nc_TABSIZE(void)
3419                 { return(*(int *)0); }
3420
3421 #undef set_tabsize_sp
3422 int     set_tabsize_sp(
3423                 SCREEN  *sp, 
3424                 int     value)
3425                 { return(*(int *)0); }
3426
3427 #undef set_tabsize
3428 int     set_tabsize(
3429                 int     value)
3430                 { return(*(int *)0); }
3431
3432 #undef _nc_handle_sigwinch
3433 int     _nc_handle_sigwinch(
3434                 SCREEN  *sp)
3435                 { return(*(int *)0); }
3436
3437 #undef use_env_sp
3438 void    use_env_sp(
3439                 SCREEN  *sp, 
3440                 NCURSES_BOOL f)
3441                 { /* void */ }
3442
3443 #undef use_tioctl_sp
3444 void    use_tioctl_sp(
3445                 SCREEN  *sp, 
3446                 NCURSES_BOOL f)
3447                 { /* void */ }
3448
3449 #undef use_env
3450 void    use_env(
3451                 NCURSES_BOOL f)
3452                 { /* void */ }
3453
3454 #undef use_tioctl
3455 void    use_tioctl(
3456                 NCURSES_BOOL f)
3457                 { /* void */ }
3458
3459 #undef _nc_get_screensize
3460 void    _nc_get_screensize(
3461                 SCREEN  *sp, 
3462                 int     *linep, 
3463                 int     *colp)
3464                 { /* void */ }
3465
3466 #undef _nc_update_screensize
3467 void    _nc_update_screensize(
3468                 SCREEN  *sp)
3469                 { /* void */ }
3470
3471 #undef _nc_setup_tinfo
3472 int     _nc_setup_tinfo(
3473                 const char *const tn, 
3474                 TERMTYPE *const tp)
3475                 { return(*(int *)0); }
3476
3477 #undef _nc_tinfo_cmdch
3478 void    _nc_tinfo_cmdch(
3479                 TERMINAL *termp, 
3480                 int     proto)
3481                 { /* void */ }
3482
3483 #undef _nc_get_locale
3484 char    *_nc_get_locale(void)
3485                 { return(*(char **)0); }
3486
3487 #undef _nc_unicode_locale
3488 int     _nc_unicode_locale(void)
3489                 { return(*(int *)0); }
3490
3491 #undef _nc_locale_breaks_acs
3492 int     _nc_locale_breaks_acs(
3493                 TERMINAL *termp)
3494                 { return(*(int *)0); }
3495
3496 #undef _nc_setupterm
3497 int     _nc_setupterm(
3498                 const char *tname, 
3499                 int     Filedes, 
3500                 int     *errret, 
3501                 int     reuse)
3502                 { return(*(int *)0); }
3503
3504 #undef new_prescr
3505 SCREEN  *new_prescr(void)
3506                 { return(*(SCREEN **)0); }
3507
3508 #undef setupterm
3509 int     setupterm(
3510                 const char *tname, 
3511                 int     Filedes, 
3512                 int     *errret)
3513                 { return(*(int *)0); }
3514
3515 /* ./tinfo/lib_termcap.c */
3516
3517 #undef UP
3518 char    *UP;
3519 #undef BC
3520 char    *BC;
3521
3522 #undef tgetent_sp
3523 int     tgetent_sp(
3524                 SCREEN  *sp, 
3525                 char    *bufp, 
3526                 const char *name)
3527                 { return(*(int *)0); }
3528
3529 #undef tgetent
3530 int     tgetent(
3531                 char    *bufp, 
3532                 const char *name)
3533                 { return(*(int *)0); }
3534
3535 #undef tgetflag_sp
3536 int     tgetflag_sp(
3537                 SCREEN  *sp, 
3538                 const char *id)
3539                 { return(*(int *)0); }
3540
3541 #undef tgetflag
3542 int     tgetflag(
3543                 const char *id)
3544                 { return(*(int *)0); }
3545
3546 #undef tgetnum_sp
3547 int     tgetnum_sp(
3548                 SCREEN  *sp, 
3549                 const char *id)
3550                 { return(*(int *)0); }
3551
3552 #undef tgetnum
3553 int     tgetnum(
3554                 const char *id)
3555                 { return(*(int *)0); }
3556
3557 #undef tgetstr_sp
3558 char    *tgetstr_sp(
3559                 SCREEN  *sp, 
3560                 const char *id, 
3561                 char    **area)
3562                 { return(*(char **)0); }
3563
3564 #undef tgetstr
3565 char    *tgetstr(
3566                 const char *id, 
3567                 char    **area)
3568                 { return(*(char **)0); }
3569
3570 /* ./tinfo/lib_termname.c */
3571
3572 #undef termname_sp
3573 char    *termname_sp(
3574                 SCREEN  *sp)
3575                 { return(*(char **)0); }
3576
3577 #undef termname
3578 char    *termname(void)
3579                 { return(*(char **)0); }
3580
3581 /* ./tinfo/lib_tgoto.c */
3582
3583 #undef tgoto
3584 char    *tgoto(
3585                 const char *string, 
3586                 int     x, 
3587                 int     y)
3588                 { return(*(char **)0); }
3589
3590 /* ./tinfo/lib_ti.c */
3591
3592 #undef tigetflag_sp
3593 int     tigetflag_sp(
3594                 SCREEN  *sp, 
3595                 const char *str)
3596                 { return(*(int *)0); }
3597
3598 #undef tigetflag
3599 int     tigetflag(
3600                 const char *str)
3601                 { return(*(int *)0); }
3602
3603 #undef tigetnum_sp
3604 int     tigetnum_sp(
3605                 SCREEN  *sp, 
3606                 const char *str)
3607                 { return(*(int *)0); }
3608
3609 #undef tigetnum
3610 int     tigetnum(
3611                 const char *str)
3612                 { return(*(int *)0); }
3613
3614 #undef tigetstr_sp
3615 char    *tigetstr_sp(
3616                 SCREEN  *sp, 
3617                 const char *str)
3618                 { return(*(char **)0); }
3619
3620 #undef tigetstr
3621 char    *tigetstr(
3622                 const char *str)
3623                 { return(*(char **)0); }
3624
3625 /* ./tinfo/lib_tparm.c */
3626
3627 #undef _nc_tparm_err
3628 int     _nc_tparm_err;
3629
3630 #undef _nc_tparm_analyze
3631 int     _nc_tparm_analyze(
3632                 const char *string, 
3633                 char    *p_is_s[9], 
3634                 int     *_nc_popcount)
3635                 { return(*(int *)0); }
3636
3637 #undef tparm
3638 char    *tparm(
3639                 const char *string, 
3640                 ...)
3641                 { return(*(char **)0); }
3642
3643 #undef tiparm
3644 char    *tiparm(
3645                 const char *string, 
3646                 ...)
3647                 { return(*(char **)0); }
3648
3649 /* ./tinfo/lib_tputs.c */
3650
3651 #undef PC
3652 char    PC;
3653 #undef ospeed
3654 short   ospeed;
3655 #undef _nc_nulls_sent
3656 int     _nc_nulls_sent;
3657
3658 #undef _nc_set_no_padding
3659 void    _nc_set_no_padding(
3660                 SCREEN  *sp)
3661                 { /* void */ }
3662
3663 #undef delay_output_sp
3664 int     delay_output_sp(
3665                 SCREEN  *sp, 
3666                 int     ms)
3667                 { return(*(int *)0); }
3668
3669 #undef delay_output
3670 int     delay_output(
3671                 int     ms)
3672                 { return(*(int *)0); }
3673
3674 #undef _nc_flush_sp
3675 void    _nc_flush_sp(
3676                 SCREEN  *sp)
3677                 { /* void */ }
3678
3679 #undef _nc_flush
3680 void    _nc_flush(void)
3681                 { /* void */ }
3682
3683 #undef _nc_outch_sp
3684 int     _nc_outch_sp(
3685                 SCREEN  *sp, 
3686                 int     ch)
3687                 { return(*(int *)0); }
3688
3689 #undef _nc_outch
3690 int     _nc_outch(
3691                 int     ch)
3692                 { return(*(int *)0); }
3693
3694 #undef _nc_putchar_sp
3695 int     _nc_putchar_sp(
3696                 SCREEN  *sp, 
3697                 int     ch)
3698                 { return(*(int *)0); }
3699
3700 #undef _nc_putchar
3701 int     _nc_putchar(
3702                 int     ch)
3703                 { return(*(int *)0); }
3704
3705 #undef putp_sp
3706 int     putp_sp(
3707                 SCREEN  *sp, 
3708                 const char *string)
3709                 { return(*(int *)0); }
3710
3711 #undef putp
3712 int     putp(
3713                 const char *string)
3714                 { return(*(int *)0); }
3715
3716 #undef _nc_putp_sp
3717 int     _nc_putp_sp(
3718                 SCREEN  *sp, 
3719                 const char *name, 
3720                 const char *string)
3721                 { return(*(int *)0); }
3722
3723 #undef _nc_putp
3724 int     _nc_putp(
3725                 const char *name, 
3726                 const char *string)
3727                 { return(*(int *)0); }
3728
3729 #undef tputs_sp
3730 int     tputs_sp(
3731                 SCREEN  *sp, 
3732                 const char *string, 
3733          &nbs