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