mirror of
https://github.com/Aigor44/ncursesw-morphos.git
synced 2024-12-27 07:49:06 +08:00
5e1e572b71
+ modify several test programs to use new popup_msgs, adapted from help-screen used in test/edit_field.c + drop two symbols obsoleted in 2004: _nc_check_termtype, and _nc_resolve_uses + fix some old copyright dates (cf: 20031025). + build-fixes for test/savescreen.c to work with AIX and HPUX. + minor fix to configure script, adding a backslash/continuation. + extend TERMINAL structure for ABI 6 to store numbers internally as integers rather than short, by adding new data for this purpose. + more fixes for minor memory-leaks in test-programs.
1556 lines
27 KiB
Plaintext
1556 lines
27 KiB
Plaintext
/****************************************************************************
|
|
* Copyright (c) 2012-2016,2017 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>
|
|
|
|
#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(
|
|
TERMTYPE2 *to,
|
|
TERMTYPE2 *from)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_copy_termtype
|
|
void _nc_copy_termtype(
|
|
TERMTYPE *dst,
|
|
const TERMTYPE *src)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_copy_termtype2
|
|
void _nc_copy_termtype2(
|
|
TERMTYPE2 *dst,
|
|
const TERMTYPE2 *src)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_export_termtype2
|
|
void _nc_export_termtype2(
|
|
TERMTYPE *dst,
|
|
const TERMTYPE2 *src)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_import_termtype2
|
|
void _nc_import_termtype2(
|
|
TERMTYPE2 *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 */
|
|
|
|
#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 */
|
|
|
|
#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,
|
|
TERMTYPE2 *tterm)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_free_entries
|
|
void _nc_free_entries(
|
|
ENTRY *headp)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_leaks_tinfo
|
|
void _nc_leaks_tinfo(void)
|
|
{ /* void */ }
|
|
|
|
/* ./fallback.c */
|
|
|
|
#undef _nc_fallback2
|
|
const TERMTYPE2 *_nc_fallback2(
|
|
const char *name)
|
|
{ return(*(const TERMTYPE2 **)0); }
|
|
|
|
#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_free_termtype2
|
|
void _nc_free_termtype2(
|
|
TERMTYPE2 *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 */
|
|
|
|
#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 */
|
|
|
|
struct speed {
|
|
int given_speed;
|
|
int actual_speed;
|
|
};
|
|
|
|
#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 */
|
|
|
|
#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 */
|
|
|
|
#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,
|
|
TERMTYPE2 *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); }
|
|
|
|
#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 */
|
|
|
|
#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 */
|
|
|
|
#undef _nc_init_termtype
|
|
void _nc_init_termtype(
|
|
TERMTYPE2 *const tp)
|
|
{ /* void */ }
|
|
|
|
#undef _nc_read_termtype
|
|
int _nc_read_termtype(
|
|
TERMTYPE2 *ptr,
|
|
char *buffer,
|
|
int limit)
|
|
{ return(*(int *)0); }
|
|
|
|
#undef _nc_read_file_entry
|
|
int _nc_read_file_entry(
|
|
const char *const filename,
|
|
TERMTYPE2 *ptr)
|
|
{ return(*(int *)0); }
|
|
|
|
#undef _nc_read_entry2
|
|
int _nc_read_entry2(
|
|
const char *const name,
|
|
char *const filename,
|
|
TERMTYPE2 *const tp)
|
|
{ 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 */
|
|
|
|
#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(
|
|
TERMTYPE2 *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); }
|