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