| /**************************************************************************** |
| * Copyright (c) 2012-2013,2015 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-on * |
| ****************************************************************************/ |
| /* 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 |
| const char *const boolcodes[] = {0}; |
| #undef numcodes |
| const char *const numcodes[] = {0}; |
| #undef strcodes |
| const 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 { |
| short 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 |
| const char *keyname_sp( |
| SCREEN *sp, |
| int c) |
| { return(*(const char **)0); } |
| |
| #undef keyname |
| const char *keyname( |
| int c) |
| { return(*(const char **)0); } |
| |
| /* ./tinfo/lib_longname.c */ |
| |
| #undef longname_sp |
| char *longname_sp( |
| SCREEN *sp) |
| { return(*(char **)0); } |
| |
| #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( |
| const 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( |
| const 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, |
| const char *id) |
| { return(*(int *)0); } |
| |
| #undef tgetflag |
| int tgetflag( |
| const char *id) |
| { return(*(int *)0); } |
| |
| #undef tgetnum_sp |
| int tgetnum_sp( |
| SCREEN *sp, |
| const char *id) |
| { return(*(int *)0); } |
| |
| #undef tgetnum |
| int tgetnum( |
| const char *id) |
| { return(*(int *)0); } |
| |
| #undef tgetstr_sp |
| char *tgetstr_sp( |
| SCREEN *sp, |
| const char *id, |
| char **area) |
| { return(*(char **)0); } |
| |
| #undef tgetstr |
| char *tgetstr( |
| const 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, |
| const char *str) |
| { return(*(int *)0); } |
| |
| #undef tigetflag |
| int tigetflag( |
| const char *str) |
| { return(*(int *)0); } |
| |
| #undef tigetnum_sp |
| int tigetnum_sp( |
| SCREEN *sp, |
| const char *str) |
| { return(*(int *)0); } |
| |
| #undef tigetnum |
| int tigetnum( |
| const char *str) |
| { return(*(int *)0); } |
| |
| #undef tigetstr_sp |
| char *tigetstr_sp( |
| SCREEN *sp, |
| const char *str) |
| { return(*(char **)0); } |
| |
| #undef tigetstr |
| char *tigetstr( |
| const 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( |
| const 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 |
| const void *_nc_retrace_cvoid_ptr( |
| const void *code) |
| { return(*(const 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[8]; |
| } 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 |
| const char *const boolnames[] = {0}; |
| #undef boolfnames |
| const char *const boolfnames[] = {0}; |
| #undef numnames |
| const char *const numnames[] = {0}; |
| #undef numfnames |
| const char *const numfnames[] = {0}; |
| #undef strnames |
| const char *const strnames[] = {0}; |
| #undef strfnames |
| const 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 |
| const char *unctrl_sp( |
| SCREEN *sp, |
| chtype ch) |
| { return(*(const char **)0); } |
| |
| #undef unctrl |
| const char *unctrl( |
| chtype ch) |
| { return(*(const 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); } |
