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