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