/* ***** DtAction functions ***** */
-static void DbReloadProc(cd)
- XtPointer cd;
+static void DbReloadProc(XtPointer cd)
{
DPR(("DbReloadProc(): action database updated\n"));
DtDbLoad(); /* Pick up any dynamic changes to the database files */
}
-static bool init_action_env()
+static bool init_action_env(void)
{
init_window_env();
return actionEnabled;
}
-static void action_cb(id, cd, args, argcnt, status)
- long unsigned id;
- XtPointer cd; /* unused */
- DtActionArg *args;
- int argcnt;
- DtActionStatus status;
+static void action_cb(long unsigned id, XtPointer cd /* unused */,
+ DtActionArg *args, int argcnt, DtActionStatus status)
{
if (actionId == 0) {
DPR(("action_cb(): invalid id %d != %d\n", id, actionId));
}
-static void wait_action_done()
+static void wait_action_done(void)
{
XEvent event;
return;
}
-int invoke_action(action, host)
- char *action;
- char *host;
+int invoke_action(char *action, char *host)
{
if (init_action_env() != True) return ErrInternal;
}
-void send_dtims_msg(msg, errcode)
- int msg, errcode;
+void send_dtims_msg(int msg, int errcode)
{
XEvent ev;
XSendEvent(Dpy, XtWindow(TopW), False, NoEventMask, &ev);
}
-void dtims_msg_proc(w, cd, event, continue_dispatch)
- Widget w;
- XtPointer cd;
- XEvent *event;
- Boolean *continue_dispatch; /* never changed */
+void dtims_msg_proc(Widget w, XtPointer cd, XEvent *event,
+ Boolean *continue_dispatch /* never changed */)
{
XClientMessageEvent *ev = &event->xclient;
int msg, errcode;
/* local func */
static int shell_type(/* shell */);
-int set_cmd_env()
+int set_cmd_env(void)
{
int ret = NoError;
char **aliases = (char **)0;
}
-int get_user_environ()
+int get_user_environ(void)
{
int ret = NoError;
char buf[BUFSIZ], *p;
}
-int expand_string(in_str, out_str, out_len, ims)
- char *in_str, *out_str;
- int out_len;
- ImsConf *ims;
+int expand_string(char *in_str, char *out_str, int out_len, ImsConf *ims)
{
register char *p, *q, *ep;
char str[20];
}
-static int shell_type(shell)
- char *shell;
+static int shell_type(char *shell)
{
char *p;
int len;
}
-int make_new_environ(oenv, sel)
- OutEnv *oenv;
- UserSelection *sel;
+int make_new_environ(OutEnv *oenv, UserSelection *sel)
{
ImsConf *ims;
EnvEnt *ep, *ep2;
return NoError;
}
-int put_new_environ(oenv) /* print modified environment variables */
- OutEnv *oenv;
+/* print modified environment variables */
+int put_new_environ(OutEnv *oenv)
{
EnvEnt *ep;
char tmpbuf[BUFSIZ], *bp, *vp;
}
-int set_remote_env(ptr, env_pass)
- char *ptr, *env_pass;
+int set_remote_env(char *ptr, char *env_pass)
{
char *bp = ptr, *ep;
char **ls, **ls2, **pp, **pp2;
}
# ifdef old_hpux
-char *xhp_xinput_name(locale)
- char *locale;
+char *xhp_xinput_name(char *locale)
{
char *xinput_name = "X@INPUT";
char **pp, *p;
}
-char *get_real_locale(locale, aliases)
- char *locale, ***aliases;
+char *get_real_locale(char *locale, char ***aliases)
{
int i;
int match_idx = -1;
#include <sys/stat.h>
/* local func */
-static void put_selection_entry(/* fp, ent_type, is_valid, val, val2 */);
+static void put_selection_entry(FILE *fp, int ent_type, bool is_valid, char *val, char *val2);
static void put_ims_conf(/* fp, sel */);
static void put_select_mode(/* fp, select_mode */);
static void put_selection_header(/* fp */);
static bool cmdconf_initialized = False;
-int create_xims_dir()
+int create_xims_dir(void)
{
int ret = NoError;
char path[MAXPATHLEN];
return ret;
}
-int init_log_file(org_path, check_size)
- char *org_path;
- int check_size;
+int init_log_file(char *org_path, int check_size)
{
char path[MAXPATHLEN];
bool log_exists = False;
}
-int set_errorlog(path)
- char *path;
+int set_errorlog(char *path)
{
int fd;
}
-int read_cmd_conf()
+int read_cmd_conf(void)
{
char buf[MAXPATHLEN];
CmdConf *conf = &Conf;
return NoError;
}
-int expand_cmd_conf()
+int expand_cmd_conf(void)
{
char **pp[20 + NUM_ACTIONS], *p, buf[BUFSIZ];
int i, j, n;
}
-int read_imsconf(conf, ims_name, ims_fname)
- ImsConf *conf;
- char *ims_name, *ims_fname;
+int read_imsconf(ImsConf *conf, char *ims_name, char *ims_fname)
{
int ret = NoError;
char path[MAXPATHLEN];
return ret;
}
-int check_ims_conf(ims, ims_name)
- ImsConf *ims;
- char *ims_name;
+int check_ims_conf(ImsConf *ims, char *ims_name)
{
int ret = NoError;
char *missing_entry = NULL;
return ret;
}
-int read_localeconf(list, locale_name)
- ImsList *list;
- char *locale_name;
+int read_localeconf(ImsList *list, char *locale_name)
{
char path[MAXPATHLEN];
char *lp, *valp, *pp;
return list->status;
}
-int read_user_selection(fselp, locale_name)
- FileSel **fselp;
- char *locale_name;
+int read_user_selection(FileSel **fselp, char *locale_name)
{
char path[MAXPATHLEN];
int ret;
return NoError;
}
-int read_selection_file(fsel, fp)
- FileSel *fsel;
- FILE *fp;
+int read_selection_file(FileSel *fsel, FILE *fp)
{
char *lp, *valp, *vp, *p;
int i, nopts, line_num;
return NoError;
}
-int save_user_selection(sel, locale_name)
- UserSelection *sel;
- char *locale_name;
+int save_user_selection(UserSelection *sel, char *locale_name)
{
char path[MAXPATHLEN];
int dpy_specific;
#define _IMSOPTION 4
#define _IMSOPT2 5
-static void put_selection_entry(fp, ent_type, is_valid, val, val2)
- FILE *fp;
- int ent_type;
- bool is_valid;
- char *val, *val2;
+static void put_selection_entry(FILE *fp, int ent_type, bool is_valid, char *val, char *val2)
{
char *name = NULL;
}
-static void put_ims_conf(fp, sel)
- FILE *fp;
- UserSelection *sel;
+static void put_ims_conf(FILE *fp, UserSelection *sel)
{
char *valp, val[20];
}
}
-static void put_select_mode(fp, select_mode)
- FILE *fp;
- int select_mode;
+static void put_select_mode(FILE *fp, int select_mode)
{
char val[20];
if (select_mode != SEL_MODE_NOAUTO && select_mode != SEL_MODE_AUTO
}
-static void put_selection_header(fp)
- FILE *fp;
+static void put_selection_header(FILE *fp)
{
fprintf(fp, "%s %s\n", COMMENT_CHARS, ProgramRevision);
if (SelectFileFormat)
fprintf(fp, "%s%s\n", COMMENT_CHARS, SelectFileFormat);
}
-static void put_selection_sep(fp)
- FILE *fp;
+static void put_selection_sep(FILE *fp)
{
fprintf(fp, "%s\n", COMMENT_CHARS);
}
-int get_select_mode()
+int get_select_mode(void)
{
char path[MAXPATHLEN];
char *lp, *valp;
return select_mode;
}
-int set_select_mode(cur_mode, new_mode)
- int cur_mode, new_mode;
+int set_select_mode(int cur_mode, int new_mode)
{
char path[MAXPATHLEN];
int dpy_specific;
return NoError;
}
-static int user_selection_fname(buf, buf_len, dpy_specific)
- char *buf;
- int buf_len, dpy_specific;
+static int user_selection_fname(char *buf, int buf_len, int dpy_specific)
{
int len;
UserEnv *uenv = &userEnv;
}
-int parse_protolist(valp)
- char *valp;
+int parse_protolist(char *valp)
{
int proto_bits = 0;
return proto_bits;
}
-int default_protocol(conf)
- ImsConf *conf;
+int default_protocol(ImsConf *conf)
{
if (conf->protocols & ProtoBit(Proto_XIM)) return Proto_XIM;
else if (conf->protocols & ProtoBit(Proto_Ximp)) return Proto_Ximp;
static bool do_usage = False;
-main (argc, argv)
- int argc;
- char **argv;
+int main (int argc, char **argv)
{
int ret = NoError;
int ret2;
}
-void sigExit(sig)
- int sig;
+void sigExit(int sig)
{
DPR(("sigExit: %s (%d)\n", sig_name(sig), sig));
signal(sig, SIG_IGN);
Exit(ErrSignaled);
}
-void Exit(err_code)
- int err_code;
+void Exit(int err_code)
{
int exit_code = IsNoError(err_code) ? 0 : 1;
exit(exit_code);
}
-int NotifyErrCode(err_code)
- int err_code;
+int NotifyErrCode(int err_code)
{
char buf[BUFSIZ], *bp, val[20];
static bool notify_done = False;
}
-static int IsNoError(error)
- ximsError error;
+static int IsNoError(ximsError error)
{
switch (error) {
case NoError: case ErrIsNone: case ErrNotRun:
return False;
}
-static int EnvNeeded(error)
- ximsError error;
+static int EnvNeeded(ximsError error)
{
switch (error) {
case NoError: case ErrIsNone: case ErrNotRun:
return False;
}
-static int ErrMsgDisabled(error)
- ximsError error;
+static int ErrMsgDisabled(ximsError error)
{
switch (error) {
case NoError: case ErrIsNone: case ErrNotRun:
return False;
}
-int ErrFilePathNeeded(error)
- ximsError error;
+int ErrFilePathNeeded(ximsError error)
{
switch (error) {
case ErrFileOpen: case ErrFileCreate: case ErrDirCreate:
return False;
}
-int InWaitingState()
+int InWaitingState(void)
{
switch (OpState) {
case State_Init_Err:
return False;
}
-void ximsMain()
+void ximsMain(void)
{
static int call_cnt = 0;
}
-void ximsFinish()
+void ximsFinish(void)
{
OpStateVal oldOpState = OpState;
}
-static int ximsShowImsList()
+static int ximsShowImsList(void)
{
int ret;
int i;
return NoError;
}
-static int ximsShowCurrentIms()
+static int ximsShowCurrentIms(void)
{
int ret = NoError;
FileSel *fsel;
}
-static int prepare_remote(win_st)
- int win_st;
+static int prepare_remote(int win_st)
{
int ret;
char **av = NULL;
return NoError;
}
-static int ximsRemoteConf()
+static int ximsRemoteConf(void)
{
int ret;
char *locale;
}
-static int ximsSetMode()
+static int ximsSetMode(void)
{
int ret = NoError;
int cur_mode = SEL_MODE_NONE;
return ret;
}
-static void show_select_mode(mode)
- int mode;
+static void show_select_mode(int mode)
{
char *valp;
}
-static int set_locale_env(locale)
- char *locale;
+static int set_locale_env(char *locale)
{
char *env_name, *env_value, *bp, *vp, buf[BUFSIZ], buf2[BUFSIZ];
static char *last_lang_env[2] = { NULL, NULL };
return NoError;
}
-static void init_command(progname)
- char *progname;
+static void init_command(char *progname)
{
/* globals */
ProgramName = progname;
}
-static bool optname_match(name, str, minlen)
- char *name, *str;
- int minlen;
+static bool optname_match(char *name, char *str, int minlen)
{
int nlen, slen;
return False;
}
-static int parse_options(argc, argv)
- int argc;
- char **argv;
+static int parse_options(int argc, char **argv)
{
char *opt;
int i, n;
};
#endif /* DEBUG */
-static void usage(force)
- int force;
+static void usage(int force)
{
char *fmt = "\t%-20s%s\n";
/* ******** error messages ******** */
-char *xims_errmsg(err_num, arg1, arg2, arg3)
- int err_num;
- void *arg1, *arg2, *arg3;
+char *xims_errmsg(int err_num, void *arg1, void *arg2, void *arg3)
{
char *fmt = NULL, *bp;
int len;
}
#endif
-int put_remote_conf(locale, ims_name)
- char *locale, *ims_name;
+int put_remote_conf(char *locale, char *ims_name)
{
int ret;
int msg_status = NoError;
return ret;
}
-int get_remote_conf(listp, hostname, locale, ims_name)
- ImsList **listp;
- char *hostname, *locale, *ims_name;
+int get_remote_conf(ImsList **listp, char *hostname, char *locale, char *ims_name)
{
int ret = NoError;
int conflen = 0;
#define PUT_DATA(nm, val) *bp++ = ' ', bp = strcpyx(bp, (nm)), \
*bp++ = '=', bp = strcpyx(bp, (val)), *bp++ = '\n'
-static int mk_remote_conf(list, locale, ims_name, status, confbuf, conflen)
- ImsList *list;
- int status;
- char *locale, *ims_name, *confbuf;
- int *conflen;
+static int mk_remote_conf(ImsList *list, char *locale,
+ char *ims_name, int status,
+ char *confbuf, int *conflen)
{
int num_ent;
int i, j;
return NoError;
}
-static char *mk_ims_ent(bp, idx, ent)
- ImsEnt *ent;
- int idx;
- register char *bp;
+static char *mk_ims_ent(register char *bp, int idx, ImsEnt *ent)
{
ImsConf *ims = ent->ims;
char val[20];
#undef PUT_DATA
-static int parse_ims_list(ptr, list)
- char *ptr;
- ImsList *list;
+static int parse_ims_list(char *ptr, ImsList *list)
{
register char *bp = ptr;
char *np, *vp;
}
-static int parse_remote_conf(listp, locale, confbuf, conflen)
- ImsList **listp;
- char *locale, *confbuf;
- int conflen;
+static int parse_remote_conf(ImsList **listp, char *locale, char *confbuf, int conflen)
{
int ret = NoError;
char *bp = confbuf;
}
-int exec_remote_ims(sel)
- UserSelection *sel;
+int exec_remote_ims(UserSelection *sel)
{
int ret = NoError;
int n, num_opts, binc;
}
-int check_hostname(hostname)
- char *hostname;
+int check_hostname(char *hostname)
{
int host_type = HOST_UNKNOWN;
char *local = userEnv.hostname;
-int set_remote_confdata(confbuf, conflen)
- char *confbuf;
- int conflen;
+int set_remote_confdata(char *confbuf, int conflen)
{
char *av[2];
return set_window_data(1, av);
}
-int read_remote_confdata(confbuf, conflen)
- char **confbuf;
- int *conflen;
+int read_remote_confdata(char **confbuf, int *conflen)
{
char **av = NULL;
int ac = 0;
}
-static int prepare_action(act_typ, av, ac)
- int act_typ;
- char **av;
- int ac;
+static int prepare_action(int act_typ, char **av, int ac)
{
int ret;
}
-int get_window_status()
+int get_window_status(void)
{
long *datap;
int len = 0;
return win_st;
}
-int change_window_status(status)
- int status;
+int change_window_status(int status)
{
if (winEnv.atom_status == None || winEnv.atom_owner == None)
return ErrInternal;
return NoError;
}
-int set_window_data(ac, av)
- int ac;
- char **av;
+int set_window_data(int ac, char **av)
{
register int i;
register int nbytes;
}
-int get_window_data(acp, avp)
- int *acp;
- char ***avp;
+int get_window_data(int *acp, char ***avp)
{
int ac;
char *data;
}
-static int read_property(prop, type, format, del_flag, datapp, lenp)
- Atom prop;
- Atom type;
- int format;
- int del_flag;
- unsigned char **datapp;
- unsigned long *lenp;
+static int read_property(Atom prop, Atom type, int format,
+ int del_flag, unsigned char **datapp,
+ unsigned long *lenp)
{
Atom realtype;
int realformat;
static int setup_user_selection(/* sel, list, idx */);
-void ximsSelect()
+void ximsSelect(void)
{
int ret;
bool use_win;
}
-static int fill_ims_ent(list, top, last)
- ImsList *list;
- int top, last;
+static int fill_ims_ent(ImsList *list, int top, int last)
{
int ret;
int i;
}
-static int setup_local_selection(sel, list, conf_all)
- UserSelection *sel;
- ImsList *list;
- int conf_all;
+static int setup_local_selection(UserSelection *sel, ImsList *list, int conf_all)
{
int ret;
int idx, top, last;
return ret;
}
-static int setup_remote_selection(sel)
- UserSelection *sel;
+static int setup_remote_selection(UserSelection *sel)
{
int ret;
int idx;
return ret;
}
-static int setup_user_selection(sel, list, idx)
- UserSelection *sel;
- ImsList *list;
- int idx;
+static int setup_user_selection(UserSelection *sel, ImsList *list, int idx)
{
if (sel->name) {
if (idx >= 0) {
return sel->status;
}
-int update_user_selection(sel, list, idx, host, host_type)
- UserSelection *sel;
- ImsList *list;
- int idx;
- char *host;
- int host_type;
+int update_user_selection(UserSelection *sel, ImsList *list, int idx, char *host, int host_type)
{
ImsEnt *ent;
}
-int get_ims_idx(list, name)
- ImsList *list;
- char *name;
+int get_ims_idx(ImsList *list, char *name)
{
int idx;
return -1;
}
-int set_ims_status(ent)
- ImsEnt *ent;
+int set_ims_status(ImsEnt *ent)
{
int ret = NoError;
ImsConf *ims = ent->ims;
}
-int get_ims_list(listp, locale, fill_ent)
- ImsList **listp;
- char *locale;
- int fill_ent;
+int get_ims_list(ImsList **listp, char *locale, int fill_ent)
{
int ret = NoError;
ImsList *list;
# endif /* old_hpux */
-void ximsStart()
+void ximsStart(void)
{
int ret;
UserSelection *sel = &userSel;
}
-void ximsWait()
+void ximsWait(void)
{
OpStateVal oldOpState = OpState;
UserSelection *sel = &userSel;
}
-void ximsWaitDone()
+void ximsWaitDone(void)
{
int ret;
UserSelection *sel = &userSel;
ximsMain();
}
-int is_waiting()
+int is_waiting(void)
{
return userSel.renv && userSel.renv->status == ErrImsWaiting;
}
-void set_sig_chld(enable)
- int enable;
+void set_sig_chld(int enable)
{
DPR(("set_sig_chld(%s)\n", enable ? "Enabled" : "Disabled"));
signal(SIGCHLD, enable ? on_sig_chld : SIG_IGN);
}
-int im_mod_available(renv)
- RunEnv *renv;
+int im_mod_available(RunEnv *renv)
{
Window owner;
/* ***** IMS options ***** */
-int mk_ims_option(ptr, sel)
- char *ptr;
- UserSelection *sel;
+int mk_ims_option(char *ptr, UserSelection *sel)
{
char *bp = ptr;
FileSel *fsel = sel->fsel;
return (int) (bp - ptr);
}
-static int check_ims_opt(ptr)
- char *ptr;
+static int check_ims_opt(char *ptr)
{
/* option string must not contain any of shell's metacaharacters */
if (strpbrk(ptr, "`'\"#;&()|<>\n")) {
static bool resource_loaded = False;
-int load_resources()
+int load_resources(void)
{
int ret;
int empty;
return ret;
}
-int restore_resources()
+int restore_resources(void)
{
if (!resource_loaded) {
DPR2(("restore_resources: not loaded yet -- not restored\n"));
return restore_RM();
}
-static char *find_session_resfile(res_type)
- int res_type;
+static char *find_session_resfile(int res_type)
{
char path[MAXPATHLEN];
char **ls = (char **) 0, **pp;
/* ***** local functions ***** */
-static int check_selection(sel)
- UserSelection *sel;
+static int check_selection(UserSelection *sel)
{
int ret = NoError;
return ret;
}
-static int build_run_env(sel)
- UserSelection *sel;
+static int build_run_env(UserSelection *sel)
{
char *p;
int proto;
return NoError;
}
-static int run_ims(sel)
- UserSelection *sel;
+static int run_ims(UserSelection *sel)
{
int ret = NoError;
return ret;
}
-static int invoke_ims(sel)
- UserSelection *sel;
+static int invoke_ims(UserSelection *sel)
{
RunEnv *renv = sel->renv;
pid_t pid;
return NoError;
}
-static void on_sig_chld(sig)
- int sig;
+static void on_sig_chld(int sig)
{
int wait_status = 0;
pid_t pid;
return;
}
-static bool is_ims_running(renv, ims)
- RunEnv *renv;
- ImsConf *ims;
+static bool is_ims_running(RunEnv *renv, ImsConf *ims)
{
char *prop_str;
Window owner;
}
-static int settle_ims(sel)
- UserSelection *sel;
+static int settle_ims(UserSelection *sel)
{
if (isXsession()) {
return NoError;
}
-static Window property_owner(prop_atom, prop_str)
- Atom *prop_atom;
- char *prop_str;
+static Window property_owner(Atom *prop_atom, char *prop_str)
{
Atom property = prop_atom ? *prop_atom : None;
static jmp_buf jmp_env;
static Window dmy_win = 0; /* temporary window used for XCreateIC() */
-static void catch_alarm(sig)
- int sig;
+static void catch_alarm(int sig)
{
signal(SIGALRM, SIG_IGN);
alarm(0);
longjmp(jmp_env, 1);
}
-static int try_connection(sel)
- UserSelection *sel;
+static int try_connection(UserSelection *sel)
{
RunEnv *renv = sel->renv;
ImsConf *ims = sel->ent->ims;
return ic_ok ? NoError : ErrImsTimeout; /* ErrImsConnect; */
}
-static int create_dummy_ic(xim)
- XIM xim;
+static int create_dummy_ic(XIM xim)
{
int scr;
XFontSet fset;
/* ******** locale name manupilation ******** */
-int find_CDE_locale_name()
+int find_CDE_locale_name(void)
{
UserEnv *uenv = &userEnv;
_DtXlateDb db = NULL;
return ret;
}
-char *find_system_locale_name(CDE_locale)
- char *CDE_locale;
+char *find_system_locale_name(char *CDE_locale)
{
_DtXlateDb db = NULL;
int ret = NoError;
/* ******** string manupilation ******** */
-char *strcpyx(dest, src)
- register char *dest, *src;
+char *strcpyx(register char *dest, register char *src)
{
while (*dest++ = *src++) ;
return(--dest);
}
#ifdef unused
-char *strcpy2(dest, src1, src2)
- register char *dest, *src1, *src2;
+char *strcpy2(register char *dest, register char *src1, register char *src2)
{
while (*dest++ = *src1++) ;
--dest;
return(--dest);
}
-char *newstradded(src1, src2, src3)
- register char *src1, *src2, *src3;
+char *newstradded(register char *src1, register char *src2, register char *src3)
{
register char *p;
char *dest;
#endif /* unused */
-int str_to_int(ptr, val)
- char *ptr;
- int *val;
+int str_to_int(char *ptr, int *val)
{
int base;
char *pp;
return(True);
}
-bool str_to_bool(ptr, def_val)
- char *ptr;
- bool def_val;
+bool str_to_bool(char *ptr, bool def_val)
{
if (!ptr || !*ptr) return def_val;
skip_white(ptr);
return def_val;
}
-char *trim_line(ptr)
- char *ptr;
+char *trim_line(char *ptr)
{
register char *lastp;
return ptr; /* return lastp > ptr ? ptr : NULL; */
}
-char **parse_strlist(ptr, sep_ch)
- register char *ptr;
- char sep_ch;
+char **parse_strlist(register char *ptr, char sep_ch)
{
char *pbuf[100], **new, **bp;
char *sep, *p;
}
#ifdef unused
-int pack_strlist(ptr, listp, sep_ch)
- char *ptr, **listp;
- char sep_ch;
+int pack_strlist(char *ptr, char **listp, char sep_ch)
{
register char *bp = ptr, **lp = listp;
}
#endif /* unused */
-void free_strlist(pp)
- char **pp;
+void free_strlist(char **pp)
{
register char **ptr = pp;
/* ******** display string ******** */
-bool parse_dpy_str(display_str, host, dnum, snum, dnet)
- char *display_str, **host;
- int *dnum, *snum, *dnet;
+bool parse_dpy_str(char *display_str, char **host, int *dnum, int *snum, int *dnet)
{
char buf[BUFSIZ], hostbuf[BUFSIZ], *p, *hp, *pdnum, *psnum;
int isdnet = 0;
return True;
}
-char *std_dpy_str(display_str, snum)
- char *display_str;
- int *snum;
+char *std_dpy_str(char *display_str, int *snum)
{
char buf[BUFSIZ], *bp, val[20];
char *host = NULL;
/* ******** file & dir manipulation ******** */
-int make_user_dir(path)
- char *path;
+int make_user_dir(char *path)
{
if (!is_directory(path, False)) {
if (access(path, F_OK) == 0)
return True;
}
-char *dirname(path)
- char *path;
+char *dirname(char *path)
{
static char dname[MAXPATHLEN];
register char *p = path;
}
-int is_directory(path, must_writable)
- char *path;
- int must_writable;
+int is_directory(char *path, int must_writable)
{
struct stat stb;
int mode = R_OK|X_OK;
}
#ifdef unused
-int is_regularfile(path)
- char *path;
+int is_regularfile(char *path)
{
struct stat stb;
return stat(path, &stb) == 0 && S_ISREG(stb.st_mode);
}
-int is_emptyfile(path)
- char *path;
+int is_emptyfile(char *path)
{
struct stat stb;
return stat(path, &stb) == 0 && S_ISREG(stb.st_mode) && stb.st_size == 0;
#endif /* unused */
-int is_executable(path)
- char *path;
+int is_executable(char *path)
{
struct stat stb;
return stat(path, &stb) == 0 && S_ISREG(stb.st_mode)
}
#ifdef unused
-int is_writable(path)
- char *path;
+int is_writable(char *path)
{
if (access(path, R_OK|W_OK) == 0)
return True;
}
#endif /* unused */
-int is_readable(path, allow_empty)
- char *path;
- int allow_empty;
+int is_readable(char *path, int allow_empty)
{
struct stat stb;
return stat(path, &stb) == 0 && S_ISREG(stb.st_mode)
static char *tag_linebuf = NULL;
static char *tag_file = NULL;
-int start_tag_line(fname)
- char *fname;
+int start_tag_line(char *fname)
{
if (fname) {
if (!tag_linebuf)
return True;
}
-int read_tag_line(fp, tagp, valp)
- FILE *fp;
- char **tagp, **valp;
+int read_tag_line(FILE *fp, char **tagp, char **valp)
{
char *lp, *lp2;
/* ******** put messages ******** */
-void put_xims_msg(msg_type, err_num, arg1, arg2, arg3)
- int msg_type, err_num;
- void *arg1, *arg2, *arg3;
+void put_xims_msg(int msg_type, int err_num, void *arg1, void *arg2, void *arg3)
{
int ret = -2;
char *msg;
return;
}
-void put_xims_errmsg(err_num, arg1, arg2, arg3)
- int err_num;
- void *arg1, *arg2, *arg3;
+void put_xims_errmsg(int err_num, void *arg1, void *arg2, void *arg3)
{
if (Verbose > 0)
put_xims_msg(MSGTYP_FATAL, err_num, arg1, arg2, arg3);
}
-void put_xims_warnmsg(err_num, arg1, arg2, arg3)
- int err_num;
- void *arg1, *arg2, *arg3;
+void put_xims_warnmsg(int err_num, void *arg1, void *arg2, void *arg3)
{
if (Verbose > 0)
put_xims_msg(MSGTYP_WARN, err_num, arg1, arg2, arg3);
#ifdef DEBUG
/* for DPR*() macro */
-void print_msg(fmt, arg1, arg2, arg3, arg4, arg5)
- char *fmt;
- void *arg1, *arg2, *arg3, *arg4, *arg5;
+void print_msg(char *fmt, void *arg1, void *arg2, void *arg3, void *arg4, void *arg5)
{
fprintf(LogFp, fmt, arg1, arg2, arg3, arg4, arg5);
}
#endif
-int put_xims_log(fmt, arg1, arg2, arg3)
- char *fmt;
- void *arg1, *arg2, *arg3;
+int put_xims_log(char *fmt, void *arg1, void *arg2, void *arg3)
{
FILE *fp;
char *logpath = Opt.LogPath;
/* ******** clear structure ******** */
-void clear_ImsConf(ims)
- ImsConf *ims;
+void clear_ImsConf(ImsConf *ims)
{
FREE(ims->servername);
FREE(ims->servername2);
CLR(ims, ImsConf);
}
-void clear_ImsEnt(ent)
- ImsEnt *ent;
+void clear_ImsEnt(ImsEnt *ent)
{
FREE(ent->name);
FREE(ent->fname);
CLR(ent, ImsEnt);
}
-void clear_ImsList(list)
- ImsList *list;
+void clear_ImsList(ImsList *list)
{
int i;
}
-void clear_FileSel(fsel)
- FileSel *fsel;
+void clear_FileSel(FileSel *fsel)
{
FREE(fsel->name);
FREE(fsel->hostname);
fsel->dpy_specific = False;
}
-void clear_UserSelection(sel)
- UserSelection *sel;
+void clear_UserSelection(UserSelection *sel)
{
FREE(sel->name);
FREE(sel->hostname);
}
-void clear_RunEnv(renv)
- RunEnv *renv;
+void clear_RunEnv(RunEnv *renv)
{
FREE(renv->im_mod);
FREE(renv->atom_name);
}
-void clear_OutEnv(oenv)
- OutEnv *oenv;
+void clear_OutEnv(OutEnv *oenv)
{
EnvEnt *ep;
#ifdef unused
-void clear_UserEnv()
+void clear_UserEnv(void)
{
UserEnv *uenv = &userEnv;
return;
}
-void clear_CmdConf()
+void clear_CmdConf(void)
{
if (cmdconf_initialized) {
CmdConf *conf = &Conf;
return;
}
-void clear_WinEnv()
+void clear_WinEnv(void)
{
CLR(&winEnv, WinEnv);
}
-void clear_CmdOpt()
+void clear_CmdOpt(void)
{
CLR(&Opt, CmdOpt);
}
-void clear_All()
+void clear_All(void)
{
UserSelection *sel = &userSel;
/* ******** print structure (for DEBUG) ******** */
-void pr_FileSel(fsel)
- FileSel *fsel;
+void pr_FileSel(FileSel *fsel)
{
fprintf(LogFp, "FileSel:\tdpy_specific=%d real_fname=%s select_mode=%d\n",
fsel->dpy_specific, fsel->real_fname, fsel->select_mode);
}
}
-void pr_UserSelection(sel)
- UserSelection *sel;
+void pr_UserSelection(UserSelection *sel)
{
fprintf(LogFp, "userSelection:\tstatus=%s flag=%#x ims_idx=%d\n",
error_name(sel->status), sel->flag, sel->ims_idx);
if (sel->renv) pr_RunEnv(sel->renv);
}
-void pr_ImsConf(conf, ims_name)
- ImsConf *conf;
- char *ims_name;
+void pr_ImsConf(ImsConf *conf, char *ims_name)
{
char **p;
fputc('\n', LogFp);
}
-void pr_ImsEnt(ent, idx)
- ImsEnt *ent;
- int idx;
+void pr_ImsEnt(ImsEnt *ent, int idx)
{
fprintf(LogFp, "ImsEnt[%d]:\tname=%s fname=%s label=%s ims=%#x\n",
idx, ent->name, ent->fname, ent->label, ent->ims);
}
-void pr_ImsList(list)
- ImsList *list;
+void pr_ImsList(ImsList *list)
{
int i;
ImsEnt *ent;
}
}
-void pr_WinEnv(wenv)
- WinEnv *wenv;
+void pr_WinEnv(WinEnv *wenv)
{
fprintf(LogFp, "WinEnv:\tstatus=%d Dpy=%#x topW=%#x appC=%#x\n",
wenv->status, wenv->Dpy, wenv->TopW, wenv->appC);
wenv->atom_owner, wenv->atom_main, wenv->atom_status, wenv->atom_data);
}
-void pr_RunEnv(renv)
- RunEnv *renv;
+void pr_RunEnv(RunEnv *renv)
{
fprintf(LogFp, "RunEnv:\tstatus=%s is_remote=%d proto=%d\n",
error_name(renv->status), renv->is_remote, proto_name(renv->proto));
}
-void pr_UserEnv()
+void pr_UserEnv(void)
{
UserEnv *uenv = &userEnv;
fprintf(LogFp, "\tscreen_num=%d\n", uenv->screen_num);
}
-void pr_OutEnv(oenv)
- OutEnv *oenv;
+void pr_OutEnv(OutEnv *oenv)
{
EnvEnt *ep;
}
-void pr_CmdConf()
+void pr_CmdConf(void)
{
int i;
CmdConf *conf = &Conf;
# endif /* old_hpux */
}
-void pr_CmdOpt()
+void pr_CmdOpt(void)
{
fprintf(LogFp, "CmdOpt:\tDisplayName=%s LocaleName=%s ShellName=%s\n",
Opt.DisplayName, Opt.LocaleName, Opt.ShellName);
Opt.SelectMode, Opt.Timeout, Opt.Interval);
}
-void pr_OpModeFlag()
+void pr_OpModeFlag(void)
{
char *name = "<unknown>";
};
#define NumStates (sizeof(StateNameTbl) / sizeof(char *))
-char *StateName()
+char *StateName(void)
{
return (OpState >= 0 && OpState < NumStates) ?
StateNameTbl[OpState] : "<unknown>";
/* ******** error name ******** */
-char *error_name(error)
- ximsError error;
+char *error_name(ximsError error)
{
char *name = "<unknown>";
{ "None", "XIM", "Ximp", "Xsi" };
# endif /* old_hpux */
-char *proto_name(proto_idx)
- int proto_idx;
+char *proto_name(int proto_idx)
{
if (proto_idx >= 0 && proto_idx < NUM_PROTOCOLS)
return _proto_names[proto_idx];
#define MaxSigNum (sizeof(SigNames) / sizeof(char *))
-char *sig_name(sig)
- int sig;
+char *sig_name(int sig)
{
return (sig > 0 && sig <= MaxSigNum) ? SigNames[sig - 1] : "<unknown>";
}
-void pr_brk(msg)
- char *msg;
+void pr_brk(char *msg)
{
static char *last_brk = 0;
char *new_brk = (char *) sbrk(0);
/* ******** window env ******** */
-int open_display()
+int open_display(void)
{
if (Dpy) return NoError; /* already done */
return NoError;
}
-void close_display()
+void close_display(void)
{
if (TopW) return; /* Xt not finished */
return;
}
-int window_env_ok()
+int window_env_ok(void)
{
return winEnv.status != WIN_ST_NONE ? True : False;
}
-int init_window_env()
+int init_window_env(void)
{
enum { XA_DTIMS_ATOM_MAIN, XA_DTIMS_ATOM_STATUS, XA_DTIMS_ATOM_DATA,
NUM_ATOMS };
return NoError;
}
-void end_window_env()
+void end_window_env(void)
{
if (TopW) {
disown_main_atom(XtWindow(TopW));
/* return; */
}
-
-int clear_cmd_property(win) /* clear WM_COMMAND property */
- Window win;
+/* clear WM_COMMAND property */
+int clear_cmd_property(Window win)
{
int ret, ac = 0;
int clear_ok = False;
return clear_ok;
}
-static int ignoreBadWindow(dpy, error)
- Display *dpy;
- XErrorEvent *error;
+static int ignoreBadWindow(Display *dpy, XErrorEvent *error)
{
if (error->error_code == BadWindow || error->error_code == BadDrawable) {
return 0;
}
#ifdef unused
-static void finish_window(w, end_window)
- Widget *w;
- int end_window;
+static void finish_window(Widget *w, int end_window)
{
if (*w) {
XtUnmapWidget(*w);
#endif /* unused */
-static int own_main_atom(win) /* own DTIMS_ATOM_MAIN */
- Window win;
+/* own DTIMS_ATOM_MAIN */
+static int own_main_atom(Window win)
{
Window owner = None;
return winEnv.atom_owner == win ? True : False;
}
-static int disown_main_atom(win) /* disown DTIMS_ATOM_MAIN */
- Window win;
+/* disown DTIMS_ATOM_MAIN */
+static int disown_main_atom(Window win)
{
if (winEnv.atom_main == None) return False;
/* if (winEnv.atom_owner == None) return False; */
static char *saved_xdefs = NULL; /* should not be freed */
-int save_RM()
+int save_RM(void)
{
if (!Dpy) return False;
saved_xdefs = XResourceManagerString(Dpy);
return saved_xdefs ? True : False;
}
-int merge_RM(res1, res2)
- char *res1, *res2;
+int merge_RM(char *res1, char *res2)
{
char cmdbuf[BUFSIZ*2];
int ret;
return ret == 0 ? True : False;
}
-int restore_RM()
+int restore_RM(void)
{
int len = saved_xdefs ? strlen(saved_xdefs) : 0;
int max = (XMaxRequestSize(Dpy) << 2) - 28;
static bool selection_changed = False;
-static void free_ims_list(list)
- ImsList *list;
+static void free_ims_list(ImsList *list)
{
/* DPR(("free_ims_list(list=%p)\n", list)); */
if (list && list != localList && list != userSel.list) {
}
}
-static void clear_selection_var()
+static void clear_selection_var(void)
{
free_ims_list(curList);
curList = (ImsList *) 0;
selection_changed = False;
}
-int start_selection_window()
+int start_selection_window(void)
{
int ret = NoError;
return NoError;
}
-static void finish_selection_window(end_window)
- int end_window;
+static void finish_selection_window(int end_window)
{
DPR(("finish_selection_window(end=%s)\n", end_window ? "True" : "False"));
return;
}
-static void done_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void done_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
int canceled = (int)(intptr_t) client_data == CANCEL_BTN;
int idx;
ximsMain();
}
-static void select_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void select_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
int new_idx = (int)(intptr_t) client_data;
CurIdx = new_idx;
}
-static void host_btn_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void host_btn_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
start_host_window(CurHost);
}
-static void help_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void help_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
ximsHelp(HELP_SELECTION);
}
-static int create_selection_window()
+static int create_selection_window(void)
{
Widget form, sel_rc, host_rc, cmd_rc, lb, sep;
Widget w_tbl[8];
}
-static int change_host(new_host, host_type)
- char *new_host;
- int host_type;
+static int change_host(char *new_host, int host_type)
{
int ret = NoError;
ImsList *new_list = (ImsList *) 0;
#define createPB XmCreatePushButton
#define createTB XmCreateToggleButton
-static void add_btn_trans(btn)
- Widget btn;
+static void add_btn_trans(Widget btn)
{
char btn_trans_str[] = "<Key>Return: ArmAndActivate()";
static XtTranslations btn_trans = 0;
# endif /* SelectByReturn */
-static void change_ims_list(last_ims_name, init_idx)
- char *last_ims_name;
- int init_idx;
+static void change_ims_list(char *last_ims_name, int init_idx)
{
int idx;
int i, j;
#undef IMS_OK
}
-static void set_host_label(host_type, hostname)
- int host_type;
- char *hostname;
+static void set_host_label(int host_type, char *hostname)
{
static Widget lb_host = 0;
}
-static void add_cmd_btn(parent_rc, cb_ok, cb_clear, cb_cancel, cb_host, cb_help)
- Widget parent_rc;
- void (*cb_ok)(), (*cb_cancel)(), (*cb_clear)(),
- (*cb_host)(), (*cb_help)();
+static void add_cmd_btn(Widget parent_rc, void (*cb_ok)(),
+ void (*cb_clear)(), void (*cb_cancel)(),
+ void (*cb_host)(), void (*cb_help)())
{
Widget pb[4];
Arg args[12];
/* ***** host window ***** */
-static void start_host_window(cur_host)
- char *cur_host;
+static void start_host_window(char *cur_host)
{
int ret;
return;
}
-static void finish_host_window()
+static void finish_host_window(void)
{
DPR(("finish_host_window()\n"));
}
}
-static void host_done_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void host_done_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
int cancel = (int)(intptr_t) client_data == CANCEL_BTN;
int ret = NoError;
#endif
}
-static void host_clear_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void host_clear_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
/* if (!HostText) return; */
XtVaSetValues(HostText, XmNvalue, "", NULL);
}
-static void host_done_action(w, ev, args, num_args)
- Widget w;
- XEvent *ev;
- String *args;
- Cardinal *num_args;
+static void host_done_action(Widget w, XEvent *ev, String *args, Cardinal *num_args)
{
host_done_cb(w, (XtPointer) OK_BTN, 0);
}
-static void create_host_window(cur_host)
- char *cur_host;
+static void create_host_window(char *cur_host)
{
Widget form, cmd_rc, lb1, sep, w_tbl[5];
Widget host_desc, host_rc, host_lb, host_txt;
static int OrgMode = SEL_MODE_NONE;
static int CurMode = SEL_MODE_NONE;
-int start_mode_window(cur_mode)
- int cur_mode;
+int start_mode_window(int cur_mode)
{
int ret;
return NoError;
}
-static void finish_mode_window(end_window)
- int end_window;
+static void finish_mode_window(int end_window)
{
if (ModeW) {
XtUnmanageChild(ModeW);
return;
}
-static void mode_done_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void mode_done_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
int ret = NoError;
int canceled = (int)(intptr_t) client_data == CANCEL_BTN;
/* never returns */
}
-static void mode_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void mode_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
int is_set = (int)((XmToggleButtonCallbackStruct *)call_data)->set;
int is_auto = (int)(intptr_t) client_data;
CurMode = (is_auto && is_set) ? SEL_MODE_AUTO : SEL_MODE_NOAUTO;
}
-static void mode_help_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void mode_help_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
ximsHelp(HELP_MODE);
}
-static int create_mode_window(cur_mode)
- int cur_mode;
+static int create_mode_window(int cur_mode)
{
Widget form, mode_rc, cmd_rc, lb1, sep, w_tbl[8];
Arg args[16];
/* ******** ximsHelp ******** */
-static void help_ok(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void help_ok(Widget w, XtPointer client_data, XtPointer call_data)
{
stop_help();
}
-void stop_help()
+void stop_help(void)
{
if (HelpW) {
XtUnmanageChild(HelpW);
}
}
-static void create_help()
+static void create_help(void)
{
int i;
Arg args[10];
return;
}
-void ximsHelp(help_type)
- int help_type;
+void ximsHelp(int help_type)
{
char *msg = NULL;
XmString str;
static int dialog_resp = XmCR_NONE;
static bool in_confirmation = False;
-static void dialog_resp_cb(w, client_data, call_data)
- Widget w;
- XtPointer client_data, call_data;
+static void dialog_resp_cb(Widget w, XtPointer client_data, XtPointer call_data)
{
Widget msg_box = (Widget) client_data;
XmAnyCallbackStruct *cbs = (XmAnyCallbackStruct *) call_data;
}
#ifdef unused
-static int wait_confirmation(w)
- Widget w;
+static int wait_confirmation(Widget w)
{
XtAppContext context;
}
#endif /* unused */
-int put_msg_win(type, msg)
- int type;
- char *msg;
+int put_msg_win(int type, char *msg)
{
int reply;
Widget btn;
#define LOC_RIGHT (1<<3)
#define LOC_MARGIN 5
-static int window_location(loc_str)
- char *loc_str;
+static int window_location(char *loc_str)
{
int locate_type = LOC_CENTER;
char *lower_str, *p;
return locate_type;
}
-static void locate_window(w)
- Widget w;
+static void locate_window(Widget w)
{
int scr;
int x, y;
/* ******** cursor (normal / wait) ******** */
-static void set_cursor(w, is_wait)
- Widget w;
- int is_wait;
+static void set_cursor(Widget w, int is_wait)
{
static Cursor cursors[2] = { None, None };
int idx;
/* ***** waiting functions ***** */
-void xevent_loop()
+void xevent_loop(void)
{
if (appC)
XtAppMainLoop(appC);
static XtIntervalId xt_last_timer = (XtIntervalId)0;
static bool xt_waiting = False;
-void xt_start_waiting()
+void xt_start_waiting(void)
{
if (!appC) return;
XtAppMainLoop(appC);
}
-void xt_stop_waiting()
+void xt_stop_waiting(void)
{
if (xt_last_timer) {
XtRemoveTimeOut(xt_last_timer);
ximsWaitDone();
}
-static void xt_timer_cb(client_data, timer_id)
- XtPointer client_data;
- XtIntervalId *timer_id;
+static void xt_timer_cb(XtPointer client_data, XtIntervalId *timer_id)
{
int lapse;
extern char *strcpy2(/* dest, src1, src2 */);
extern char *newstradded(/* src1, src2, src3 */);
extern int str_to_int(/* ptr, val */);
-extern bool str_to_bool(/* ptr, def_val */);
+extern bool str_to_bool(char *ptr, bool def_val);
extern char *trim_line(/* ptr */);
-extern char **parse_strlist(/* ptr, sep_ch */);
+extern char **parse_strlist(register char *ptr, char sep_ch);
extern int pack_strlist(/* ptr, listp, sep_ch */);
extern void free_strlist(/* pp */);
extern bool parse_dpy_str(/* display_str, host, dnum, snum, dnet */);
projects / oweals / cde.git / commitdiff