0ca29b5e570ea10fc79f6ef1097bf7bf81c4cdca
[ncurses.git] / ncurses / llib-lncurses
1 /******************************************************************************
2  * Copyright 1996,1997 by Thomas E. Dickey <dickey@clark.net>                 *
3  * All Rights Reserved.                                                       *
4  *                                                                            *
5  * Permission to use, copy, modify, and distribute this software and its      *
6  * documentation for any purpose and without fee is hereby granted, provided  *
7  * that the above copyright notice appear in all copies and that both that    *
8  * copyright notice and this permission notice appear in supporting           *
9  * documentation, and that the name of the above listed copyright holder(s)   *
10  * not be used in advertising or publicity pertaining to distribution of the  *
11  * software without specific, written prior permission. THE ABOVE LISTED      *
12  * COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,  *
13  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO     *
14  * EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY         *
15  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER       *
16  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF       *
17  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN        *
18  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.                   *
19  ******************************************************************************/
20 /* LINTLIBRARY */
21
22 /* ./fallback.c */
23
24 #include <curses.priv.h>
25 #include <term.h>
26
27 #undef _nc_fallback
28 const TERMTYPE *_nc_fallback(
29                 const char *name)
30                 { return(*(const TERMTYPE **)0); }
31
32 /* ./hashmap.c */
33
34 #undef _nc_hash_map
35 void    _nc_hash_map(void)
36                 { /* void */ }
37
38 /* ./hardscroll.c */
39
40 #undef _nc_scroll_optimize
41 void    _nc_scroll_optimize(void)
42                 { /* void */ }
43
44 /* ./lib_acs.c */
45
46 #undef acs_map
47 chtype  acs_map[128];
48
49 #undef init_acs
50 void    init_acs(void)
51                 { /* void */ }
52
53 /* ./lib_addch.c */
54
55 #include <ctype.h>
56
57 #undef wattr_on
58 int     wattr_on(
59                 WINDOW  *win, 
60                 const attr_t at)
61                 { return(*(int *)0); }
62
63 #undef wattr_off
64 int     wattr_off(
65                 WINDOW  *win, 
66                 const attr_t at)
67                 { return(*(int *)0); }
68
69 #undef wchgat
70 int     wchgat(
71                 WINDOW  *win, 
72                 int     n, 
73                 attr_t  attr, 
74                 short   color, 
75                 const void *opts)
76                 { return(*(int *)0); }
77
78 #undef _nc_background
79 chtype  _nc_background(
80                 WINDOW  *win)
81                 { return(*(chtype *)0); }
82
83 #undef _nc_render
84 chtype  _nc_render(
85                 WINDOW  *win, 
86                 chtype  ch)
87                 { return(*(chtype *)0); }
88
89 #undef _nc_waddch_nosync
90 int     _nc_waddch_nosync(
91                 WINDOW  *win, 
92                 const chtype c)
93                 { return(*(int *)0); }
94
95 #undef waddch
96 int     waddch(
97                 WINDOW  *win, 
98                 const chtype ch)
99                 { return(*(int *)0); }
100
101 #undef wechochar
102 int     wechochar(
103                 WINDOW  *win, 
104                 const chtype ch)
105                 { return(*(int *)0); }
106
107 /* ./lib_addstr.c */
108
109 #undef waddnstr
110 int     waddnstr(
111                 WINDOW  *win, 
112                 const char *const astr, 
113                 int     n)
114                 { return(*(int *)0); }
115
116 #undef waddchnstr
117 int     waddchnstr(
118                 WINDOW  *win, 
119                 const chtype *const astr, 
120                 int     n)
121                 { return(*(int *)0); }
122
123 /* ./lib_beep.c */
124
125 #undef beep
126 int     beep(void)
127                 { return(*(int *)0); }
128
129 #undef flash
130 int     flash(void)
131                 { return(*(int *)0); }
132
133 /* ./lib_bkgd.c */
134
135 #undef wbkgd
136 int     wbkgd(
137                 WINDOW  *win, 
138                 const chtype ch)
139                 { return(*(int *)0); }
140
141 /* ./lib_baudrate.c */
142
143 struct speed {
144         speed_t s;
145         int sp;
146 };
147
148 #undef baudrate
149 int     baudrate(void)
150                 { return(*(int *)0); }
151
152 /* ./lib_box.c */
153
154 #undef wborder
155 int     wborder(
156                 WINDOW  *win, 
157                 chtype  ls, 
158                 chtype  rs, 
159                 chtype  ts, 
160                 chtype  bs, 
161                 chtype  tl, 
162                 chtype  tr, 
163                 chtype  bl, 
164                 chtype  br)
165                 { return(*(int *)0); }
166
167 #undef whline
168 int     whline(
169                 WINDOW  *win, 
170                 chtype  ch, 
171                 int     n)
172                 { return(*(int *)0); }
173
174 #undef wvline
175 int     wvline(
176                 WINDOW  *win, 
177                 chtype  ch, 
178                 int     n)
179                 { return(*(int *)0); }
180
181 /* ./lib_clear.c */
182
183 #undef wclear
184 int     wclear(
185                 WINDOW  *win)
186                 { return(*(int *)0); }
187
188 /* ./lib_clrbot.c */
189
190 #undef wclrtobot
191 int     wclrtobot(
192                 WINDOW  *win)
193                 { return(*(int *)0); }
194
195 /* ./lib_clreol.c */
196
197 #undef wclrtoeol
198 int     wclrtoeol(
199                 WINDOW  *win)
200                 { return(*(int *)0); }
201
202 /* ./lib_color.c */
203
204 #undef COLOR_PAIRS
205 int     COLOR_PAIRS;
206 #undef COLORS
207 int     COLORS;
208
209 #undef start_color
210 int     start_color(void)
211                 { return(*(int *)0); }
212
213 #undef init_pair
214 int     init_pair(
215                 short   pair, 
216                 short   f, 
217                 short   b)
218                 { return(*(int *)0); }
219
220 #undef init_color
221 int     init_color(
222                 short   color, 
223                 short   r, 
224                 short   g, 
225                 short   b)
226                 { return(*(int *)0); }
227
228 #undef can_change_color
229 bool    can_change_color(void)
230                 { return(*(bool *)0); }
231
232 #undef has_colors
233 bool    has_colors(void)
234                 { return(*(bool *)0); }
235
236 #undef color_content
237 int     color_content(
238                 short   color, 
239                 short   *r, 
240                 short   *g, 
241                 short   *b)
242                 { return(*(int *)0); }
243
244 #undef pair_content
245 int     pair_content(
246                 short   pair, 
247                 short   *f, 
248                 short   *b)
249                 { return(*(int *)0); }
250
251 #undef _nc_do_color
252 void    _nc_do_color(
253                 int     pair, 
254                 int     (*outc)(
255                 int     p1))
256                 { /* void */ }
257
258 /* ./lib_data.c */
259
260 #undef stdscr
261 WINDOW  *stdscr;
262 #undef curscr
263 WINDOW  *curscr;
264 #undef newscr
265 WINDOW  *newscr;
266 #undef _nc_windows
267 struct _win_list *_nc_windows;
268 #undef _nc_idcok
269 bool    _nc_idcok;
270 #undef _nc_idlok
271 bool    _nc_idlok;
272 #undef SP
273 SCREEN  *SP;
274
275 /* ./lib_delch.c */
276
277 #undef wdelch
278 int     wdelch(
279                 WINDOW  *win)
280                 { return(*(int *)0); }
281
282 /* ./lib_delwin.c */
283
284 #undef delwin
285 int     delwin(
286                 WINDOW  *win)
287                 { return(*(int *)0); }
288
289 /* ./lib_doupdate.c */
290
291 #include <sys/time.h>
292
293 #undef doupdate
294 int     doupdate(void)
295                 { return(*(int *)0); }
296
297 #undef _nc_outstr
298 void    _nc_outstr(
299                 const char *str)
300                 { /* void */ }
301
302 /* ./lib_endwin.c */
303
304 #undef endwin
305 int     endwin(void)
306                 { return(*(int *)0); }
307
308 /* ./lib_erase.c */
309
310 #undef werase
311 int     werase(
312                 WINDOW  *win)
313                 { return(*(int *)0); }
314
315 /* ./lib_gen.c */
316
317 #include <curses.h>
318
319 #undef addch
320 int     addch(
321                 const chtype z)
322                 { return(*(int *)0); }
323
324 #undef addchnstr
325 int     addchnstr(
326                 const chtype *a1, 
327                 int     z)
328                 { return(*(int *)0); }
329
330 #undef addchstr
331 int     addchstr(
332                 const chtype *z)
333                 { return(*(int *)0); }
334
335 #undef addnstr
336 int     addnstr(
337                 const char *a1, 
338                 int     z)
339                 { return(*(int *)0); }
340
341 #undef addstr
342 int     addstr(
343                 const char *z)
344                 { return(*(int *)0); }
345
346 #undef attroff
347 int     attroff(
348                 int     z)
349                 { return(*(int *)0); }
350
351 #undef attron
352 int     attron(
353                 int     z)
354                 { return(*(int *)0); }
355
356 #undef attrset
357 int     attrset(
358                 int     z)
359                 { return(*(int *)0); }
360
361 #undef attr_get
362 int     attr_get(void)
363                 { return(*(int *)0); }
364
365 #undef attr_off
366 int     attr_off(
367                 int     z)
368                 { return(*(int *)0); }
369
370 #undef attr_on
371 int     attr_on(
372                 int     z)
373                 { return(*(int *)0); }
374
375 #undef attr_set
376 int     attr_set(
377                 int     z)
378                 { return(*(int *)0); }
379
380 #undef bkgd
381 int     bkgd(
382                 chtype  z)
383                 { return(*(int *)0); }
384
385 #undef bkgdset
386 void    bkgdset(
387                 chtype  z)
388                 { /* void */ }
389
390 #undef border
391 int     border(
392                 chtype  a1, 
393                 chtype  a2, 
394                 chtype  a3, 
395                 chtype  a4, 
396                 chtype  a5, 
397                 chtype  a6, 
398                 chtype  a7, 
399                 chtype  z)
400                 { return(*(int *)0); }
401
402 #undef box
403 int     box(
404                 WINDOW  *a1, 
405                 chtype  a2, 
406                 chtype  z)
407                 { return(*(int *)0); }
408
409 #undef chgat
410 int     chgat(
411                 int     a1, 
412                 attr_t  a2, 
413                 short   a3, 
414                 const void *z)
415                 { return(*(int *)0); }
416
417 #undef clear
418 int     clear(void)
419                 { return(*(int *)0); }
420
421 #undef clrtobot
422 int     clrtobot(void)
423                 { return(*(int *)0); }
424
425 #undef clrtoeol
426 int     clrtoeol(void)
427                 { return(*(int *)0); }
428
429 #undef COLOR_PAIR
430 int     COLOR_PAIR(
431                 int     z)
432                 { return(*(int *)0); }
433
434 #undef delch
435 int     delch(void)
436                 { return(*(int *)0); }
437
438 #undef deleteln
439 int     deleteln(void)
440                 { return(*(int *)0); }
441
442 #undef echochar
443 int     echochar(
444                 const chtype z)
445                 { return(*(int *)0); }
446
447 #undef getbkgd
448 chtype  getbkgd(
449                 WINDOW  *z)
450                 { return(*(chtype *)0); }
451
452 #undef getch
453 int     getch(void)
454                 { return(*(int *)0); }
455
456 #undef getnstr
457 int     getnstr(
458                 char    *a1, 
459                 int     z)
460                 { return(*(int *)0); }
461
462 #undef getstr
463 int     getstr(
464                 char    *z)
465                 { return(*(int *)0); }
466
467 #undef hline
468 int     hline(
469                 chtype  a1, 
470                 int     z)
471                 { return(*(int *)0); }
472
473 #undef inch
474 chtype  inch(void)
475                 { return(*(chtype *)0); }
476
477 #undef inchnstr
478 int     inchnstr(
479                 chtype  *a1, 
480                 int     z)
481                 { return(*(int *)0); }
482
483 #undef inchstr
484 int     inchstr(
485                 chtype  *z)
486                 { return(*(int *)0); }
487
488 #undef innstr
489 int     innstr(
490                 char    *a1, 
491                 int     z)
492                 { return(*(int *)0); }
493
494 #undef insch
495 int     insch(
496                 chtype  z)
497                 { return(*(int *)0); }
498
499 #undef insdelln
500 int     insdelln(
501                 int     z)
502                 { return(*(int *)0); }
503
504 #undef insertln
505 int     insertln(void)
506                 { return(*(int *)0); }
507
508 #undef insnstr
509 int     insnstr(
510                 const char *a1, 
511                 int     z)
512                 { return(*(int *)0); }
513
514 #undef insstr
515 int     insstr(
516                 const char *z)
517                 { return(*(int *)0); }
518
519 #undef instr
520 int     instr(
521                 char    *z)
522                 { return(*(int *)0); }
523
524 #undef move
525 int     move(
526                 int     a1, 
527                 int     z)
528                 { return(*(int *)0); }
529
530 #undef mvaddch
531 int     mvaddch(
532                 int     a1, 
533                 int     a2, 
534                 const chtype z)
535                 { return(*(int *)0); }
536
537 #undef mvaddchnstr
538 int     mvaddchnstr(
539                 int     a1, 
540                 int     a2, 
541                 const chtype *a3, 
542                 int     z)
543                 { return(*(int *)0); }
544
545 #undef mvaddchstr
546 int     mvaddchstr(
547                 int     a1, 
548                 int     a2, 
549                 const chtype *z)
550                 { return(*(int *)0); }
551
552 #undef mvaddnstr
553 int     mvaddnstr(
554                 int     a1, 
555                 int     a2, 
556                 const char *a3, 
557                 int     z)
558                 { return(*(int *)0); }
559
560 #undef mvaddstr
561 int     mvaddstr(
562                 int     a1, 
563                 int     a2, 
564                 const char *z)
565                 { return(*(int *)0); }
566
567 #undef mvchgat
568 int     mvchgat(
569                 int     a1, 
570                 int     a2, 
571                 int     a3, 
572                 attr_t  a4, 
573                 short   a5, 
574                 const void *z)
575                 { return(*(int *)0); }
576
577 #undef mvdelch
578 int     mvdelch(
579                 int     a1, 
580                 int     z)
581                 { return(*(int *)0); }
582
583 #undef mvgetch
584 int     mvgetch(
585                 int     a1, 
586                 int     z)
587                 { return(*(int *)0); }
588
589 #undef mvgetnstr
590 int     mvgetnstr(
591                 int     a1, 
592                 int     a2, 
593                 char    *a3, 
594                 int     z)
595                 { return(*(int *)0); }
596
597 #undef mvgetstr
598 int     mvgetstr(
599                 int     a1, 
600                 int     a2, 
601                 char    *z)
602                 { return(*(int *)0); }
603
604 #undef mvhline
605 int     mvhline(
606                 int     a1, 
607                 int     a2, 
608                 chtype  a3, 
609                 int     z)
610                 { return(*(int *)0); }
611
612 #undef mvinch
613 chtype  mvinch(
614                 int     a1, 
615                 int     z)
616                 { return(*(chtype *)0); }
617
618 #undef mvinchnstr
619 int     mvinchnstr(
620                 int     a1, 
621                 int     a2, 
622                 chtype  *a3, 
623                 int     z)
624                 { return(*(int *)0); }
625
626 #undef mvinchstr
627 int     mvinchstr(
628                 int     a1, 
629                 int     a2, 
630                 chtype  *z)
631                 { return(*(int *)0); }
632
633 #undef mvinnstr
634 int     mvinnstr(
635                 int     a1, 
636                 int     a2, 
637                 char    *a3, 
638                 int     z)
639                 { return(*(int *)0); }
640
641 #undef mvinsch
642 int     mvinsch(
643                 int     a1, 
644                 int     a2, 
645                 chtype  z)
646                 { return(*(int *)0); }
647
648 #undef mvinsnstr
649 int     mvinsnstr(
650                 int     a1, 
651                 int     a2, 
652                 const char *a3, 
653                 int     z)
654                 { return(*(int *)0); }
655
656 #undef mvinsstr
657 int     mvinsstr(
658                 int     a1, 
659                 int     a2, 
660                 const char *z)
661                 { return(*(int *)0); }
662
663 #undef mvinstr
664 int     mvinstr(
665                 int     a1, 
666                 int     a2, 
667                 char    *z)
668                 { return(*(int *)0); }
669
670 #undef mvvline
671 int     mvvline(
672                 int     a1, 
673                 int     a2, 
674                 chtype  a3, 
675                 int     z)
676                 { return(*(int *)0); }
677
678 #undef mvwaddch
679 int     mvwaddch(
680                 WINDOW  *a1, 
681                 int     a2, 
682                 int     a3, 
683                 const chtype z)
684                 { return(*(int *)0); }
685
686 #undef mvwaddchnstr
687 int     mvwaddchnstr(
688                 WINDOW  *a1, 
689                 int     a2, 
690                 int     a3, 
691                 const chtype *a4, 
692                 int     z)
693                 { return(*(int *)0); }
694
695 #undef mvwaddchstr
696 int     mvwaddchstr(
697                 WINDOW  *a1, 
698                 int     a2, 
699                 int     a3, 
700                 const chtype *z)
701                 { return(*(int *)0); }
702
703 #undef mvwaddnstr
704 int     mvwaddnstr(
705                 WINDOW  *a1, 
706                 int     a2, 
707                 int     a3, 
708                 const char *a4, 
709                 int     z)
710                 { return(*(int *)0); }
711
712 #undef mvwaddstr
713 int     mvwaddstr(
714                 WINDOW  *a1, 
715                 int     a2, 
716                 int     a3, 
717                 const char *z)
718                 { return(*(int *)0); }
719
720 #undef mvwchgat
721 int     mvwchgat(
722                 WINDOW  *a1, 
723                 int     a2, 
724                 int     a3, 
725                 int     a4, 
726                 attr_t  a5, 
727                 short   a6, 
728                 const void *z)
729                 { return(*(int *)0); }
730
731 #undef mvwdelch
732 int     mvwdelch(
733                 WINDOW  *a1, 
734                 int     a2, 
735                 int     z)
736                 { return(*(int *)0); }
737
738 #undef mvwgetch
739 int     mvwgetch(
740                 WINDOW  *a1, 
741                 int     a2, 
742                 int     z)
743                 { return(*(int *)0); }
744
745 #undef mvwgetnstr
746 int     mvwgetnstr(
747                 WINDOW  *a1, 
748                 int     a2, 
749                 int     a3, 
750                 char    *a4, 
751                 int     z)
752                 { return(*(int *)0); }
753
754 #undef mvwgetstr
755 int     mvwgetstr(
756                 WINDOW  *a1, 
757                 int     a2, 
758                 int     a3, 
759                 char    *z)
760                 { return(*(int *)0); }
761
762 #undef mvwhline
763 int     mvwhline(
764                 WINDOW  *a1, 
765                 int     a2, 
766                 int     a3, 
767                 chtype  a4, 
768                 int     z)
769                 { return(*(int *)0); }
770
771 #undef mvwinch
772 chtype  mvwinch(
773                 WINDOW  *a1, 
774                 int     a2, 
775                 int     z)
776                 { return(*(chtype *)0); }
777
778 #undef mvwinchnstr
779 int     mvwinchnstr(
780                 WINDOW  *a1, 
781                 int     a2, 
782                 int     a3, 
783                 chtype  *a4, 
784                 int     z)
785                 { return(*(int *)0); }
786
787 #undef mvwinchstr
788 int     mvwinchstr(
789                 WINDOW  *a1, 
790                 int     a2, 
791                 int     a3, 
792                 chtype  *z)
793                 { return(*(int *)0); }
794
795 #undef mvwinnstr
796 int     mvwinnstr(
797                 WINDOW  *a1, 
798                 int     a2, 
799                 int     a3, 
800                 char    *a4, 
801                 int     z)
802                 { return(*(int *)0); }
803
804 #undef mvwinsch
805 int     mvwinsch(
806                 WINDOW  *a1, 
807                 int     a2, 
808                 int     a3, 
809                 chtype  z)
810                 { return(*(int *)0); }
811
812 #undef mvwinsnstr
813 int     mvwinsnstr(
814                 WINDOW  *a1, 
815                 int     a2, 
816                 int     a3, 
817                 const char *a4, 
818                 int     z)
819                 { return(*(int *)0); }
820
821 #undef mvwinsstr
822 int     mvwinsstr(
823                 WINDOW  *a1, 
824                 int     a2, 
825                 int     a3, 
826                 const char *z)
827                 { return(*(int *)0); }
828
829 #undef mvwinstr
830 int     mvwinstr(
831                 WINDOW  *a1, 
832                 int     a2, 
833                 int     a3, 
834                 char    *z)
835                 { return(*(int *)0); }
836
837 #undef mvwvline
838 int     mvwvline(
839                 WINDOW  *a1, 
840                 int     a2, 
841                 int     a3, 
842                 chtype  a4, 
843                 int     z)
844                 { return(*(int *)0); }
845
846 #undef PAIR_NUMBER
847 int     PAIR_NUMBER(
848                 int     z)
849                 { return(*(int *)0); }
850
851 #undef redrawwin
852 int     redrawwin(
853                 WINDOW  *z)
854                 { return(*(int *)0); }
855
856 #undef refresh
857 int     refresh(void)
858                 { return(*(int *)0); }
859
860 #undef scrl
861 int     scrl(
862                 int     z)
863                 { return(*(int *)0); }
864
865 #undef scroll
866 int     scroll(
867                 WINDOW  *z)
868                 { return(*(int *)0); }
869
870 #undef setscrreg
871 int     setscrreg(
872                 int     a1, 
873                 int     z)
874                 { return(*(int *)0); }
875
876 #undef standout
877 int     standout(void)
878                 { return(*(int *)0); }
879
880 #undef standend
881 int     standend(void)
882                 { return(*(int *)0); }
883
884 #undef timeout
885 int     timeout(
886                 int     z)
887                 { return(*(int *)0); }
888
889 #undef untouchwin
890 int     untouchwin(
891                 WINDOW  *z)
892                 { return(*(int *)0); }
893
894 #undef vline
895 int     vline(
896                 chtype  a1, 
897                 int     z)
898                 { return(*(int *)0); }
899
900 #undef vw_printw
901 int     vw_printw(
902                 WINDOW  *a1, 
903                 const char *a2, 
904                 va_list z)
905                 { return(*(int *)0); }
906
907 #undef vw_scanw
908 int     vw_scanw(
909                 WINDOW  *a1, 
910                 const char *a2, 
911                 va_list z)
912                 { return(*(int *)0); }
913
914 #undef waddchstr
915 int     waddchstr(
916                 WINDOW  *a1, 
917                 const chtype *z)
918                 { return(*(int *)0); }
919
920 #undef waddstr
921 int     waddstr(
922                 WINDOW  *a1, 
923                 const char *z)
924                 { return(*(int *)0); }
925
926 #undef wattron
927 int     wattron(
928                 WINDOW  *a1, 
929                 int     z)
930                 { return(*(int *)0); }
931
932 #undef wattroff
933 int     wattroff(
934                 WINDOW  *a1, 
935                 int     z)
936                 { return(*(int *)0); }
937
938 #undef wattrset
939 int     wattrset(
940                 WINDOW  *a1, 
941                 int     z)
942                 { return(*(int *)0); }
943
944 #undef wattr_get
945 attr_t  wattr_get(
946                 WINDOW  *z)
947                 { return(*(attr_t *)0); }
948
949 #undef wattr_set
950 int     wattr_set(
951                 WINDOW  *a1, 
952                 attr_t  z)
953                 { return(*(int *)0); }
954
955 #undef wbkgdset
956 void    wbkgdset(
957                 WINDOW  *a1, 
958                 chtype  z)
959                 { /* void */ }
960
961 #undef wdeleteln
962 int     wdeleteln(
963                 WINDOW  *z)
964                 { return(*(int *)0); }
965
966 #undef wgetstr
967 int     wgetstr(
968                 WINDOW  *a1, 
969                 char    *z)
970                 { return(*(int *)0); }
971
972 #undef winch
973 chtype  winch(
974                 WINDOW  *z)
975                 { return(*(chtype *)0); }
976
977 #undef winchstr
978 int     winchstr(
979                 WINDOW  *a1, 
980                 chtype  *z)
981                 { return(*(int *)0); }
982
983 #undef winsertln
984 int     winsertln(
985                 WINDOW  *z)
986                 { return(*(int *)0); }
987
988 #undef winsstr
989 int     winsstr(
990                 WINDOW  *a1, 
991                 const char *z)
992                 { return(*(int *)0); }
993
994 #undef winstr
995 int     winstr(
996                 WINDOW  *a1, 
997                 char    *z)
998                 { return(*(int *)0); }
999
1000 #undef wstandout
1001 int     wstandout(
1002                 WINDOW  *z)
1003                 { return(*(int *)0); }
1004
1005 #undef wstandend
1006 int     wstandend(
1007                 WINDOW  *z)
1008                 { return(*(int *)0); }
1009
1010 /* ./lib_getch.c */
1011
1012 #undef ESCDELAY
1013 int     ESCDELAY;
1014
1015 #undef ungetch
1016 int     ungetch(
1017                 int     ch)
1018                 { return(*(int *)0); }
1019
1020 #undef _nc_backspace
1021 void    _nc_backspace(
1022                 WINDOW  *win)
1023                 { /* void */ }
1024
1025 #undef wgetch
1026 int     wgetch(
1027                 WINDOW  *win)
1028                 { return(*(int *)0); }
1029
1030 /* ./lib_getstr.c */
1031
1032 #undef wgetnstr
1033 int     wgetnstr(
1034                 WINDOW  *win, 
1035                 char    *str, 
1036                 int     maxlen)
1037                 { return(*(int *)0); }
1038
1039 /* ./lib_inchstr.c */
1040
1041 #undef winchnstr
1042 int     winchnstr(
1043                 WINDOW  *win, 
1044                 chtype  *str, 
1045                 int     n)
1046                 { return(*(int *)0); }
1047
1048 /* ./lib_initscr.c */
1049
1050 #undef _nc_initscr
1051 int     _nc_initscr(void)
1052                 { return(*(int *)0); }
1053
1054 #undef initscr
1055 WINDOW  *initscr(void)
1056                 { return(*(WINDOW **)0); }
1057
1058 #undef termname
1059 char    *termname(void)
1060                 { return(*(char **)0); }
1061
1062 /* ./lib_insch.c */
1063
1064 #undef winsch
1065 int     winsch(
1066                 WINDOW  *win, 
1067                 chtype  c)
1068                 { return(*(int *)0); }
1069
1070 /* ./lib_insdel.c */
1071
1072 #undef winsdelln
1073 int     winsdelln(
1074                 WINDOW  *win, 
1075                 int     n)
1076                 { return(*(int *)0); }
1077
1078 /* ./lib_insstr.c */
1079
1080 #undef winsnstr
1081 int     winsnstr(
1082                 WINDOW  *win, 
1083                 const char *str, 
1084                 int     n)
1085                 { return(*(int *)0); }
1086
1087 /* ./lib_instr.c */
1088
1089 #undef winnstr
1090 int     winnstr(
1091                 WINDOW  *win, 
1092                 char    *str, 
1093                 int     n)
1094                 { return(*(int *)0); }
1095
1096 /* ./lib_isendwin.c */
1097
1098 #undef isendwin
1099 int     isendwin(void)
1100                 { return(*(int *)0); }
1101
1102 /* ./lib_kernel.c */
1103
1104 #undef napms
1105 int     napms(
1106                 int     ms)
1107                 { return(*(int *)0); }
1108
1109 #undef reset_prog_mode
1110 int     reset_prog_mode(void)
1111                 { return(*(int *)0); }
1112
1113 #undef reset_shell_mode
1114 int     reset_shell_mode(void)
1115                 { return(*(int *)0); }
1116
1117 #undef erasechar
1118 char    erasechar(void)
1119                 { return(*(char *)0); }
1120
1121 #undef killchar
1122 char    killchar(void)
1123                 { return(*(char *)0); }
1124
1125 #undef flushinp
1126 int     flushinp(void)
1127                 { return(*(int *)0); }
1128
1129 #undef savetty
1130 int     savetty(void)
1131                 { return(*(int *)0); }
1132
1133 #undef resetty
1134 int     resetty(void)
1135                 { return(*(int *)0); }
1136
1137 /* ./lib_keyname.c */
1138
1139 #include <ncurses_cfg.h>
1140 #include <stdlib.h>
1141
1142 struct kn {
1143         const char *name;
1144         int code;
1145 };
1146
1147 #undef key_names
1148 const struct kn key_names[] = {0};
1149
1150 #undef keyname
1151 const char *keyname(
1152                 int     c)
1153                 { return(*(const char **)0); }
1154
1155 /* ./lib_longname.c */
1156
1157 #undef longname
1158 char    *longname(void)
1159                 { return(*(char **)0); }
1160
1161 /* ./lib_mouse.c */
1162
1163 #undef _nc_max_click_interval
1164 int     _nc_max_click_interval;
1165
1166 #undef _nc_mouse_init
1167 void    _nc_mouse_init(
1168                 SCREEN  *sp)
1169                 { /* void */ }
1170
1171 #undef _nc_mouse_fd
1172 int     _nc_mouse_fd(void)
1173                 { return(*(int *)0); }
1174
1175 #undef _nc_mouse_event
1176 bool    _nc_mouse_event(
1177                 SCREEN  *sp)
1178                 { return(*(bool *)0); }
1179
1180 #undef _nc_mouse_inline
1181 bool    _nc_mouse_inline(
1182                 SCREEN  *sp)
1183                 { return(*(bool *)0); }
1184
1185 #undef _nc_mouse_parse
1186 bool    _nc_mouse_parse(
1187                 int     runcount)
1188                 { return(*(bool *)0); }
1189
1190 #undef _nc_mouse_wrap
1191 void    _nc_mouse_wrap(
1192                 SCREEN  *sp)
1193                 { /* void */ }
1194
1195 #undef _nc_mouse_resume
1196 void    _nc_mouse_resume(
1197                 SCREEN  *sp)
1198                 { /* void */ }
1199
1200 #undef getmouse
1201 int     getmouse(
1202                 MEVENT  *aevent)
1203                 { return(*(int *)0); }
1204
1205 #undef ungetmouse
1206 int     ungetmouse(
1207                 MEVENT  *aevent)
1208                 { return(*(int *)0); }
1209
1210 #undef mousemask
1211 mmask_t mousemask(
1212                 mmask_t newmask, 
1213                 mmask_t *oldmask)
1214                 { return(*(mmask_t *)0); }
1215
1216 #undef wenclose
1217 bool    wenclose(
1218                 WINDOW  *win, 
1219                 int     y, 
1220                 int     x)
1221                 { return(*(bool *)0); }
1222
1223 #undef mouseinterval
1224 int     mouseinterval(
1225                 int     maxclick)
1226                 { return(*(int *)0); }
1227
1228 /* ./lib_move.c */
1229
1230 #undef wmove
1231 int     wmove(
1232                 WINDOW  *win, 
1233                 int     y, 
1234                 int     x)
1235                 { return(*(int *)0); }
1236
1237 /* ./lib_mvcur.c */
1238
1239 #undef _nc_mvcur_resume
1240 void    _nc_mvcur_resume(void)
1241                 { /* void */ }
1242
1243 #undef _nc_mvcur_init
1244 void    _nc_mvcur_init(void)
1245                 { /* void */ }
1246
1247 #undef _nc_mvcur_wrap
1248 void    _nc_mvcur_wrap(void)
1249                 { /* void */ }
1250
1251 #undef mvcur
1252 int     mvcur(
1253                 int     yold, 
1254                 int     xold, 
1255                 int     ynew, 
1256                 int     xnew)
1257                 { return(*(int *)0); }
1258
1259 #undef _nc_mvcur_scrolln
1260 int     _nc_mvcur_scrolln(
1261                 int     n, 
1262                 int     top, 
1263                 int     bot, 
1264                 int     maxy)
1265                 { return(*(int *)0); }
1266
1267 /* ./lib_mvwin.c */
1268
1269 #undef mvwin
1270 int     mvwin(
1271                 WINDOW  *win, 
1272                 int     by, 
1273                 int     bx)
1274                 { return(*(int *)0); }
1275
1276 /* ./lib_newterm.c */
1277
1278 #undef filter
1279 void    filter(void)
1280                 { /* void */ }
1281
1282 #undef newterm
1283 SCREEN  *newterm(
1284                 const char *term, 
1285                 FILE    *ofp, 
1286                 FILE    *ifp)
1287                 { return(*(SCREEN **)0); }
1288
1289 /* ./lib_newwin.c */
1290
1291 #undef _nc_freewin
1292 void    _nc_freewin(
1293                 WINDOW  *win)
1294                 { /* void */ }
1295
1296 #undef newwin
1297 WINDOW  *newwin(
1298                 int     num_lines, 
1299                 int     num_columns, 
1300                 int     begy, 
1301                 int     begx)
1302                 { return(*(WINDOW **)0); }
1303
1304 #undef derwin
1305 WINDOW  *derwin(
1306                 WINDOW  *orig, 
1307                 int     num_lines, 
1308                 int     num_columns, 
1309                 int     begy, 
1310                 int     begx)
1311                 { return(*(WINDOW **)0); }
1312
1313 #undef subwin
1314 WINDOW  *subwin(
1315                 WINDOW  *w, 
1316                 int     l, 
1317                 int     c, 
1318                 int     y, 
1319                 int     x)
1320                 { return(*(WINDOW **)0); }
1321
1322 #undef _nc_makenew
1323 WINDOW  *_nc_makenew(
1324                 int     num_lines, 
1325                 int     num_columns, 
1326                 int     begy, 
1327                 int     begx, 
1328                 int     flags)
1329                 { return(*(WINDOW **)0); }
1330
1331 /* ./lib_options.c */
1332
1333 #undef has_ic
1334 int     has_ic(void)
1335                 { return(*(int *)0); }
1336
1337 #undef has_il
1338 int     has_il(void)
1339                 { return(*(int *)0); }
1340
1341 #undef idlok
1342 int     idlok(
1343                 WINDOW  *win, 
1344                 bool    flag)
1345                 { return(*(int *)0); }
1346
1347 #undef idcok
1348 void    idcok(
1349                 WINDOW  *win, 
1350                 bool    flag)
1351                 { /* void */ }
1352
1353 #undef clearok
1354 int     clearok(
1355                 WINDOW  *win, 
1356                 bool    flag)
1357                 { return(*(int *)0); }
1358
1359 #undef immedok
1360 void    immedok(
1361                 WINDOW  *win, 
1362                 bool    flag)
1363                 { /* void */ }
1364
1365 #undef leaveok
1366 int     leaveok(
1367                 WINDOW  *win, 
1368                 bool    flag)
1369                 { return(*(int *)0); }
1370
1371 #undef scrollok
1372 int     scrollok(
1373                 WINDOW  *win, 
1374                 bool    flag)
1375                 { return(*(int *)0); }
1376
1377 #undef halfdelay
1378 int     halfdelay(
1379                 int     t)
1380                 { return(*(int *)0); }
1381
1382 #undef nodelay
1383 int     nodelay(
1384                 WINDOW  *win, 
1385                 bool    flag)
1386                 { return(*(int *)0); }
1387
1388 #undef notimeout
1389 int     notimeout(
1390                 WINDOW  *win, 
1391                 bool    f)
1392                 { return(*(int *)0); }
1393
1394 #undef wtimeout
1395 int     wtimeout(
1396                 WINDOW  *win, 
1397                 int     delay)
1398                 { return(*(int *)0); }
1399
1400 #undef _nc_keypad
1401 int     _nc_keypad(
1402                 bool    flag)
1403                 { return(*(int *)0); }
1404
1405 #undef keypad
1406 int     keypad(
1407                 WINDOW  *win, 
1408                 bool    flag)
1409                 { return(*(int *)0); }
1410
1411 #undef meta
1412 int     meta(
1413                 WINDOW  *win, 
1414                 bool    flag)
1415                 { return(*(int *)0); }
1416
1417 #undef curs_set
1418 int     curs_set(
1419                 int     vis)
1420                 { return(*(int *)0); }
1421
1422 #if 0
1423
1424 #include <keys.tries>
1425
1426 #endif
1427
1428 #undef typeahead
1429 int     typeahead(
1430                 int     fd)
1431                 { return(*(int *)0); }
1432
1433 #undef has_key
1434 int     has_key(
1435                 int     keycode)
1436                 { return(*(int *)0); }
1437
1438 /* ./lib_overlay.c */
1439
1440 #undef overlay
1441 int     overlay(
1442                 const WINDOW *win1, 
1443                 WINDOW  *win2)
1444                 { return(*(int *)0); }
1445
1446 #undef overwrite
1447 int     overwrite(
1448                 const WINDOW *win1, 
1449                 WINDOW  *win2)
1450                 { return(*(int *)0); }
1451
1452 #undef copywin
1453 int     copywin(
1454                 const WINDOW *src, 
1455                 WINDOW  *dst, 
1456                 int     sminrow, 
1457                 int     smincol, 
1458                 int     dminrow, 
1459                 int     dmincol, 
1460                 int     dmaxrow, 
1461                 int     dmaxcol, 
1462                 int     over)
1463                 { return(*(int *)0); }
1464
1465 /* ./lib_pad.c */
1466
1467 #undef newpad
1468 WINDOW  *newpad(
1469                 int     l, 
1470                 int     c)
1471                 { return(*(WINDOW **)0); }
1472
1473 #undef subpad
1474 WINDOW  *subpad(
1475                 WINDOW  *orig, 
1476                 int     l, 
1477                 int     c, 
1478                 int     begy, 
1479                 int     begx)
1480                 { return(*(WINDOW **)0); }
1481
1482 #undef prefresh
1483 int     prefresh(
1484                 WINDOW  *win, 
1485                 int     pminrow, 
1486                 int     pmincol, 
1487                 int     sminrow, 
1488                 int     smincol, 
1489                 int     smaxrow, 
1490                 int     smaxcol)
1491                 { return(*(int *)0); }
1492
1493 #undef pnoutrefresh
1494 int     pnoutrefresh(
1495                 WINDOW  *win, 
1496                 int     pminrow, 
1497                 int     pmincol, 
1498                 int     sminrow, 
1499                 int     smincol, 
1500                 int     smaxrow, 
1501                 int     smaxcol)
1502                 { return(*(int *)0); }
1503
1504 #undef pechochar
1505 int     pechochar(
1506                 WINDOW  *pad, 
1507                 chtype  ch)
1508                 { return(*(int *)0); }
1509
1510 /* ./lib_print.c */
1511
1512 #undef mcprint
1513 int     mcprint(
1514                 char    *data, 
1515                 int     len)
1516                 { return(*(int *)0); }
1517
1518 /* ./lib_printw.c */
1519
1520 #undef printw
1521 int     printw(
1522                 const char *fmt, 
1523                 ...)
1524                 { return(*(int *)0); }
1525
1526 #undef wprintw
1527 int     wprintw(
1528                 WINDOW  *win, 
1529                 const char *fmt, 
1530                 ...)
1531                 { return(*(int *)0); }
1532
1533 #undef mvprintw
1534 int     mvprintw(
1535                 int     y, 
1536                 int     x, 
1537                 const char *fmt, 
1538                 ...)
1539                 { return(*(int *)0); }
1540
1541 #undef mvwprintw
1542 int     mvwprintw(
1543                 WINDOW  *win, 
1544                 int     y, 
1545                 int     x, 
1546                 const char *fmt, 
1547                 ...)
1548                 { return(*(int *)0); }
1549
1550 #undef vwprintw
1551 int     vwprintw(
1552                 WINDOW  *win, 
1553                 const char *fmt, 
1554                 va_list argp)
1555                 { return(*(int *)0); }
1556
1557 /* ./lib_raw.c */
1558
1559 #undef raw
1560 int     raw(void)
1561                 { return(*(int *)0); }
1562
1563 #undef cbreak
1564 int     cbreak(void)
1565                 { return(*(int *)0); }
1566
1567 #undef echo
1568 int     echo(void)
1569                 { return(*(int *)0); }
1570
1571 #undef nl
1572 int     nl(void)
1573                 { return(*(int *)0); }
1574
1575 #undef qiflush
1576 int     qiflush(void)
1577                 { return(*(int *)0); }
1578
1579 #undef noraw
1580 int     noraw(void)
1581                 { return(*(int *)0); }
1582
1583 #undef nocbreak
1584 int     nocbreak(void)
1585                 { return(*(int *)0); }
1586
1587 #undef noecho
1588 int     noecho(void)
1589                 { return(*(int *)0); }
1590
1591 #undef nonl
1592 int     nonl(void)
1593                 { return(*(int *)0); }
1594
1595 #undef noqiflush
1596 int     noqiflush(void)
1597                 { return(*(int *)0); }
1598
1599 #undef intrflush
1600 int     intrflush(
1601                 WINDOW  *win, 
1602                 bool    flag)
1603                 { return(*(int *)0); }
1604
1605 /* ./lib_refresh.c */
1606
1607 #undef wredrawln
1608 int     wredrawln(
1609                 WINDOW  *win, 
1610                 int     beg, 
1611                 int     num)
1612                 { return(*(int *)0); }
1613
1614 #undef wrefresh
1615 int     wrefresh(
1616                 WINDOW  *win)
1617                 { return(*(int *)0); }
1618
1619 #undef wnoutrefresh
1620 int     wnoutrefresh(
1621                 WINDOW  *win)
1622                 { return(*(int *)0); }
1623
1624 /* ./lib_restart.c */
1625
1626 #undef def_shell_mode
1627 int     def_shell_mode(void)
1628                 { return(*(int *)0); }
1629
1630 #undef def_prog_mode
1631 int     def_prog_mode(void)
1632                 { return(*(int *)0); }
1633
1634 #undef restartterm
1635 int     restartterm(
1636                 const char *term, 
1637                 int     filenum, 
1638                 int     *errret)
1639                 { return(*(int *)0); }
1640
1641 #undef set_curterm
1642 TERMINAL *set_curterm(
1643                 TERMINAL *term)
1644                 { return(*(TERMINAL **)0); }
1645
1646 #undef del_curterm
1647 int     del_curterm(
1648                 TERMINAL *term)
1649                 { return(*(int *)0); }
1650
1651 /* ./lib_scanw.c */
1652
1653 #undef vwscanw
1654 int     vwscanw(
1655                 WINDOW  *win, 
1656                 const char *fmt, 
1657                 va_list argp)
1658                 { return(*(int *)0); }
1659
1660 #undef scanw
1661 int     scanw(
1662                 const char *fmt, 
1663                 ...)
1664                 { return(*(int *)0); }
1665
1666 #undef wscanw
1667 int     wscanw(
1668                 WINDOW  *win, 
1669                 const char *fmt, 
1670                 ...)
1671                 { return(*(int *)0); }
1672
1673 #undef mvscanw
1674 int     mvscanw(
1675                 int     y, 
1676                 int     x, 
1677                 const char *fmt, 
1678                 ...)
1679                 { return(*(int *)0); }
1680
1681 #undef mvwscanw
1682 int     mvwscanw(
1683                 WINDOW  *win, 
1684                 int     y, 
1685                 int     x, 
1686                 const char *fmt, 
1687                 ...)
1688                 { return(*(int *)0); }
1689
1690 /* ./lib_screen.c */
1691
1692 #include <sys/stat.h>
1693 #include <time.h>
1694
1695 #undef getwin
1696 WINDOW  *getwin(
1697                 FILE    *filep)
1698                 { return(*(WINDOW **)0); }
1699
1700 #undef putwin
1701 int     putwin(
1702                 WINDOW  *win, 
1703                 FILE    *filep)
1704                 { return(*(int *)0); }
1705
1706 #undef scr_restore
1707 int     scr_restore(
1708                 const char *file)
1709                 { return(*(int *)0); }
1710
1711 #undef scr_dump
1712 int     scr_dump(
1713                 const char *file)
1714                 { return(*(int *)0); }
1715
1716 #undef scr_init
1717 int     scr_init(
1718                 const char *file)
1719                 { return(*(int *)0); }
1720
1721 #undef scr_set
1722 int     scr_set(
1723                 const char *file)
1724                 { return(*(int *)0); }
1725
1726 /* ./lib_scroll.c */
1727
1728 #undef _nc_scroll_window
1729 void    _nc_scroll_window(
1730                 WINDOW  *win, 
1731                 int const n, 
1732                 short const top, 
1733                 short const bottom)
1734                 { /* void */ }
1735
1736 #undef wscrl
1737 int     wscrl(
1738                 WINDOW  *win, 
1739                 int     n)
1740                 { return(*(int *)0); }
1741
1742 /* ./lib_scrreg.c */
1743
1744 #undef wsetscrreg
1745 int     wsetscrreg(
1746                 WINDOW  *win, 
1747                 int     top, 
1748                 int     bottom)
1749                 { return(*(int *)0); }
1750
1751 /* ./lib_set_term.c */
1752
1753 #undef _nc_set_buffer
1754 void    _nc_set_buffer(
1755                 FILE    *ofp, 
1756                 bool    buffered)
1757                 { /* void */ }
1758
1759 #undef set_term
1760 SCREEN  *set_term(
1761                 SCREEN  *screen)
1762                 { return(*(SCREEN **)0); }
1763
1764 #undef delscreen
1765 void    delscreen(
1766                 SCREEN  *sp)
1767                 { /* void */ }
1768
1769 #undef rippedoff
1770 ripoff_t rippedoff[5];
1771 #undef rsp
1772 ripoff_t *rsp;
1773
1774 #undef _nc_setupscreen
1775 int     _nc_setupscreen(
1776                 short   slines, 
1777                 short const scolumns, 
1778                 FILE    *output)
1779                 { return(*(int *)0); }
1780
1781 #undef _nc_ripoffline
1782 int     _nc_ripoffline(
1783                 int     line, 
1784                 int     (*init)(
1785                 WINDOW  *p1, 
1786                 int     p2))
1787                 { return(*(int *)0); }
1788
1789 #undef ripoffline
1790 int     ripoffline(
1791                 int     line, 
1792                 int     (*init)(
1793                 WINDOW  *p1, 
1794                 int     p2))
1795                 { return(*(int *)0); }
1796
1797 /* ./lib_setup.c */
1798
1799 #include <sys/ioctl.h>
1800
1801 #undef use_env
1802 void    use_env(
1803                 bool    f)
1804                 { /* void */ }
1805
1806 #undef LINES
1807 int     LINES;
1808 #undef COLS
1809 int     COLS;
1810 #undef TABSIZE
1811 int     TABSIZE;
1812
1813 #undef _nc_get_screensize
1814 void    _nc_get_screensize(void)
1815                 { /* void */ }
1816
1817 #undef ttytype
1818 char    ttytype[256 ];
1819
1820 #undef setupterm
1821 int     setupterm(
1822                 const char *tname, 
1823                 int     Filedes, 
1824                 int     *errret)
1825                 { return(*(int *)0); }
1826
1827 /* ./lib_slk.c */
1828
1829 #undef _nc_slk_format
1830 int     _nc_slk_format;
1831
1832 #undef slk_label
1833 char    *slk_label(
1834                 int     n)
1835                 { return(*(char **)0); }
1836
1837 #undef slk_noutrefresh
1838 int     slk_noutrefresh(void)
1839                 { return(*(int *)0); }
1840
1841 #undef slk_refresh
1842 int     slk_refresh(void)
1843                 { return(*(int *)0); }
1844
1845 #undef slk_restore
1846 int     slk_restore(void)
1847                 { return(*(int *)0); }
1848
1849 #undef slk_set
1850 int     slk_set(
1851                 int     i, 
1852                 const char *astr, 
1853                 int     format)
1854                 { return(*(int *)0); }
1855
1856 #undef slk_touch
1857 int     slk_touch(void)
1858                 { return(*(int *)0); }
1859
1860 #undef slk_clear
1861 int     slk_clear(void)
1862                 { return(*(int *)0); }
1863
1864 #undef _nc_slk_initialize
1865 int     _nc_slk_initialize(
1866                 WINDOW  *stwin, 
1867                 int     cols)
1868                 { return(*(int *)0); }
1869
1870 #undef slk_init
1871 int     slk_init(
1872                 int     format)
1873                 { return(*(int *)0); }
1874
1875 #undef slk_attrset
1876 int     slk_attrset(
1877                 const attr_t attr)
1878                 { return(*(int *)0); }
1879
1880 #undef slk_attron
1881 int     slk_attron(
1882                 const attr_t attr)
1883                 { return(*(int *)0); }
1884
1885 #undef slk_attroff
1886 int     slk_attroff(
1887                 const attr_t attr)
1888                 { return(*(int *)0); }
1889
1890 #undef slk_attr
1891 attr_t  slk_attr(void)
1892                 { return(*(attr_t *)0); }
1893
1894 /* ./lib_termcap.c */
1895
1896 #include <termcap.h>
1897 #include <tic.h>
1898
1899 #undef PC
1900 char    PC;
1901 #undef UP
1902 char    *UP;
1903 #undef BC
1904 char    *BC;
1905 #undef ospeed
1906 short   ospeed;
1907
1908 #undef tgetent
1909 int     tgetent(
1910                 char    *bufp, 
1911                 const char *name)
1912                 { return(*(int *)0); }
1913
1914 #if 0
1915
1916 #include <capdefaults.c>
1917
1918 #endif
1919
1920 #undef tgetflag
1921 int     tgetflag(
1922                 const char *id)
1923                 { return(*(int *)0); }
1924
1925 #undef tgetnum
1926 int     tgetnum(
1927                 const char *id)
1928                 { return(*(int *)0); }
1929
1930 #undef tgetstr
1931 char    *tgetstr(
1932                 const char *id, 
1933                 char    **area)
1934                 { return(*(char **)0); }
1935
1936 #undef tgoto
1937 char    *tgoto(
1938                 const char *string, 
1939                 int     x, 
1940                 int     y)
1941                 { return(*(char **)0); }
1942
1943 /* ./lib_ti.c */
1944
1945 #undef tigetflag
1946 int     tigetflag(
1947                 const char *str)
1948                 { return(*(int *)0); }
1949
1950 #undef tigetnum
1951 int     tigetnum(
1952                 const char *str)
1953                 { return(*(int *)0); }
1954
1955 #undef tigetstr
1956 char    *tigetstr(
1957                 const char *str)
1958                 { return(*(char **)0); }
1959
1960 /* ./lib_touch.c */
1961
1962 #undef is_linetouched
1963 int     is_linetouched(
1964                 WINDOW  *win, 
1965                 int     line)
1966                 { return(*(int *)0); }
1967
1968 #undef is_wintouched
1969 int     is_wintouched(
1970                 WINDOW  *win)
1971                 { return(*(int *)0); }
1972
1973 #undef wtouchln
1974 int     wtouchln(
1975                 WINDOW  *win, 
1976                 int     y, 
1977                 int     n, 
1978                 int     changed)
1979                 { return(*(int *)0); }
1980
1981 /* ./lib_tparm.c */
1982
1983 typedef union {
1984         unsigned int    num;
1985         char           *str;
1986 } stack_frame;
1987
1988 #undef tparm
1989 char    *tparm(
1990                 const char *string, 
1991                 ...)
1992                 { return(*(char **)0); }
1993
1994 /* ./lib_tputs.c */
1995
1996 #undef delay_output
1997 int     delay_output(
1998                 int     ms)
1999                 { return(*(int *)0); }
2000
2001 #undef _nc_outch
2002 int     _nc_outch(
2003                 int     ch)
2004                 { return(*(int *)0); }
2005
2006 #undef putp
2007 int     putp(
2008                 const char *string)
2009                 { return(*(int *)0); }
2010
2011 #undef tputs
2012 int     tputs(
2013                 const char *string, 
2014                 int     affcnt, 
2015                 int     (*outc)(
2016                 int     p1))
2017                 { return(*(int *)0); }
2018
2019 /* ./lib_trace.c */
2020
2021 #include <fcntl.h>
2022
2023 #undef _nc_tracing
2024 unsigned _nc_tracing;
2025 #undef _nc_tputs_trace
2026 const char *_nc_tputs_trace = {0};
2027 #undef _nc_outchars
2028 long    _nc_outchars;
2029 #undef _nc_optimize_enable
2030 int     _nc_optimize_enable;
2031
2032 #undef trace
2033 void    trace(
2034                 const unsigned int tracelevel)
2035                 { /* void */ }
2036
2037 #undef _nc_visbuf
2038 const char *_nc_visbuf(
2039                 const char *buf)
2040                 { return(*(const char **)0); }
2041
2042 #undef _tracef
2043 void    _tracef(
2044                 const char *fmt, 
2045                 ...)
2046                 { /* void */ }
2047
2048 /* ./lib_traceatr.c */
2049
2050 #undef _traceattr
2051 char    *_traceattr(
2052                 attr_t  newmode)
2053                 { return(*(char **)0); }
2054
2055 #undef _tracechtype
2056 char    *_tracechtype(
2057                 chtype  ch)
2058                 { return(*(char **)0); }
2059
2060 /* ./lib_tracechr.c */
2061
2062 #undef _tracechar
2063 char    *_tracechar(
2064                 const unsigned char ch)
2065                 { return(*(char **)0); }
2066
2067 /* ./lib_tracedmp.c */
2068
2069 #undef _tracedump
2070 void    _tracedump(
2071                 const char *name, 
2072                 WINDOW  *win)
2073                 { /* void */ }
2074
2075 /* ./lib_tracemse.c */
2076
2077 #undef _tracemouse
2078 char    *_tracemouse(
2079                 MEVENT const *ep)
2080                 { return(*(char **)0); }
2081
2082 /* ./lib_tstp.c */
2083
2084 #include <signal.h>
2085
2086 typedef struct sigaction sigaction_t;
2087
2088 #undef _nc_signal_handler
2089 void    _nc_signal_handler(
2090                 bool    enable)
2091                 { /* void */ }
2092
2093 /* ./lib_twait.c */
2094
2095 #undef _nc_timed_wait
2096 int     _nc_timed_wait(
2097                 int     mode, 
2098                 int     milliseconds, 
2099                 int     *timeleft)
2100                 { return(*(int *)0); }
2101
2102 /* ./lib_unctrl.c */
2103
2104 #undef unctrl
2105 char    *unctrl(
2106                  chtype uch)
2107                 { return(*(char **)0); }
2108
2109 /* ./lib_vidattr.c */
2110
2111 #undef vidputs
2112 int     vidputs(
2113                 attr_t  newmode, 
2114                 int     (*outc)(
2115                 int     p1))
2116                 { return(*(int *)0); }
2117
2118 #undef vidattr
2119 int     vidattr(
2120                 attr_t  newmode)
2121                 { return(*(int *)0); }
2122
2123 #undef termattrs
2124 attr_t  termattrs(void)
2125                 { return(*(attr_t *)0); }
2126
2127 /* ./lib_window.c */
2128
2129 #undef _nc_synchook
2130 void    _nc_synchook(
2131                 WINDOW  *win)
2132                 { /* void */ }
2133
2134 #undef mvderwin
2135 int     mvderwin(
2136                 WINDOW  *win, 
2137                 int     y, 
2138                 int     x)
2139                 { return(*(int *)0); }
2140
2141 #undef syncok
2142 int     syncok(
2143                 WINDOW  *win, 
2144                 bool    bf)
2145                 { return(*(int *)0); }
2146
2147 #undef wsyncup
2148 void    wsyncup(
2149                 WINDOW  *win)
2150                 { /* void */ }
2151
2152 #undef wsyncdown
2153 void    wsyncdown(
2154                 WINDOW  *win)
2155                 { /* void */ }
2156
2157 #undef wcursyncup
2158 void    wcursyncup(
2159                 WINDOW  *win)
2160                 { /* void */ }
2161
2162 #undef dupwin
2163 WINDOW  *dupwin(
2164                 WINDOW  *win)
2165                 { return(*(WINDOW **)0); }
2166
2167 /* ./names.c */
2168
2169 #undef boolnames
2170 char    *const boolnames[] = {0};
2171 #undef boolfnames
2172 char    *const boolfnames[] = {0};
2173 #undef numnames
2174 char    *const numnames[] = {0};
2175 #undef numfnames
2176 char    *const numfnames[] = {0};
2177 #undef strnames
2178 char    *const strnames[] = {0};
2179 #undef strfnames
2180 char    *const strfnames[] = {0};
2181
2182 /* ./codes.c */
2183 #undef boolcodes
2184 char    *const boolcodes[] = {0};
2185 #undef numcodes
2186 char    *const numcodes[] = {0};
2187 #undef strcodes
2188 char    *const strcodes[] = {0};
2189
2190 /* ./read_entry.c */
2191 #undef cur_term
2192 TERMINAL *cur_term;
2193
2194 #undef _nc_tic_dir
2195 char    *_nc_tic_dir(
2196                 char    *path)
2197                 { return(*(char **)0); }
2198
2199 #undef _nc_read_file_entry
2200 int     _nc_read_file_entry(
2201                 const char *const filename, 
2202                 TERMTYPE *ptr)
2203                 { return(*(int *)0); }
2204
2205 #undef _nc_read_entry
2206 int     _nc_read_entry(
2207                 const char *const tn, 
2208                 char    *const filename, 
2209                 TERMTYPE *const tp)
2210                 { return(*(int *)0); }
2211
2212 #undef _nc_first_name
2213 char    *_nc_first_name(
2214                 const char *const sp)
2215                 { return(*(char **)0); }
2216
2217 #undef _nc_name_match
2218 int     _nc_name_match(
2219                 const char *const namelst, 
2220                 const char *const name, 
2221                 const char *const delim)
2222                 { return(*(int *)0); }
2223
2224 /* ./read_termcap.c */
2225
2226 #include <term_entry.h>
2227
2228 #undef _nc_read_termcap_entry
2229 int     _nc_read_termcap_entry(
2230                 const char *const tn, 
2231                 TERMTYPE *const tp)
2232                 { return(*(int *)0); }
2233
2234 /* ./write_entry.c */
2235
2236 #undef _nc_set_writedir
2237 void    _nc_set_writedir(
2238                 char    *dir)
2239                 { /* void */ }
2240
2241 #undef _nc_write_entry
2242 void    _nc_write_entry(
2243                 TERMTYPE *const tp)
2244                 { /* void */ }
2245
2246 #undef _nc_tic_written
2247 int     _nc_tic_written(void)
2248                 { return(*(int *)0); }
2249
2250 /* ./sigaction.c */
2251
2252 #undef _nc_sigaction
2253 void    _nc_sigaction(void)
2254                 { /* void */ }
2255
2256 /* ./vsscanf.c */
2257
2258 #undef _nc_vsscanf
2259 void    _nc_vsscanf(void)
2260                 { /* void */ }
2261
2262 /* ./alloc_entry.c */
2263
2264 #undef _nc_init_entry
2265 void    _nc_init_entry(
2266                 TERMTYPE *const tp)
2267                 { /* void */ }
2268
2269 #undef _nc_save_str
2270 char    *_nc_save_str(
2271                 const char *const string)
2272                 { return(*(char **)0); }
2273
2274 #undef _nc_wrap_entry
2275 void    _nc_wrap_entry(
2276                 ENTRY   *const ep)
2277                 { /* void */ }
2278
2279 #undef _nc_merge_entry
2280 void    _nc_merge_entry(
2281                 TERMTYPE *const to, 
2282                 TERMTYPE *const from)
2283                 { /* void */ }
2284
2285 /* ./captoinfo.c */
2286
2287 #undef _nc_captoinfo
2288 char    *_nc_captoinfo(
2289                  char   *const cap, 
2290                  char   *s, 
2291                 int const parametrized)
2292                 { return(*(char **)0); }
2293
2294 #undef _nc_infotocap
2295 char    *_nc_infotocap(
2296                  char   *const cap, 
2297                  char   *str, 
2298                 int const parametrized)
2299                 { return(*(char **)0); }
2300
2301 /* ./comp_captab.c */
2302
2303 #include <hashsize.h>
2304
2305 #undef _nc_info_hash_table
2306 const struct name_table_entry *const _nc_info_hash_table[991] = {0};
2307 #undef _nc_cap_hash_table
2308 const struct name_table_entry *const _nc_cap_hash_table[991] = {0};
2309 #undef _nc_capalias_table
2310 const struct alias _nc_capalias_table[] = {0};
2311 #undef _nc_infoalias_table
2312 const struct alias _nc_infoalias_table[] = {0};
2313
2314 #undef _nc_get_table
2315 const struct name_table_entry *_nc_get_table(
2316                 bool    termcap)
2317                 { return(*(const struct name_table_entry **)0); }
2318
2319 /* ./comp_error.c */
2320
2321 #undef _nc_suppress_warnings
2322 bool    _nc_suppress_warnings;
2323
2324 #undef _nc_set_source
2325 void    _nc_set_source(
2326                 const char *const name)
2327                 { /* void */ }
2328
2329 #undef _nc_set_type
2330 void    _nc_set_type(
2331                 const char *const name)
2332                 { /* void */ }
2333
2334 #undef _nc_get_type
2335 void    _nc_get_type(
2336                 char    *name)
2337                 { /* void */ }
2338
2339 #undef _nc_warning
2340 void    _nc_warning(
2341                 const char *const fmt, 
2342                 ...)
2343                 { /* void */ }
2344
2345 #undef _nc_err_abort
2346 void    _nc_err_abort(
2347                 const char *const fmt, 
2348                 ...)
2349                 { /* void */ }
2350
2351 #undef _nc_syserr_abort
2352 void    _nc_syserr_abort(
2353                 const char *const fmt, 
2354                 ...)
2355                 { /* void */ }
2356
2357 /* ./comp_hash.c */
2358
2359 #undef _nc_find_entry
2360 struct name_table_entry const *_nc_find_entry(
2361                 const char *string, 
2362                 const struct name_table_entry *const *hash_table)
2363                 { return(*(struct name_table_entry const **)0); }
2364
2365 #undef _nc_find_type_entry
2366 struct name_table_entry const *_nc_find_type_entry(
2367                 const char *string, 
2368                 int     type, 
2369                 const struct name_table_entry *table)
2370                 { return(*(struct name_table_entry const **)0); }
2371
2372 /* ./comp_parse.c */
2373
2374 #undef _nc_head
2375 ENTRY   *_nc_head;
2376 #undef _nc_tail
2377 ENTRY   *_nc_tail;
2378
2379 #undef _nc_free_entries
2380 void    _nc_free_entries(
2381                 ENTRY   *head)
2382                 { /* void */ }
2383
2384 #undef _nc_entry_match
2385 bool    _nc_entry_match(
2386                 char    *n1, 
2387                 char    *n2)
2388                 { return(*(bool *)0); }
2389
2390 #undef _nc_read_entry_source
2391 void    _nc_read_entry_source(
2392                 FILE    *fp, 
2393                 char    *buf, 
2394                 int     literal, 
2395                 bool    silent, 
2396                 bool    (*hook)(
2397                 ENTRY   *p1))
2398                 { /* void */ }
2399
2400 #undef _nc_resolve_uses
2401 int     _nc_resolve_uses(void)
2402                 { return(*(int *)0); }
2403
2404 /* ./comp_scan.c */
2405
2406 #undef _nc_syntax
2407 int     _nc_syntax;
2408 #undef _nc_curr_line
2409 int     _nc_curr_line;
2410 #undef _nc_curr_col
2411 int     _nc_curr_col;
2412 #undef _nc_curr_file_pos
2413 long    _nc_curr_file_pos;
2414 #undef _nc_comment_start
2415 long    _nc_comment_start;
2416 #undef _nc_comment_end
2417 long    _nc_comment_end;
2418 #undef _nc_start_line
2419 long    _nc_start_line;
2420
2421 #undef _nc_get_token
2422 int     _nc_get_token(void)
2423                 { return(*(int *)0); }
2424
2425 #undef _nc_push_token
2426 void    _nc_push_token(
2427                 int     class)
2428                 { /* void */ }
2429
2430 #undef _nc_panic_mode
2431 void    _nc_panic_mode(
2432                 char    ch)
2433                 { /* void */ }
2434
2435 #undef _nc_reset_input
2436 void    _nc_reset_input(
2437                 FILE    *fp, 
2438                 char    *buf)
2439                 { /* void */ }
2440
2441 /* ./parse_entry.c */
2442
2443 #undef _nc_curr_token
2444 struct token _nc_curr_token;
2445
2446 #undef _nc_parse_entry
2447 int     _nc_parse_entry(
2448                 struct entry *entryp, 
2449                 int     literal, 
2450                 bool    silent)
2451                 { return(*(int *)0); }
2452
2453 #undef _nc_capcmp
2454 int     _nc_capcmp(
2455                 const char *s, 
2456                 const char *t)
2457                 { return(*(int *)0); }
2458
2459 typedef struct {const char *from; const char *to;} assoc;
2460
2461 /* ./lib_dft_fgbg.c */
2462
2463 #undef use_default_colors
2464 int     use_default_colors(void)
2465                 { return(*(int *)0); }
2466
2467 /* ./lib_freeall.c */
2468
2469 #undef _nc_free_termtype
2470 void    _nc_free_termtype(
2471                 struct termtype *p, 
2472                 int     base)
2473                 { /* void */ }
2474
2475 #undef _nc_freeall
2476 void    _nc_freeall(void)
2477                 { /* void */ }
2478
2479 #undef _nc_free_and_exit
2480 void    _nc_free_and_exit(
2481                 int     code)
2482                 { /* void */ }
2483
2484 /* ./resizeterm.c */
2485
2486 #undef resizeterm
2487 int     resizeterm(
2488                 int     ToLines, 
2489                 int     ToCols)
2490                 { return(*(int *)0); }
2491
2492 /* ./wresize.c */
2493
2494 #undef wresize
2495 int     wresize(
2496                 WINDOW  *win, 
2497                 int     ToLines, 
2498                 int     ToCols)
2499                 { return(*(int *)0); }
2500
2501 /* ./lib_adabind.c */
2502
2503 #undef _nc_ada_getmaxyx
2504 int     _nc_ada_getmaxyx(
2505                 WINDOW  *win, 
2506                 int     *y, 
2507                 int     *x)
2508                 { return(*(int *)0); }
2509
2510 #undef _nc_ada_getbegyx
2511 int     _nc_ada_getbegyx(
2512                 WINDOW  *win, 
2513                 int     *y, 
2514                 int     *x)
2515                 { return(*(int *)0); }
2516
2517 #undef _nc_ada_getyx
2518 int     _nc_ada_getyx(
2519                 WINDOW  *win, 
2520                 int     *y, 
2521                 int     *x)
2522                 { return(*(int *)0); }
2523
2524 #undef _nc_ada_getparyx
2525 int     _nc_ada_getparyx(
2526                 WINDOW  *win, 
2527                 int     *y, 
2528                 int     *x)
2529                 { return(*(int *)0); }
2530
2531 #undef _nc_ada_isscroll
2532 int     _nc_ada_isscroll(
2533                 WINDOW  *win)
2534                 { return(*(int *)0); }
2535
2536 #undef _nc_ada_coord_transform
2537 int     _nc_ada_coord_transform(
2538                 WINDOW  *win, 
2539                 int     *Y, 
2540                 int     *X, 
2541                 int     dir)
2542                 { return(*(int *)0); }
2543
2544 #undef _nc_ada_mouse_event
2545 void    _nc_ada_mouse_event(
2546                 mmask_t m, 
2547                 int     *b, 
2548                 int     *s)
2549                 { /* void */ }
2550
2551 #undef _nc_ada_mouse_mask
2552 int     _nc_ada_mouse_mask(
2553                 int     button, 
2554                 int     state, 
2555                 mmask_t *mask)
2556                 { return(*(int *)0); }
2557
2558 #undef _nc_ada_unregister_mouse
2559 void    _nc_ada_unregister_mouse(void)
2560                 { /* void */ }