diff options
Diffstat (limited to 'contrib/ncurses/ncurses/llib-ltinfow')
-rw-r--r-- | contrib/ncurses/ncurses/llib-ltinfow | 1559 |
1 files changed, 1559 insertions, 0 deletions
diff --git a/contrib/ncurses/ncurses/llib-ltinfow b/contrib/ncurses/ncurses/llib-ltinfow new file mode 100644 index 0000000..f219698 --- /dev/null +++ b/contrib/ncurses/ncurses/llib-ltinfow @@ -0,0 +1,1559 @@ +/**************************************************************************** + * Copyright (c) 2012,2013 Free Software Foundation, Inc. * + * * + * Permission is hereby granted, free of charge, to any person obtaining a * + * copy of this software and associated documentation files (the * + * "Software"), to deal in the Software without restriction, including * + * without limitation the rights to use, copy, modify, merge, publish, * + * distribute, distribute with modifications, sublicense, and/or sell * + * copies of the Software, and to permit persons to whom the Software is * + * furnished to do so, subject to the following conditions: * + * * + * The above copyright notice and this permission notice shall be included * + * in all copies or substantial portions of the Software. * + * * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * + * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * + * * + * Except as contained in this notice, the name(s) of the above copyright * + * holders shall not be used in advertising or otherwise to promote the * + * sale, use or other dealings in this Software without prior written * + * authorization. * + ****************************************************************************/ + +/**************************************************************************** + * Author: Thomas E. Dickey 2012 * + ****************************************************************************/ +/* LINTLIBRARY */ + +/* ./tinfo/access.c */ + +#include <curses.priv.h> +#include <ctype.h> +#include <tic.h> + +#undef _nc_rootname +char *_nc_rootname( + char *path) + { return(*(char **)0); } + +#undef _nc_is_abs_path +NCURSES_BOOL _nc_is_abs_path( + const char *path) + { return(*(NCURSES_BOOL *)0); } + +#undef _nc_pathlast +unsigned _nc_pathlast( + const char *path) + { return(*(unsigned *)0); } + +#undef _nc_basename +char *_nc_basename( + char *path) + { return(*(char **)0); } + +#undef _nc_access +int _nc_access( + const char *path, + int mode) + { return(*(int *)0); } + +#undef _nc_is_dir_path +NCURSES_BOOL _nc_is_dir_path( + const char *path) + { return(*(NCURSES_BOOL *)0); } + +#undef _nc_is_file_path +NCURSES_BOOL _nc_is_file_path( + const char *path) + { return(*(NCURSES_BOOL *)0); } + +#undef _nc_env_access +int _nc_env_access(void) + { return(*(int *)0); } + +/* ./tinfo/add_tries.c */ + +#undef _nc_add_to_try +int _nc_add_to_try( + TRIES **tree, + const char *str, + unsigned code) + { return(*(int *)0); } + +/* ./tinfo/alloc_ttype.c */ + +#undef _nc_align_termtype +void _nc_align_termtype( + TERMTYPE *to, + TERMTYPE *from) + { /* void */ } + +#undef _nc_copy_termtype +void _nc_copy_termtype( + TERMTYPE *dst, + const TERMTYPE *src) + { /* void */ } + +/* ./codes.c */ + +#undef boolcodes +char *const boolcodes[] = {0}; +#undef numcodes +char *const numcodes[] = {0}; +#undef strcodes +char *const strcodes[] = {0}; + +/* ./comp_captab.c */ + +#include <hashsize.h> + +#undef _nc_get_table +const struct name_table_entry *_nc_get_table( + NCURSES_BOOL termcap) + { return(*(const struct name_table_entry **)0); } + +#undef _nc_get_hash_table +const HashValue *_nc_get_hash_table( + NCURSES_BOOL termcap) + { return(*(const HashValue **)0); } + +#undef _nc_get_alias_table +const struct alias *_nc_get_alias_table( + NCURSES_BOOL termcap) + { return(*(const struct alias **)0); } + +#undef _nc_get_hash_info +const HashData *_nc_get_hash_info( + NCURSES_BOOL termcap) + { return(*(const HashData **)0); } + +/* ./tinfo/comp_error.c */ + +#undef _nc_suppress_warnings +NCURSES_BOOL _nc_suppress_warnings; +#undef _nc_curr_line +int _nc_curr_line; +#undef _nc_curr_col +int _nc_curr_col; + +#undef _nc_get_source +const char *_nc_get_source(void) + { return(*(const char **)0); } + +#undef _nc_set_source +void _nc_set_source( + const char *const name) + { /* void */ } + +#undef _nc_set_type +void _nc_set_type( + const char *const name) + { /* void */ } + +#undef _nc_get_type +void _nc_get_type( + char *name) + { /* void */ } + +#undef _nc_warning +void _nc_warning( + const char *const fmt, + ...) + { /* void */ } + +#undef _nc_err_abort +void _nc_err_abort( + const char *const fmt, + ...) + { /* void */ } + +#undef _nc_syserr_abort +void _nc_syserr_abort( + const char *const fmt, + ...) + { /* void */ } + +/* ./tinfo/comp_hash.c */ + +#undef _nc_find_entry +struct name_table_entry const *_nc_find_entry( + const char *string, + const HashValue *hash_table) + { return(*(struct name_table_entry const **)0); } + +#undef _nc_find_type_entry +struct name_table_entry const *_nc_find_type_entry( + const char *string, + int type, + NCURSES_BOOL termcap) + { return(*(struct name_table_entry const **)0); } + +/* ./tinfo/db_iterator.c */ + +#include <time.h> + +#undef _nc_tic_dir +const char *_nc_tic_dir( + const char *path) + { return(*(const char **)0); } + +#undef _nc_keep_tic_dir +void _nc_keep_tic_dir( + const char *path) + { /* void */ } + +#undef _nc_last_db +void _nc_last_db(void) + { /* void */ } + +#undef _nc_next_db +const char *_nc_next_db( + DBDIRS *state, + int *offset) + { return(*(const char **)0); } + +#undef _nc_first_db +void _nc_first_db( + DBDIRS *state, + int *offset) + { /* void */ } + +/* ./tinfo/doalloc.c */ + +#undef _nc_doalloc +void *_nc_doalloc( + void *oldp, + size_t amount) + { return(*(void **)0); } + +/* ./tinfo/entries.c */ + +#undef _nc_head +ENTRY *_nc_head; +#undef _nc_tail +ENTRY *_nc_tail; + +#undef _nc_free_entry +void _nc_free_entry( + ENTRY *headp, + TERMTYPE *tterm) + { /* void */ } + +#undef _nc_free_entries +void _nc_free_entries( + ENTRY *headp) + { /* void */ } + +#undef _nc_delink_entry +ENTRY *_nc_delink_entry( + ENTRY *headp, + TERMTYPE *tterm) + { return(*(ENTRY **)0); } + +#undef _nc_leaks_tinfo +void _nc_leaks_tinfo(void) + { /* void */ } + +/* ./fallback.c */ + +#undef _nc_fallback +const TERMTYPE *_nc_fallback( + const char *name) + { return(*(const TERMTYPE **)0); } + +/* ./tinfo/free_ttype.c */ + +#undef _nc_free_termtype +void _nc_free_termtype( + TERMTYPE *ptr) + { /* void */ } + +#undef _nc_user_definable +NCURSES_BOOL _nc_user_definable; + +#undef use_extended_names +int use_extended_names( + NCURSES_BOOL flag) + { return(*(int *)0); } + +/* ./tinfo/getenv_num.c */ + +#undef _nc_getenv_num +int _nc_getenv_num( + const char *name) + { return(*(int *)0); } + +#undef _nc_setenv_num +void _nc_setenv_num( + const char *name, + int value) + { /* void */ } + +/* ./tinfo/home_terminfo.c */ + +#undef _nc_home_terminfo +char *_nc_home_terminfo(void) + { return(*(char **)0); } + +/* ./tinfo/init_keytry.c */ + +#if 0 + +#include <init_keytry.h> + +#undef _nc_tinfo_fkeys +const struct tinfo_fkeys _nc_tinfo_fkeys[] = {0}; + +#endif + +#undef _nc_init_keytry +void _nc_init_keytry( + SCREEN *sp) + { /* void */ } + +/* ./tinfo/lib_acs.c */ + +#undef acs_map +chtype acs_map[128]; + +#undef _nc_init_acs_sp +void _nc_init_acs_sp( + SCREEN *sp) + { /* void */ } + +#undef _nc_init_acs +void _nc_init_acs(void) + { /* void */ } + +/* ./tinfo/lib_baudrate.c */ + +#include <termcap.h> + +struct speed { + int s; + int sp; +}; + +#undef _nc_baudrate +int _nc_baudrate( + int OSpeed) + { return(*(int *)0); } + +#undef _nc_ospeed +int _nc_ospeed( + int BaudRate) + { return(*(int *)0); } + +#undef baudrate_sp +int baudrate_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef baudrate +int baudrate(void) + { return(*(int *)0); } + +/* ./tinfo/lib_cur_term.c */ + +#undef cur_term +TERMINAL *cur_term; + +#undef set_curterm_sp +TERMINAL *set_curterm_sp( + SCREEN *sp, + TERMINAL *termp) + { return(*(TERMINAL **)0); } + +#undef set_curterm +TERMINAL *set_curterm( + TERMINAL *termp) + { return(*(TERMINAL **)0); } + +#undef del_curterm_sp +int del_curterm_sp( + SCREEN *sp, + TERMINAL *termp) + { return(*(int *)0); } + +#undef del_curterm +int del_curterm( + TERMINAL *termp) + { return(*(int *)0); } + +/* ./tinfo/lib_data.c */ + +#undef stdscr +WINDOW *stdscr; +#undef curscr +WINDOW *curscr; +#undef newscr +WINDOW *newscr; +#undef _nc_screen_chain +SCREEN *_nc_screen_chain; +#undef SP +SCREEN *SP; +#undef _nc_globals +NCURSES_GLOBALS _nc_globals; +#undef _nc_prescreen +NCURSES_PRESCREEN _nc_prescreen; + +#undef _nc_screen_of +SCREEN *_nc_screen_of( + WINDOW *win) + { return(*(SCREEN **)0); } + +/* ./tinfo/lib_has_cap.c */ + +#undef has_ic_sp +NCURSES_BOOL has_ic_sp( + SCREEN *sp) + { return(*(NCURSES_BOOL *)0); } + +#undef has_ic +NCURSES_BOOL has_ic(void) + { return(*(NCURSES_BOOL *)0); } + +#undef has_il_sp +NCURSES_BOOL has_il_sp( + SCREEN *sp) + { return(*(NCURSES_BOOL *)0); } + +#undef has_il +NCURSES_BOOL has_il(void) + { return(*(NCURSES_BOOL *)0); } + +/* ./tinfo/lib_kernel.c */ + +#undef erasechar_sp +char erasechar_sp( + SCREEN *sp) + { return(*(char *)0); } + +#undef erasechar +char erasechar(void) + { return(*(char *)0); } + +#undef killchar_sp +char killchar_sp( + SCREEN *sp) + { return(*(char *)0); } + +#undef killchar +char killchar(void) + { return(*(char *)0); } + +#undef flushinp_sp +int flushinp_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef flushinp +int flushinp(void) + { return(*(int *)0); } + +/* ./lib_keyname.c */ + +struct kn { short offset; int code; }; + +#undef keyname_sp +char *keyname_sp( + SCREEN *sp, + int c) + { return(*(char **)0); } + +#undef keyname +char *keyname( + int c) + { return(*(char **)0); } + +/* ./tinfo/lib_longname.c */ + +#undef longname +char *longname(void) + { return(*(char **)0); } + +/* ./tinfo/lib_napms.c */ + +#include <sys/time.h> + +#undef napms_sp +int napms_sp( + SCREEN *sp, + int ms) + { return(*(int *)0); } + +#undef napms +int napms( + int ms) + { return(*(int *)0); } + +/* ./tinfo/lib_options.c */ + +#undef idlok +int idlok( + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef idcok +void idcok( + WINDOW *win, + NCURSES_BOOL flag) + { /* void */ } + +#undef halfdelay_sp +int halfdelay_sp( + SCREEN *sp, + int t) + { return(*(int *)0); } + +#undef halfdelay +int halfdelay( + int t) + { return(*(int *)0); } + +#undef nodelay +int nodelay( + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef notimeout +int notimeout( + WINDOW *win, + NCURSES_BOOL f) + { return(*(int *)0); } + +#undef wtimeout +void wtimeout( + WINDOW *win, + int delay) + { /* void */ } + +#undef keypad +int keypad( + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef meta +int meta( + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef curs_set_sp +int curs_set_sp( + SCREEN *sp, + int vis) + { return(*(int *)0); } + +#undef curs_set +int curs_set( + int vis) + { return(*(int *)0); } + +#undef typeahead_sp +int typeahead_sp( + SCREEN *sp, + int fd) + { return(*(int *)0); } + +#undef typeahead +int typeahead( + int fd) + { return(*(int *)0); } + +#undef has_key_sp +int has_key_sp( + SCREEN *sp, + int keycode) + { return(*(int *)0); } + +#undef has_key +int has_key( + int keycode) + { return(*(int *)0); } + +#undef _nc_putp_flush_sp +int _nc_putp_flush_sp( + SCREEN *sp, + const char *name, + const char *value) + { return(*(int *)0); } + +#undef _nc_keypad +int _nc_keypad( + SCREEN *sp, + int flag) + { return(*(int *)0); } + +/* ./tinfo/lib_raw.c */ + +#undef raw_sp +int raw_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef raw +int raw(void) + { return(*(int *)0); } + +#undef cbreak_sp +int cbreak_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef cbreak +int cbreak(void) + { return(*(int *)0); } + +#undef qiflush_sp +void qiflush_sp( + SCREEN *sp) + { /* void */ } + +#undef qiflush +void qiflush(void) + { /* void */ } + +#undef noraw_sp +int noraw_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef noraw +int noraw(void) + { return(*(int *)0); } + +#undef nocbreak_sp +int nocbreak_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef nocbreak +int nocbreak(void) + { return(*(int *)0); } + +#undef noqiflush_sp +void noqiflush_sp( + SCREEN *sp) + { /* void */ } + +#undef noqiflush +void noqiflush(void) + { /* void */ } + +#undef intrflush_sp +int intrflush_sp( + SCREEN *sp, + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef intrflush +int intrflush( + WINDOW *win, + NCURSES_BOOL flag) + { return(*(int *)0); } + +/* ./tinfo/lib_setup.c */ + +#include <locale.h> +#include <sys/ioctl.h> +#include <langinfo.h> + +#undef ttytype +char ttytype[256]; +#undef LINES +int LINES; +#undef COLS +int COLS; +#undef TABSIZE +int TABSIZE; + +#undef set_tabsize_sp +int set_tabsize_sp( + SCREEN *sp, + int value) + { return(*(int *)0); } + +#undef set_tabsize +int set_tabsize( + int value) + { return(*(int *)0); } + +#undef _nc_handle_sigwinch +int _nc_handle_sigwinch( + SCREEN *sp) + { return(*(int *)0); } + +#undef use_env_sp +void use_env_sp( + SCREEN *sp, + NCURSES_BOOL f) + { /* void */ } + +#undef use_tioctl_sp +void use_tioctl_sp( + SCREEN *sp, + NCURSES_BOOL f) + { /* void */ } + +#undef use_env +void use_env( + NCURSES_BOOL f) + { /* void */ } + +#undef use_tioctl +void use_tioctl( + NCURSES_BOOL f) + { /* void */ } + +#undef _nc_get_screensize +void _nc_get_screensize( + SCREEN *sp, + int *linep, + int *colp) + { /* void */ } + +#undef _nc_update_screensize +void _nc_update_screensize( + SCREEN *sp) + { /* void */ } + +#undef _nc_setup_tinfo +int _nc_setup_tinfo( + const char *const tn, + TERMTYPE *const tp) + { return(*(int *)0); } + +#undef _nc_tinfo_cmdch +void _nc_tinfo_cmdch( + TERMINAL *termp, + int proto) + { /* void */ } + +#undef _nc_get_locale +char *_nc_get_locale(void) + { return(*(char **)0); } + +#undef _nc_unicode_locale +int _nc_unicode_locale(void) + { return(*(int *)0); } + +#undef _nc_locale_breaks_acs +int _nc_locale_breaks_acs( + TERMINAL *termp) + { return(*(int *)0); } + +#undef _nc_setupterm +int _nc_setupterm( + char *tname, + int Filedes, + int *errret, + int reuse) + { return(*(int *)0); } + +#undef new_prescr +SCREEN *new_prescr(void) + { return(*(SCREEN **)0); } + +#undef setupterm +int setupterm( + char *tname, + int Filedes, + int *errret) + { return(*(int *)0); } + +/* ./tinfo/lib_termcap.c */ + +#undef UP +char *UP; +#undef BC +char *BC; + +#undef tgetent_sp +int tgetent_sp( + SCREEN *sp, + char *bufp, + const char *name) + { return(*(int *)0); } + +#if 0 + +#include <capdefaults.c> + +#endif + +#undef tgetent +int tgetent( + char *bufp, + const char *name) + { return(*(int *)0); } + +#undef tgetflag_sp +int tgetflag_sp( + SCREEN *sp, + char *id) + { return(*(int *)0); } + +#undef tgetflag +int tgetflag( + char *id) + { return(*(int *)0); } + +#undef tgetnum_sp +int tgetnum_sp( + SCREEN *sp, + char *id) + { return(*(int *)0); } + +#undef tgetnum +int tgetnum( + char *id) + { return(*(int *)0); } + +#undef tgetstr_sp +char *tgetstr_sp( + SCREEN *sp, + char *id, + char **area) + { return(*(char **)0); } + +#undef tgetstr +char *tgetstr( + char *id, + char **area) + { return(*(char **)0); } + +/* ./tinfo/lib_termname.c */ + +#undef termname_sp +char *termname_sp( + SCREEN *sp) + { return(*(char **)0); } + +#undef termname +char *termname(void) + { return(*(char **)0); } + +/* ./tinfo/lib_tgoto.c */ + +#undef tgoto +char *tgoto( + const char *string, + int x, + int y) + { return(*(char **)0); } + +/* ./tinfo/lib_ti.c */ + +#undef tigetflag_sp +int tigetflag_sp( + SCREEN *sp, + char *str) + { return(*(int *)0); } + +#undef tigetflag +int tigetflag( + char *str) + { return(*(int *)0); } + +#undef tigetnum_sp +int tigetnum_sp( + SCREEN *sp, + char *str) + { return(*(int *)0); } + +#undef tigetnum +int tigetnum( + char *str) + { return(*(int *)0); } + +#undef tigetstr_sp +char *tigetstr_sp( + SCREEN *sp, + char *str) + { return(*(char **)0); } + +#undef tigetstr +char *tigetstr( + char *str) + { return(*(char **)0); } + +/* ./tinfo/lib_tparm.c */ + +#undef _nc_tparm_err +int _nc_tparm_err; + +#undef _nc_tparm_analyze +int _nc_tparm_analyze( + const char *string, + char *p_is_s[9], + int *_nc_popcount) + { return(*(int *)0); } + +#undef tparm +char *tparm( + char *string, + ...) + { return(*(char **)0); } + +#undef tiparm +char *tiparm( + const char *string, + ...) + { return(*(char **)0); } + +/* ./tinfo/lib_tputs.c */ + +#undef PC +char PC; +#undef ospeed +short ospeed; +#undef _nc_nulls_sent +int _nc_nulls_sent; + +#undef _nc_set_no_padding +void _nc_set_no_padding( + SCREEN *sp) + { /* void */ } + +#undef delay_output_sp +int delay_output_sp( + SCREEN *sp, + int ms) + { return(*(int *)0); } + +#undef delay_output +int delay_output( + int ms) + { return(*(int *)0); } + +#undef _nc_flush_sp +void _nc_flush_sp( + SCREEN *sp) + { /* void */ } + +#undef _nc_flush +void _nc_flush(void) + { /* void */ } + +#undef _nc_outch_sp +int _nc_outch_sp( + SCREEN *sp, + int ch) + { return(*(int *)0); } + +#undef _nc_outch +int _nc_outch( + int ch) + { return(*(int *)0); } + +#undef _nc_putchar_sp +int _nc_putchar_sp( + SCREEN *sp, + int ch) + { return(*(int *)0); } + +#undef _nc_putchar +int _nc_putchar( + int ch) + { return(*(int *)0); } + +#undef putp_sp +int putp_sp( + SCREEN *sp, + const char *string) + { return(*(int *)0); } + +#undef putp +int putp( + const char *string) + { return(*(int *)0); } + +#undef _nc_putp_sp +int _nc_putp_sp( + SCREEN *sp, + const char *name, + const char *string) + { return(*(int *)0); } + +#undef _nc_putp +int _nc_putp( + const char *name, + const char *string) + { return(*(int *)0); } + +#undef tputs_sp +int tputs_sp( + SCREEN *sp, + const char *string, + int affcnt, + NCURSES_OUTC_sp outc) + { return(*(int *)0); } + +#undef _nc_outc_wrapper +int _nc_outc_wrapper( + SCREEN *sp, + int c) + { return(*(int *)0); } + +#undef tputs +int tputs( + const char *string, + int affcnt, + int (*outc)( + int p1)) + { return(*(int *)0); } + +/* ./trace/lib_trace.c */ + +#undef _nc_tracing +unsigned _nc_tracing; +#undef _nc_tputs_trace +const char *_nc_tputs_trace = {0}; +#undef _nc_outchars +long _nc_outchars; + +#undef trace +void trace( + const unsigned int tracelevel) + { /* void */ } + +#undef _tracef +void _tracef( + const char *fmt, + ...) + { /* void */ } + +#undef _nc_retrace_bool +NCURSES_BOOL _nc_retrace_bool( + int code) + { return(*(NCURSES_BOOL *)0); } + +#undef _nc_retrace_char +char _nc_retrace_char( + int code) + { return(*(char *)0); } + +#undef _nc_retrace_int +int _nc_retrace_int( + int code) + { return(*(int *)0); } + +#undef _nc_retrace_unsigned +unsigned _nc_retrace_unsigned( + unsigned code) + { return(*(unsigned *)0); } + +#undef _nc_retrace_ptr +char *_nc_retrace_ptr( + char *code) + { return(*(char **)0); } + +#undef _nc_retrace_cptr +const char *_nc_retrace_cptr( + const char *code) + { return(*(const char **)0); } + +#undef _nc_retrace_cvoid_ptr +void *_nc_retrace_cvoid_ptr( + void *code) + { return(*(void **)0); } + +#undef _nc_retrace_void_ptr +void *_nc_retrace_void_ptr( + void *code) + { return(*(void **)0); } + +#undef _nc_retrace_sp +SCREEN *_nc_retrace_sp( + SCREEN *code) + { return(*(SCREEN **)0); } + +#undef _nc_retrace_win +WINDOW *_nc_retrace_win( + WINDOW *code) + { return(*(WINDOW **)0); } + +/* ./trace/lib_traceatr.c */ + +#undef _traceattr2 +char *_traceattr2( + int bufnum, + chtype newmode) + { return(*(char **)0); } + +#undef _traceattr +char *_traceattr( + attr_t newmode) + { return(*(char **)0); } + +#undef _nc_retrace_int_attr_t +int _nc_retrace_int_attr_t( + attr_t code) + { return(*(int *)0); } + +#undef _nc_retrace_attr_t +attr_t _nc_retrace_attr_t( + attr_t code) + { return(*(attr_t *)0); } + +#undef _nc_altcharset_name +const char *_nc_altcharset_name( + attr_t attr, + chtype ch) + { return(*(const char **)0); } + +#undef _tracechtype2 +char *_tracechtype2( + int bufnum, + chtype ch) + { return(*(char **)0); } + +#undef _tracechtype +char *_tracechtype( + chtype ch) + { return(*(char **)0); } + +#undef _nc_retrace_chtype +chtype _nc_retrace_chtype( + chtype code) + { return(*(chtype *)0); } + +#undef _tracecchar_t2 +char *_tracecchar_t2( + int bufnum, + const cchar_t *ch) + { return(*(char **)0); } + +#undef _tracecchar_t +char *_tracecchar_t( + const cchar_t *ch) + { return(*(char **)0); } + +/* ./trace/lib_tracebits.c */ + +typedef struct { + unsigned int val; + const char *name; +} BITNAMES; + +#undef _nc_trace_ttymode +char *_nc_trace_ttymode( + struct termios *tty) + { return(*(char **)0); } + +#undef _nc_tracebits +char *_nc_tracebits(void) + { return(*(char **)0); } + +/* ./trace/lib_tracechr.c */ + +#undef _nc_tracechar +char *_nc_tracechar( + SCREEN *sp, + int ch) + { return(*(char **)0); } + +#undef _tracechar +char *_tracechar( + int ch) + { return(*(char **)0); } + +/* ./tinfo/lib_ttyflags.c */ + +#undef _nc_get_tty_mode_sp +int _nc_get_tty_mode_sp( + SCREEN *sp, + struct termios *buf) + { return(*(int *)0); } + +#undef _nc_get_tty_mode +int _nc_get_tty_mode( + struct termios *buf) + { return(*(int *)0); } + +#undef _nc_set_tty_mode_sp +int _nc_set_tty_mode_sp( + SCREEN *sp, + struct termios *buf) + { return(*(int *)0); } + +#undef _nc_set_tty_mode +int _nc_set_tty_mode( + struct termios *buf) + { return(*(int *)0); } + +#undef def_shell_mode_sp +int def_shell_mode_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef def_shell_mode +int def_shell_mode(void) + { return(*(int *)0); } + +#undef def_prog_mode_sp +int def_prog_mode_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef def_prog_mode +int def_prog_mode(void) + { return(*(int *)0); } + +#undef reset_prog_mode_sp +int reset_prog_mode_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef reset_prog_mode +int reset_prog_mode(void) + { return(*(int *)0); } + +#undef reset_shell_mode_sp +int reset_shell_mode_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef reset_shell_mode +int reset_shell_mode(void) + { return(*(int *)0); } + +#undef savetty_sp +int savetty_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef savetty +int savetty(void) + { return(*(int *)0); } + +#undef resetty_sp +int resetty_sp( + SCREEN *sp) + { return(*(int *)0); } + +#undef resetty +int resetty(void) + { return(*(int *)0); } + +/* ./tty/lib_twait.c */ + +#undef _nc_timed_wait +int _nc_timed_wait( + SCREEN *sp, + int mode, + int milliseconds, + int *timeleft) + { return(*(int *)0); } + +/* ./tinfo/name_match.c */ + +#undef _nc_first_name +char *_nc_first_name( + const char *const sp) + { return(*(char **)0); } + +#undef _nc_name_match +int _nc_name_match( + const char *const namelst, + const char *const name, + const char *const delim) + { return(*(int *)0); } + +/* ./names.c */ + +#undef boolnames +char *const boolnames[] = {0}; +#undef boolfnames +char *const boolfnames[] = {0}; +#undef numnames +char *const numnames[] = {0}; +#undef numfnames +char *const numfnames[] = {0}; +#undef strnames +char *const strnames[] = {0}; +#undef strfnames +char *const strfnames[] = {0}; + +/* ./tinfo/obsolete.c */ + +#undef _nc_set_buffer_sp +void _nc_set_buffer_sp( + SCREEN *sp, + FILE *ofp, + int buffered) + { /* void */ } + +#undef _nc_set_buffer +void _nc_set_buffer( + FILE *ofp, + int buffered) + { /* void */ } + +/* ./tinfo/read_entry.c */ + +#include <hashed_db.h> + +#undef _nc_init_termtype +void _nc_init_termtype( + TERMTYPE *const tp) + { /* void */ } + +#undef _nc_read_termtype +int _nc_read_termtype( + TERMTYPE *ptr, + char *buffer, + int limit) + { return(*(int *)0); } + +#undef _nc_read_file_entry +int _nc_read_file_entry( + const char *const filename, + TERMTYPE *ptr) + { return(*(int *)0); } + +#undef _nc_read_entry +int _nc_read_entry( + const char *const name, + char *const filename, + TERMTYPE *const tp) + { return(*(int *)0); } + +/* ./tinfo/read_termcap.c */ + +#include <sys/types.h> + +#undef _nc_read_termcap +void _nc_read_termcap(void) + { /* void */ } + +/* ./tinfo/strings.c */ + +#undef _nc_str_init +string_desc *_nc_str_init( + string_desc *dst, + char *src, + size_t len) + { return(*(string_desc **)0); } + +#undef _nc_str_null +string_desc *_nc_str_null( + string_desc *dst, + size_t len) + { return(*(string_desc **)0); } + +#undef _nc_str_copy +string_desc *_nc_str_copy( + string_desc *dst, + string_desc *src) + { return(*(string_desc **)0); } + +#undef _nc_safe_strcat +NCURSES_BOOL _nc_safe_strcat( + string_desc *dst, + const char *src) + { return(*(NCURSES_BOOL *)0); } + +#undef _nc_safe_strcpy +NCURSES_BOOL _nc_safe_strcpy( + string_desc *dst, + const char *src) + { return(*(NCURSES_BOOL *)0); } + +/* ./trace/trace_buf.c */ + +#undef _nc_trace_buf +char *_nc_trace_buf( + int bufnum, + size_t want) + { return(*(char **)0); } + +#undef _nc_trace_bufcat +char *_nc_trace_bufcat( + int bufnum, + const char *value) + { return(*(char **)0); } + +/* ./trace/trace_tries.c */ + +#undef _nc_trace_tries +void _nc_trace_tries( + TRIES *tree) + { /* void */ } + +/* ./base/tries.c */ + +#undef _nc_expand_try +char *_nc_expand_try( + TRIES *tree, + unsigned code, + int *count, + size_t len) + { return(*(char **)0); } + +#undef _nc_remove_key +int _nc_remove_key( + TRIES **tree, + unsigned code) + { return(*(int *)0); } + +#undef _nc_remove_string +int _nc_remove_string( + TRIES **tree, + const char *string) + { return(*(int *)0); } + +/* ./tinfo/trim_sgr0.c */ + +#undef _nc_trim_sgr0 +char *_nc_trim_sgr0( + TERMTYPE *tp) + { return(*(char **)0); } + +/* ./unctrl.c */ + +#undef unctrl_sp +char *unctrl_sp( + SCREEN *sp, + chtype ch) + { return(*(char **)0); } + +#undef unctrl +char *unctrl( + chtype ch) + { return(*(char **)0); } + +/* ./trace/visbuf.c */ + +#undef _nc_visbuf2 +const char *_nc_visbuf2( + int bufnum, + const char *buf) + { return(*(const char **)0); } + +#undef _nc_visbuf +const char *_nc_visbuf( + const char *buf) + { return(*(const char **)0); } + +#undef _nc_visbufn +const char *_nc_visbufn( + const char *buf, + int len) + { return(*(const char **)0); } + +#undef _nc_viswbuf2 +const char *_nc_viswbuf2( + int bufnum, + const wchar_t *buf) + { return(*(const char **)0); } + +#undef _nc_viswbuf +const char *_nc_viswbuf( + const wchar_t *buf) + { return(*(const char **)0); } + +#undef _nc_viswbufn +const char *_nc_viswbufn( + const wchar_t *buf, + int len) + { return(*(const char **)0); } + +#undef _nc_viswibuf +const char *_nc_viswibuf( + const wint_t *buf) + { return(*(const char **)0); } + +#undef _nc_viscbuf2 +const char *_nc_viscbuf2( + int bufnum, + const cchar_t *buf, + int len) + { return(*(const char **)0); } + +#undef _nc_viscbuf +const char *_nc_viscbuf( + const cchar_t *buf, + int len) + { return(*(const char **)0); } + +/* ./base/define_key.c */ + +#undef define_key_sp +int define_key_sp( + SCREEN *sp, + const char *str, + int keycode) + { return(*(int *)0); } + +#undef define_key +int define_key( + const char *str, + int keycode) + { return(*(int *)0); } + +/* ./tinfo/hashed_db.c */ + +#undef _nc_hashed_db +void _nc_hashed_db(void) + { /* void */ } + +/* ./base/key_defined.c */ + +#undef key_defined_sp +int key_defined_sp( + SCREEN *sp, + const char *str) + { return(*(int *)0); } + +#undef key_defined +int key_defined( + const char *str) + { return(*(int *)0); } + +/* ./base/keybound.c */ + +#undef keybound_sp +char *keybound_sp( + SCREEN *sp, + int code, + int count) + { return(*(char **)0); } + +#undef keybound +char *keybound( + int code, + int count) + { return(*(char **)0); } + +/* ./base/keyok.c */ + +#undef keyok_sp +int keyok_sp( + SCREEN *sp, + int c, + NCURSES_BOOL flag) + { return(*(int *)0); } + +#undef keyok +int keyok( + int c, + NCURSES_BOOL flag) + { return(*(int *)0); } + +/* ./base/version.c */ + +#undef curses_version +const char *curses_version(void) + { return(*(const char **)0); } |