blob: 4268ef1c8236667c76943dbf0ffa118a74cf6c15 [file] [log] [blame]
#include "ckcsym.h"
/* C K U U S 7 -- "User Interface" for C-Kermit, part 7 */
/*
Authors:
Frank da Cruz <fdc@columbia.edu>,
The Kermit Project, Columbia University, New York City
Jeffrey E Altman <jaltman@secure-endpoints.com>
Secure Endpoints Inc., New York City
Copyright (C) 1985, 2004,
Trustees of Columbia University in the City of New York.
All rights reserved. See the C-Kermit COPYING.TXT file or the
copyright text in the ckcmai.c module for disclaimer and permissions.
*/
/*
This file created from parts of ckuus3.c, which became too big for
Mark Williams Coherent compiler to handle.
*/
/*
Definitions here supersede those from system include files.
*/
#include "ckcdeb.h" /* Debugging & compiler things */
#include "ckcasc.h" /* ASCII character symbols */
#include "ckcker.h" /* Kermit application definitions */
#include "ckcxla.h" /* Character set translation */
#include "ckcnet.h" /* Network symbols */
#include "ckuusr.h" /* User interface symbols */
#include "ckucmd.h"
#include "ckclib.h"
#ifdef VMS
#ifndef TCPSOCKET
#include <errno.h>
#endif /* TCPSOCKET */
#endif /* VMS */
#ifdef OS2
#ifndef NT
#define INCL_NOPM
#define INCL_VIO /* Needed for ckocon.h */
#define INCL_DOSMODULEMGR
#include <os2.h>
#undef COMMENT
#else /* NT */
#define APIRET ULONG
#include <windows.h>
#include <tapi.h>
#include "cknwin.h"
#include "ckntap.h"
#endif /* NT */
#include "ckowin.h"
#include "ckocon.h"
#include "ckodir.h"
#ifdef OS2MOUSE
#include "ckokey.h"
#endif /* OS2MOUSE */
#ifdef KUI
#include "ikui.h"
#endif /* KUI */
#ifdef putchar
#undef putchar
#endif /* putchar */
#define putchar(x) conoc(x)
extern int mskkeys;
#endif /* OS2 */
#ifdef CK_AUTHENTICATION
#include "ckuath.h"
#endif /* CK_AUTHENTICATION */
#ifdef CK_SSL
#include "ck_ssl.h"
#endif /* CK_SSL */
#ifdef SSHBUILTIN
#include "ckossh.h"
#endif /* SSHBUILTIN */
#ifdef STRATUS /* Stratus Computer, Inc. VOS */
#ifdef putchar
#undef putchar
#endif /* putchar */
#define putchar(x) conoc(x)
#ifdef getchar
#undef getchar
#endif /* getchar */
#define getchar(x) coninc(0)
#endif /* STRATUS */
char * slmsg = NULL;
static int x, y = 0, z;
static char *s;
extern CHAR feol;
extern int g_matchdot, hints, xcmdsrc, rcdactive;
extern char * k_info_dir;
#ifndef NOSPL
extern int nmac;
extern struct mtab *mactab;
#endif /* NOSPL */
#ifndef NOXFER
#ifdef CK_SPEED
extern short ctlp[]; /* Control-char prefixing table */
#endif /* CK_SPEED */
#ifdef PIPESEND
extern char * sndfilter, * g_sfilter;
extern char * rcvfilter, * g_rfilter;
#endif /* PIPESEND */
extern char * snd_move;
extern char * snd_rename;
extern char * g_snd_move;
extern char * g_snd_rename;
extern char * rcv_move;
extern char * rcv_rename;
extern char * g_rcv_move;
extern char * g_rcv_rename;
#ifdef PATTERNS
extern char *binpatterns[], *txtpatterns[];
extern int patterns;
#endif /* PATTERNS */
extern char * remdest;
#ifdef CK_TMPDIR
char * dldir = NULL;
#endif /* CK_TMPDIR */
extern struct ck_p ptab[];
extern int protocol, remfile, rempipe, remappd, reliable, xreliable, fmask,
fncnv, frecl, maxrps, wslotr, bigsbsiz, bigrbsiz, urpsiz, rpsiz, spsiz,
bctr, npad, timef, timint, spsizr, spsizf, maxsps, spmax, nfils, displa,
atcapr, pkttim, rtimo, fncact, mypadn, fdispla, f_save, pktpaus, setreliable,
fnrpath, fnspath, atenci, atenco, atdati, atdato, atleni, atleno, atblki,
atblko, attypi, attypo, atsidi, atsido, atsysi, atsyso, atdisi, atdiso;
extern int stathack;
extern int atfrmi, atfrmo;
#ifdef STRATUS
extern int atcrei, atcreo, atacti, atacto;
#endif /* STRATUS */
#ifdef CK_PERMS
extern int atlpri, atlpro, atgpri, atgpro;
#endif /* CK_PERMS */
extern CHAR
sstate, eol, seol, stchr, mystch, mypadc, padch, ctlq, myctlq;
#ifdef IKSD
extern int inserver;
#ifdef IKSDCONF
extern int iksdcf;
#endif /* IKSDCONF */
#endif /* IKSD */
extern char *cmarg, *cmarg2;
#ifndef NOFRILLS
extern char optbuf[]; /* Buffer for MAIL or PRINT options */
extern int rprintf; /* REMOTE PRINT flag */
#endif /* NOFRILLS */
#endif /* NOXFER */
#ifdef CK_TRIGGER
extern char * tt_trigger[];
#endif /* CK_TRIGGER */
extern int tcs_transp;
#ifdef PCTERM
extern int tt_pcterm;
#endif /* PCTERM */
#ifdef NT
extern int tt_vtnt;
#endif /* NT */
#ifdef SSHBUILTIN
int sl_ssh_xfw = 0;
int sl_ssh_xfw_saved = 0;
int sl_ssh_ver = 0;
int sl_ssh_ver_saved = 0;
#endif /* SSHBUILTIN */
#ifdef CK_AUTHENTICATION
extern int auth_type_user[];
int sl_auth_type_user[AUTHTYPLSTSZ] = {AUTHTYPE_NULL, AUTHTYPE_NULL};
int sl_auth_saved = 0;
int sl_topt_a_su = 0;
int sl_topt_a_s_saved = 0;
int sl_topt_a_cm = 0;
int sl_topt_a_c_saved = 0;
#endif /* CK_AUTHENTICATION */
#ifdef CK_ENCRYPTION
extern int cx_type;
int sl_cx_type = 0;
int sl_cx_saved = 0;
int sl_topt_e_su = 0;
int sl_topt_e_sm = 0;
int sl_topt_e_s_saved = 0;
int sl_topt_e_cu = 0;
int sl_topt_e_cm = 0;
int sl_topt_e_c_saved = 0;
#endif /* CK_ENCRYPTION */
extern char uidbuf[];
static int uidflag = 0;
char sl_uidbuf[UIDBUFLEN] = { NUL, NUL };
int sl_uid_saved = 0;
#ifdef TNCODE
int sl_tn_wait = 0;
int sl_tn_saved = 0;
#endif /* TNCODE */
#ifdef TNCODE
extern int tn_wait_flg;
#endif /* TNCODE */
VOID
slrestor() {
#ifdef CK_AUTHENTICATION
int x;
if (sl_auth_saved) {
for (x = 0; x < AUTHTYPLSTSZ; x++)
auth_type_user[x] = sl_auth_type_user[x];
sl_auth_saved = 0;
}
if (sl_topt_a_s_saved) {
TELOPT_DEF_S_U_MODE(TELOPT_AUTHENTICATION) = sl_topt_a_su;
sl_topt_a_s_saved = 0;
}
if (sl_topt_a_c_saved) {
TELOPT_DEF_C_ME_MODE(TELOPT_AUTHENTICATION) = sl_topt_a_cm;
sl_topt_a_c_saved = 0;
}
#endif /* CK_AUTHENTICATION */
#ifdef CK_ENCRYPTION
if (sl_cx_saved) {
cx_type = sl_cx_type;
sl_cx_saved = 0;
}
if (sl_topt_e_s_saved) {
TELOPT_DEF_S_U_MODE(TELOPT_ENCRYPTION) = sl_topt_e_su;
TELOPT_DEF_S_ME_MODE(TELOPT_ENCRYPTION) = sl_topt_e_sm;
sl_topt_e_s_saved = 0;
}
if (sl_topt_e_c_saved) {
TELOPT_DEF_C_U_MODE(TELOPT_ENCRYPTION) = sl_topt_e_cu;
TELOPT_DEF_C_ME_MODE(TELOPT_ENCRYPTION) = sl_topt_e_cm;
sl_topt_e_c_saved = 0;
}
#endif /* CK_ENCRYPTION */
if (sl_uid_saved) {
ckstrncpy(uidbuf,sl_uidbuf,UIDBUFLEN);
sl_uid_saved = 0;
}
#ifdef TNCODE
if (sl_tn_saved) {
tn_wait_flg = sl_tn_wait;
sl_tn_saved = 0;
}
#endif /* TNCODE */
#ifdef SSHBUILTIN
if (sl_ssh_xfw_saved) {
ssh_xfw = sl_ssh_xfw;
sl_ssh_xfw_saved = 0;
}
if (sl_ssh_ver_saved) {
ssh_ver = sl_ssh_ver;
sl_ssh_ver_saved = 0;
}
#endif /* SSHBUILTIN */
}
int oldplex = -1; /* Duplex holder around network */
#ifndef NOICP
#ifdef LOCUS
extern int locus, autolocus;
#endif /* LOCUS */
#ifndef NODIAL
extern int dialsta;
#endif /* NODIAL */
/* Note: gcc -Wall wants braces around each keyword table entry. */
static struct keytab psltab[] = { /* SET LINE/PORT command options */
{ "/connect", SL_CNX, 0 },
#ifdef OS2ORVMS
{ "/noshare", SL_NSH, 0 },
#endif /* OS2ORVMS */
{ "/server", SL_SRV, 0 },
#ifdef OS2ORVMS
{ "/share", SL_SHR, 0 },
#endif /* OS2ORVMS */
{ "", 0, 0 }
};
static int npsltab = sizeof(psltab)/sizeof(struct keytab) - 1;
#ifdef NETCONN
static struct keytab shtab[] = { /* SET HOST command options */
#ifdef NETCMD
/* (COMMAND is also a network type) */
{ "/command", SL_CMD, CM_INV },
#endif /* NETCMD */
{ "/connect", SL_CNX, 0 },
{ "/network-type", SL_NET, CM_ARG },
{ "/nowait", SL_NOWAIT, 0 },
#ifndef NOSPL
#ifdef CK_AUTHENTICATION
{ "/password", SL_PSW, CM_ARG },
#endif /* CK_AUTHENTICATION */
#endif /* NOSPL */
#ifdef NETCMD
{ "/pipe", SL_CMD, 0 },
#endif /* NETCMD */
#ifdef NETPTY
{ "/pty", SL_PTY, 0 },
#endif /* NETPTY */
{ "/server", SL_SRV, 0 },
{ "/timeout", SL_TMO, CM_ARG },
{ "/userid", SL_UID, CM_ARG },
{ "/wait", SL_WAIT, 0 },
{ "", 0, 0 }
};
static int nshtab = sizeof(shtab)/sizeof(struct keytab) - 1;
static struct keytab shteltab[] = { /* TELNET command options */
#ifdef CK_AUTHENTICATION
{ "/auth", SL_AUTH, CM_ARG },
#endif /* CK_AUTHENTICATION */
#ifdef CK_ENCRYPTION
{ "/encrypt", SL_ENC, CM_ARG },
#endif /* CK_ENCRYPTION */
{ "/nowait", SL_NOWAIT, 0 },
#ifndef NOSPL
#ifdef CK_AUTHENTICATION
{ "/password", SL_PSW, CM_ARG },
#endif /* CK_AUTHENTICATION */
#endif /* NOSPL */
{ "/timeout", SL_TMO, CM_ARG },
{ "/userid", SL_UID, CM_ARG },
{ "/wait", SL_WAIT, 0 },
{ "", 0 ,0 }
};
static int nshteltab = sizeof(shteltab)/sizeof(struct keytab) - 1;
#ifdef RLOGCODE
static struct keytab shrlgtab[] = { /* SET HOST RLOGIN command options */
#ifdef CK_KERBEROS
#ifdef CK_ENCRYPTION
{ "/encrypt", SL_ENC, 0 },
#endif /* CK_ENCRYPTION */
{ "/k4", SL_KRB4, CM_INV },
{ "/k5", SL_KRB5, CM_INV },
{ "/kerberos4", SL_KRB4, 0 },
{ "/kerberos5", SL_KRB5, 0 },
{ "/kerberos_iv", SL_KRB4, CM_INV },
{ "/kerberos_v", SL_KRB5, CM_INV },
{ "/krb4", SL_KRB4, CM_INV },
{ "/krb5", SL_KRB5, CM_INV },
#endif /* CK_KERBEROS */
{ "", 0 ,0 }
};
static int nshrlgtab = sizeof(shrlgtab)/sizeof(struct keytab)-1;
#endif /* RLOGCODE */
extern struct keytab netcmd[];
extern int nnets;
#ifndef NODIAL
extern int dirline;
extern int nnetdir; /* Network services directory */
extern char *netdir[];
_PROTOTYP( VOID ndreset, (void) );
char *nh_p[MAXDNUMS + 1]; /* Network directory entry pointers */
char *nh_p2[MAXDNUMS + 1]; /* Network directory entry nettype */
char *nh_px[4][MAXDNUMS + 1]; /* Network-specific stuff... */
#endif /* NODIAL */
int nhcount = 0;
int ndinited = 0;
char * n_name = NULL; /* Network name pointer */
#endif /* NETCONN */
_PROTOTYP(int remtxt, (char **) );
_PROTOTYP(VOID rmsg, (void) );
_PROTOTYP(static int remcfm, (void) );
extern int nopush;
int mdmsav = -1; /* Save modem type around network */
extern int isguest; /* Global flag for anonymous login */
extern xx_strp xxstring;
extern int success, binary, b_save, ckwarn, msgflg, quiet, cmask, pflag, local,
nettype, escape, mdmtyp, duplex, dfloc, network, cdtimo, autoflow, tnlm,
sosi, tlevel, lf_opts, backgrd, flow, debses, parity, ttnproto, ckxech,
x_ifnum, cmflgs, haveline, cxtype, cxflow[], maclvl;
#ifdef DCMDBUF
extern struct cmdptr *cmdstk; /* The command stack itself */
#else
extern struct cmdptr cmdstk[]; /* The command stack itself */
#endif /* DCMDBUF */
extern FILE * tfile[];
extern char * macp[];
extern char psave[]; /* For saving & restoring prompt */
extern int sprmlen, rprmlen;
#ifdef OS2
static struct keytab strmkeytab[] = {
{ "clear", 0, 0 },
{ "default", 1, 0 }
};
static int nstrmkeytab = sizeof(strmkeytab)/sizeof(struct keytab);
static struct keytab strmswitab[] = {
{ "/literal", 0, 0 }
};
static int nstrmswitab = sizeof(strmswitab)/sizeof(struct keytab);
static struct keytab normrev[] = {
{ "dark-display", 0, 0 },
{ "light-display", 1, 0 },
{ "normal", 0, 0 },
{ "reverse", 1, 0 }
};
static struct keytab prnmtab[] = {
{ "auto", 1, 0 },
{ "copy", 2, 0 },
{ "off", 0, 0 },
{ "on", 1, CM_INV }, /* Compatibility with XPRINT version */
{ "user", 3, 0 },
{ "transparent", 3, CM_INV } /* not really transparent */
};
static int nprnmtab = sizeof(prnmtab)/sizeof(struct keytab);
extern int tt_diff_upd;
#ifdef NT
#define stricmp _stricmp
extern int tt_attr_bug;
#endif /* NT */
extern int tt_rows[], tt_cols[];
extern int tt_cols_usr;
extern int tt_szchng[VNUM];
int tt_modechg = TVC_ENA;
extern int tt_url_hilite, tt_url_hilite_attr;
extern struct _vtG G[4];
extern int priority;
extern bool send_c1;
int send_c1_usr = FALSE;
extern int sgrcolors;
extern int marginbell, marginbellcol;
extern int autoscroll, wy_autopage;
extern int tt_sac;
extern int dec_nrc, dec_lang, dec_kbd;
#else /* OS2 */
extern int tt_rows, tt_cols;
#endif /* OS2 */
extern int tt_escape;
extern long speed;
extern char *dftty;
extern char *tp, *lp; /* Temporary buffer & pointers */
extern char ttname[];
#ifdef CK_TAPI
int tttapi = 0; /* is Line TAPI? */
struct keytab * tapilinetab = NULL;
struct keytab * _tapilinetab = NULL;
int ntapiline = 0;
#endif /* CK_TAPI */
#ifdef NETCONN /* Network items */
#ifdef ANYX25
extern int revcall, closgr, cudata, nx25;
extern char udata[];
extern struct keytab x25tab[];
#ifndef IBMX25
extern int npadx3;
extern CHAR padparms[];
extern struct keytab padx3tab[];
#endif /* IBMX25 */
#endif /* ANYX25 */
#ifdef OS2
extern bool ttshare;
#ifndef NT
extern bool ttslip,ttppp;
#endif /* NT */
#endif /* OS2 */
#ifdef NPIPE
extern char pipename[];
#endif /* NPIPE */
#ifdef TCPSOCKET
static struct keytab tcprawtab[] = { /* SET HOST options */
{ "/default", NP_DEFAULT, CM_INV },
#ifdef CK_AUTHENTICATION
#ifdef CK_KERBEROS
#ifdef RLOGCODE
{ "/ek4login", NP_EK4LOGIN, 0 },
{ "/ek5login", NP_EK5LOGIN, 0 },
{ "/k4login", NP_K4LOGIN, 0 },
{ "/k5login", NP_K5LOGIN, 0 },
#endif /* RLOGCODE */
#ifdef KRB5_U2U
{ "/k5user2user", NP_K5U2U, 0 },
#endif /* KRB5_U2U */
#endif /* CK_KERBEROS */
#endif /* CK_AUTHENTICATION */
{ "/no-telnet-init", NP_NONE, 0 },
{ "/none", NP_NONE, CM_INV },
{ "/raw-socket", NP_TCPRAW, 0 },
#ifdef RLOGCODE
{ "/rlogin", NP_RLOGIN, 0 },
#endif /* RLOGCODE */
#ifdef CK_SSL
{ "/ssl", NP_SSL, 0 },
{ "/ssl-telnet", NP_SSL_TELNET, 0 },
#endif /* CK_SSL */
{ "/telnet", NP_TELNET, 0 },
#ifdef CK_SSL
{ "/tls", NP_TLS, 0 },
{ "/tls-telnet", NP_TLS_TELNET, 0 },
#endif /* CK_SSL */
{ "", 0, 0 }
};
static int ntcpraw = (sizeof(tcprawtab) / sizeof(struct keytab)) - 1;
#ifdef RLOGCODE
_PROTOTYP( int rlog_naws, (void) );
#endif /* RLOGCODE */
#endif /* TCPSOCKET */
#ifdef SUPERLAT
extern char slat_pwd[18];
#endif /* SUPERLAT */
#endif /* NETCONN */
#ifdef COMMENT
#ifndef NOSETKEY
extern KEY *keymap;
#ifndef OS2
#define mapkey(x) keymap[x]
#endif /* OS2 */
extern MACRO *macrotab;
#ifndef NOKVERBS
extern struct keytab kverbs[];
extern int nkverbs;
#endif /* NOKVERBS */
#endif /* NOSETKEY */
#else
#ifndef NOSETKEY
extern KEY *keymap;
extern MACRO *macrotab;
#ifndef NOKVERBS
extern struct keytab kverbs[];
extern int nkverbs;
#endif /* NOKVERBS */
#endif /* NOSETKEY */
#endif /* COMMENT */
#ifdef OS2 /* AUTODOWNLOAD parameters */
extern int adl_kmode, adl_zmode; /* Match Packet to signal download */
extern char * adl_kstr; /* KERMIT Download String */
extern char * adl_zstr; /* ZMODEM Download String */
extern int adl_kc0, adl_zc0; /* Process ADL C0s in emulation */
#endif /* OS2 */
/* Keyword tables ... */
extern struct keytab onoff[], rltab[];
extern int nrlt;
#ifndef NOCSETS
static struct keytab fdfltab[] = {
{ "7bit-character-set", 7, 0 },
{ "8bit-character-set", 8, 0 }
};
static int nfdflt = (sizeof(fdfltab) / sizeof(struct keytab));
#endif /* NOCSETS */
/* SET FILE parameters */
static struct keytab filtab[] = {
#ifndef NOXFER
#ifdef PATTERNS
{ "binary-patterns", XYFIBP, 0 },
#endif /* PATTERNS */
{ "bytesize", XYFILS, 0 },
#ifndef NOCSETS
{ "character-set", XYFILC, 0 },
#endif /* NOCSETS */
{ "collision", XYFILX, 0 },
{ "default", XYF_DFLT, 0 },
{ "destination", XYFILY, 0 },
{ "display", XYFILD, CM_INV },
#ifdef CK_TMPDIR
{ "download-directory", XYFILG, 0 },
#endif /* CK_TMPDIR */
#endif /* NOXFER */
{ "end-of-line", XYFILA, 0 },
{ "eol", XYFILA, CM_INV },
#ifdef CK_CTRLZ
{ "eof", XYFILV, 0 },
#endif /* CK_CTRLZ */
#ifndef NOXFER
{ "fastlookups", 9997, CM_INV },
{ "incomplete", XYFILI, 0 },
#ifndef datageneral
{ "inspection", XYF_INSP, CM_INV },
#endif /* datageneral */
#ifdef CK_LABELED
{ "label", XYFILL, 0 },
#endif /* CK_LABELED */
#ifdef UNIX
#ifdef DYNAMIC
{ "listsize", XYF_LSIZ, 0 },
#endif /* DYNAMIC */
#endif /* UNIX */
{ "names", XYFILN, 0 },
#ifdef UNIX
{ "output", XYFILH, 0 },
#endif /* UNIX */
#ifdef PATTERNS
{ "patterns", XYFIPA, 0 },
#endif /* PATTERNS */
#ifdef COMMENT /* Not implemented (but see CHMOD) */
{ "permissions", XYF_PRM, CM_INV },
{ "protection", XYF_PRM, 0 },
#endif /* COMMENt */
#ifdef VMS
{ "record-length", XYFILR, 0 },
#endif /* VMS */
#ifndef datageneral
{ "scan", XYF_INSP, 0 },
#endif /* datageneral */
#ifdef UNIX
#ifdef DYNAMIC
{ "stringspace", XYF_SSPA, 0 },
#endif /* DYNAMIC */
#endif /* UNIX */
#ifdef PATTERNS
{ "t", XYFILT, CM_INV|CM_ABR },
{ "text-patterns", XYFITP, 0 },
#endif /* PATTERNS */
#endif /* NOXFER */
{ "type", XYFILT, 0 },
#ifdef UNICODE
{ "ucs", XYFILU, 0 },
#endif /* UNICODE */
#ifndef NOXFER
{ "warning", XYFILW, CM_INV }
#endif /* NOXFER */
};
static int nfilp = (sizeof(filtab) / sizeof(struct keytab));
struct keytab pathtab[] = {
{ "absolute", PATH_ABS, 0 },
{ "none", PATH_OFF, CM_INV },
{ "off", PATH_OFF, 0 },
{ "on", PATH_ABS, CM_INV },
{ "relative", PATH_REL, 0 }
};
int npathtab = (sizeof(pathtab) / sizeof(struct keytab));
struct keytab rpathtab[] = {
{ "absolute", PATH_ABS, 0 },
{ "auto", PATH_AUTO, 0 },
{ "none", PATH_OFF, CM_INV },
{ "off", PATH_OFF, 0 },
{ "on", PATH_ABS, CM_INV },
{ "relative", PATH_REL, 0 }
};
int nrpathtab = (sizeof(rpathtab) / sizeof(struct keytab));
#ifdef CK_CTRLZ
struct keytab eoftab[] = { /* EOF detection method */
{ "ctrl-z", 1, 0 },
{ "length", 0, 0 },
{ "noctrl-z", 0, CM_INV }
};
#endif /* CK_CTRLZ */
struct keytab fttab[] = { /* File types for SET FILE TYPE */
{ "ascii", XYFT_T, CM_INV },
#ifdef VMS
{ "b", XYFT_B, CM_INV|CM_ABR },
#endif /* VMS */
{ "binary", XYFT_B, 0 },
#ifdef VMS
{ "block", XYFT_I, CM_INV },
{ "image", XYFT_I, 0 },
#endif /* VMS */
#ifdef CK_LABELED
{ "labeled", XYFT_L, 0 },
#endif /* CK_LABELED */
#ifdef MAC
{ "macbinary", XYFT_M, 0 },
#endif /* MAC */
{ "text", XYFT_T, 0 }
};
int nfttyp = (sizeof(fttab) / sizeof(struct keytab));
static struct keytab rfttab[] = { /* File types for REMOTE SET FILE */
{ "ascii", XYFT_T, CM_INV },
{ "binary", XYFT_B, 0 },
#ifdef VMS
{ "labeled", XYFT_L, 0 },
#else
#ifdef OS2
{ "labeled", XYFT_L, 0 },
#endif /* OS2 */
#endif /* VMS */
{ "text", XYFT_T, 0 }
};
static int nrfttyp = (sizeof(rfttab) / sizeof(struct keytab));
#ifdef OS2ORUNIX
#define ZOF_BLK 0
#define ZOF_NBLK 1
#define ZOF_BUF 2
#define ZOF_NBUF 3
static struct keytab zoftab[] = {
{ "blocking", ZOF_BLK, 0 },
{ "buffered", ZOF_BUF, 0 },
{ "nonblocking", ZOF_NBLK, 0 },
{ "unbuffered", ZOF_NBUF, 0 }
};
static int nzoftab = (sizeof(zoftab) / sizeof(struct keytab));
#endif /* OS2ORUNIX */
extern int query; /* Global flag for QUERY active */
#ifndef NOSPL
#ifndef NOXFER
static struct keytab vartyp[] = { /* Variable types for REMOTE QUERY */
{ "global", (int) 'G', CM_INV },
{ "kermit", (int) 'K', 0 },
{ "system", (int) 'S', 0 },
{ "user", (int) 'G', 0 }
};
static int nvartyp = (sizeof(vartyp) / sizeof(struct keytab));
#endif /* NOXFER */
#endif /* NOSPL */
#ifdef CK_TIMERS
static struct keytab timotab[] = { /* Timer types */
{ "dynamic", 1, 0 },
{ "fixed", 0, 0 }
};
#endif /* CK_TIMERS */
#ifdef DCMDBUF
extern char *atxbuf, *atmbuf; /* Atom buffer */
extern char *cmdbuf; /* Command buffer */
extern char *line, *tmpbuf; /* Character buffers for anything */
extern int *intime; /* INPUT TIMEOUT */
#else /* Not DCMDBUF ... */
extern char atxbuf[], atmbuf[]; /* Atom buffer */
extern char cmdbuf[]; /* Command buffer */
extern char line[], tmpbuf[]; /* Character buffer for anything */
extern int intime[];
#endif /* DCMDBUF */
#ifndef NOCSETS
extern struct keytab fcstab[]; /* For SET FILE CHARACTER-SET */
extern struct csinfo fcsinfo[]; /* File character set info. */
extern struct keytab ttcstab[];
extern int nfilc, fcharset, tcharset, ntermc, tcsr, tcsl, dcset7, dcset8;
#ifdef CKOUNI
extern int tt_utf8;
#endif /* CKOUNI */
#ifdef OS2
_PROTOTYP( int os2setcp, (int) );
_PROTOTYP( int os2getcp, (void) );
_PROTOTYP( void os2debugoff, (void) );
#endif /* OS2 */
#endif /* NOCSETS */
extern int cmdlvl; /* Overall command level */
#ifndef NOSPL
#ifdef DCMDBUF
extern int *inpcas; /* INPUT CASE setting on cmd stack */
#else
extern int inpcas[];
#endif /* DCMDBUF */
#endif /* NOSPL */
#ifdef CK_CURSES
#ifndef VMS
_PROTOTYP(int tgetent,(char *, char *));
#else
#ifdef __DECC
_PROTOTYP(int tgetent,(char *, char *));
#endif /* __DECC */
#endif /* VMS */
#endif /* CK_CURSES */
#ifndef NOXMIT
#define XMITF 0 /* SET TRANSMIT values */
#define XMITL 1 /* (Local to this module) */
#define XMITP 2
#define XMITE 3
#define XMITX 4
#define XMITS 5
#define XMITW 6
#define XMITT 7
#define XMBUFL 50
extern int xmitf, xmitl, xmitp, xmitx, xmits, xmitw, xmitt;
char xmitbuf[XMBUFL+1] = { NUL }; /* TRANSMIT eof string */
struct keytab xmitab[] = { /* SET TRANSMIT */
{ "echo", XMITX, 0 },
{ "eof", XMITE, 0 },
{ "fill", XMITF, 0 },
{ "linefeed", XMITL, 0 },
{ "locking-shift", XMITS, 0 },
{ "pause", XMITW, 0 },
{ "prompt", XMITP, 0 },
{ "timeout", XMITT, 0 }
};
int nxmit = (sizeof(xmitab) / sizeof(struct keytab));
#endif /* NOXMIT */
/* For SET FILE COLLISION */
/* Some of the following may be possible for some C-Kermit implementations */
/* but not others. Those that are not possible for your implementation */
/* should be ifdef'd out. */
struct keytab colxtab[] = { /* SET FILE COLLISION options */
#ifndef MAC
{ "append", XYFX_A, 0 }, /* append to old file */
#endif /* MAC */
#ifdef COMMENT
{ "ask", XYFX_Q, 0 }, /* ask what to do (not implemented) */
#endif
{ "backup", XYFX_B, 0 }, /* rename old file */
#ifndef MAC
/* This crashes Mac Kermit. */
{ "discard", XYFX_D, 0 }, /* don't accept new file */
{ "no-supersede", XYFX_D, CM_INV }, /* ditto (MSK compatibility) */
#endif /* MAC */
{ "overwrite", XYFX_X, 0 }, /* overwrite the old file */
{ "rename", XYFX_R, 0 }, /* rename the incoming file */
#ifndef MAC /* This crashes Mac Kermit. */
{ "update", XYFX_U, 0 }, /* replace if newer */
#endif /* MAC */
{ "", 0, 0 }
};
int ncolx = (sizeof(colxtab) / sizeof(struct keytab)) - 1;
static struct keytab rfiltab[] = { /* for REMOTE SET FILE */
#ifndef NOCSETS
{ "character-set", XYFILC, 0 },
#endif /* NOCSETS */
{ "collision", XYFILX, 0 },
{ "incomplete", XYFILI, 0 },
{ "names", XYFILN, 0 },
{ "record-length", XYFILR, 0 },
{ "type", XYFILT, 0 }
};
int nrfilp = (sizeof(rfiltab) / sizeof(struct keytab));
struct keytab eoltab[] = { /* File eof delimiters */
{ "cr", XYFA_C, 0 },
{ "crlf", XYFA_2, 0 },
{ "lf", XYFA_L, 0 }
};
static int neoltab = (sizeof(eoltab) / sizeof(struct keytab));
struct keytab fntab[] = { /* File naming */
{ "converted", XYFN_C, 0 },
{ "literal", XYFN_L, 0 },
{ "standard", XYFN_C, CM_INV }
};
int nfntab = (sizeof(fntab) / sizeof(struct keytab));
#ifndef NOLOCAL
/* Terminal parameters table */
static struct keytab trmtab[] = {
#ifdef OS2
{ "answerback", XYTANS, 0 },
#endif /* OS2 */
#ifdef CK_APC
{ "apc", XYTAPC, 0 },
#endif /* CK_APC */
#ifdef OS2
{ "arrow-keys", XYTARR, 0 },
#endif /* OS2 */
#ifdef NT
{ "at", XYTATTR, CM_INV|CM_ABR },
{ "att", XYTATTR, CM_INV|CM_ABR },
{ "attr", XYTATTR, CM_INV|CM_ABR },
{ "attr-bug", XYTATTBUG, CM_INV },
#endif /* NT */
#ifdef OS2
{ "attribute", XYTATTR, 0 },
#endif /* OS2 */
#ifdef CK_APC
#ifdef CK_AUTODL
{ "autodownload", XYTAUTODL, 0, },
#endif /* CK_AUTODL */
#endif /* CK_APC */
#ifdef OS2
{ "autopage", XYTAPAGE, 0 },
{ "autoscroll", XYTASCRL, 0 },
{ "bell", XYTBEL, CM_INV },
#endif /* OS2 */
{ "bytesize", XYTBYT, 0 },
#ifndef NOCSETS
{ "character-set", XYTCS, 0 },
#endif /* NOCSETS */
#ifdef OS2
{ "code-page", XYTCPG, 0 },
{ "color", XYTCOL, 0 },
{ "controls", XYTCTRL, 0 },
#endif /* OS2 */
{ "cr-display", XYTCRD, 0 },
#ifdef OS2
{ "cursor", XYTCUR, 0 },
#endif /* OS2 */
{ "debug", XYTDEB, 0 },
#ifdef OS2
{ "dg-unix-mode", XYTUNX, 0 },
#endif /* OS2 */
{ "echo", XYTEC, 0 },
{ "escape-character", XYTESC, 0 },
#ifdef OS2
#ifdef PCFONTS
{ "font", XYTFON, 0 },
#else
#ifdef KUI
{ "font", XYTFON, 0 },
#endif /* KUI */
#endif /* PCFONTS */
#endif /* OS2 */
{ "height", XYTHIG, 0 },
#ifdef CKTIDLE
{ "idle-action", XYTIACT, 0 },
{ "idle-limit", XYTITMO, CM_INV },
{ "idle-send", XYTIDLE, CM_INV },
{ "idle-timeout", XYTITMO, 0 },
#endif /* CKTIDLE */
#ifdef OS2
#ifndef NOCSETS
{ "kbd-follows-gl/gr", XYTKBDGL, 0 },
#endif /* NOCSETS */
{ "key", XYTKEY, 0 },
{ "keyboard-mode", XYTKBMOD, 0 },
{ "keypad-mode", XYTKPD, 0 },
#endif /* OS2 */
#ifndef NOCSETS
#ifdef OS2
#ifndef KUI
{ "line-spacing", XYTLSP, CM_INV },
{ "local-character-set", XYTLCS, 0 },
#else
{ "line-spacing", XYTLSP, 0 },
{ "local-character-set", XYTLCS, CM_INV },
#endif /* KUI */
#else
{ "local-character-set", XYTLCS, CM_INV },
#endif /* OS2 */
#endif /* NOCSETS */
{ "locking-shift", XYTSO, 0 },
#ifdef OS2
{ "margin-bell", XYTMBEL, 0 },
#endif /* OS2 */
#ifdef OS2MOUSE
{ "mouse", XYTMOU, CM_INV },
#endif /* OS2MOUSE */
{ "newline-mode", XYTNL, 0 },
#ifdef OS2
{ "output-pacing", XYTPAC, 0 },
#ifdef PCTERM
{ "pcterm", XYTPCTERM, 0 },
#endif /* PCTERM */
#endif /* OS2 */
#ifdef OS2ORUNIX
{ "print", XYTPRN, 0 },
#endif /* OS2ORUNIX */
#ifndef NOCSETS
#ifdef OS2
{ "remote-character-set", XYTRCS, 0 },
#else
{ "remote-character-set", XYTRCS, CM_INV },
#endif /* OS2 */
#endif /* NOCSETS */
#ifdef OS2
{ "roll-mode", XYTROL, 0 },
{ "s", XYTUPD, CM_ABR|CM_INV },
{ "sc", XYTUPD, CM_ABR|CM_INV },
{ "scr", XYTUPD, CM_ABR|CM_INV },
{ "scree", XYTUPD, CM_ABR|CM_INV },
{ "screen", XYTUPD, CM_ABR|CM_INV },
{ "screen-", XYTUPD, CM_ABR|CM_INV },
{ "screen-mode", XYTSCNM, 0 },
{ "screen-optimize", XYTOPTI, 0 },
{ "screen-update", XYTUPD, 0 },
{ "scrollback", XYSCRS, 0 },
{ "send-data", XYTSEND, 0 },
{ "send-end-of-block", XYTSEOB, 0 },
{ "sgr-colors", XYTSGRC, 0 },
{ "sni-ch.code", XYTSNICC, 0 },
{ "sni-firmware-versions", XYTSNIFV, 0 },
{ "sni-language", XYTVTLNG, 0 },
{ "sni-pagemode", XYTSNIPM, CM_INV },
{ "sni-scrollmode", XYTSNISM, CM_INV },
{ "spacing-attribute-character", XYTSAC, CM_INV },
{ "statusline", XYTSTAT, 0 },
{ "tra", XYTCTS, CM_INV|CM_ABR },
{ "transmit-timeout", XYTCTS, 0 },
#endif /* OS2 */
#ifdef OS2ORUNIX
{ "transparent-print", XYTPRN, CM_INV },
#endif /* OS2ORUNIX */
#ifdef CK_TRIGGER
{ "trigger", XYTRIGGER,0 },
#endif /* CK_TRIGGER */
#ifdef OS2
{ "type", XYTTYP, 0 },
#else
{ "type", XYTTYP, CM_INV },
#endif /* OS2 */
#ifndef NOCSETS
#ifdef UNICODE
#ifdef CKOUNI
{ "unicode", XYTUNI, CM_INV },
#endif /* CKOUNI */
#endif /* UNICODE */
#endif /* NOCSETS */
#ifdef OS2
{ "unix-mode", XYTUNX, CM_INV },
{ "url-highlight", XYTURLHI, 0 },
#ifdef NT
{ "video-change", XYTVCH, 0 },
#endif /* NT */
{ "vt-language", XYTVTLNG, 0 },
{ "vt-nrc-mode", XYTVTNRC, 0 },
#endif /* OS2 */
{ "width", XYTWID, 0 },
#ifdef OS2
{ "wrap", XYTWRP, 0 },
#endif /* OS2 */
{ "", 0, 0 }
};
int ntrm = (sizeof(trmtab) / sizeof(struct keytab)) - 1;
#ifdef OS2
struct keytab termctrl[] = { /* SET TERM CONTROLS */
{ "7", 7, 0 },
{ "8", 8, 0 }
};
int ntermctrl = (sizeof(termctrl) / sizeof(struct keytab));
struct keytab curontab[] = { /* SET TERM CURSOR */
#ifdef KUI
{ "noblink", 2, 0 },
#else
{ "noblink", 2, CM_INV },
#endif /* KUI */
{ "off", 0, 0 },
{ "on", 1, 0 }
};
int ncuron = (sizeof(curontab) / sizeof(struct keytab));
struct keytab rolltab[] = { /* Set TERM Roll Options */
{ "insert", TTR_INSERT, 0 },
{ "keystrokes",TTR_KEYS, 0 },
{ "off", TTR_OVER, CM_INV },
{ "on", TTR_INSERT, CM_INV },
{ "overwrite", TTR_OVER, 0 }
};
int nroll = (sizeof(rolltab) / sizeof(struct keytab));
struct keytab rollkeytab[] = { /* Set TERM ROLL KEYSTROKES */
{ "ignore", TTRK_IGN, 0 },
{ "restore-and-send", TTRK_RST, 0 },
{ "send", TTRK_SND, 0 }
};
int nrollkey = (sizeof(rollkeytab) / sizeof(struct keytab));
#define TT_GR_ALL 4
#define TT_GR_G0 0
#define TT_GR_G1 1
#define TT_GR_G2 2
#define TT_GR_G3 3
#define TT_GR_KBD 4
struct keytab graphsettab[] = { /* DEC VT Graphic Sets */
{ "all", TT_GR_ALL, 0 },
{ "g0", TT_GR_G0, 0 },
{ "g1", TT_GR_G1, 0 },
{ "g2", TT_GR_G2, 0 },
{ "g3", TT_GR_G3, 0 },
{ "keyboard", TT_GR_KBD, 0 }
};
int ngraphset = (sizeof(graphsettab) / sizeof(struct keytab));
#endif /* OS2 */
struct keytab adltab[] = { /* Autodownload Options */
{ "ask", TAD_ASK, 0 },
{ "error", TAD_ERR, 0 },
#ifdef OS2
{ "kermit", TAD_K, 0 },
#endif /* OS2 */
{ "off", TAD_OFF, 0 },
{ "on", TAD_ON, 0 },
#ifdef OS2
{ "zmodem", TAD_Z, 0 },
#endif /* OS2 */
{ "", 0, 0 }
};
int nadltab = (sizeof(adltab) / sizeof(struct keytab)) - 1;
struct keytab adlerrtab[] = { /* Autodownload Error Options */
{ "continue", 0, 0 },
{ "go", 0, CM_INV },
{ "stop", 1, 0 }
};
int nadlerrtab = (sizeof(adlerrtab) / sizeof(struct keytab));
#ifdef OS2
struct keytab adlxtab[] = { /* Autodownload Options */
{ "c0-conflicts", TAD_X_C0, 0 },
{ "detection-method", TAD_X_DETECT, 0 },
{ "string", TAD_X_STR, 0 }
};
int nadlxtab = (sizeof(adlxtab) / sizeof(struct keytab));
struct keytab adldtab[] = { /* Auto-dl Detection Methods */
{ "packet", ADL_PACK, 0 },
{ "string", ADL_STR, 0 }
};
int nadldtab = (sizeof(adldtab) / sizeof(struct keytab));
struct keytab adlc0tab[] = { /* Auto-dl Detection Methods */
{ "ignored-by-emulator", 0, 0 },
{ "processed-by-emulator", 1, 0 }
};
int nadlc0tab = (sizeof(adlc0tab) / sizeof(struct keytab));
#ifndef NOCSETS
struct keytab vtlangtab[] = {
{ "belgian", VTL_BELGIAN , 0 },
{ "british", VTL_BRITISH , 0 },
{ "canadian", VTL_CANADIAN, 0 },
{ "czech", VTL_CZECH , 0 },
{ "danish", VTL_DANISH , 0 },
{ "dutch", VTL_DUTCH , 0 },
{ "finnish", VTL_FINNISH , 0 },
{ "french", VTL_FRENCH , 0 },
{ "french-canadian",VTL_FR_CAN , 0 },
{ "german", VTL_GERMAN , 0 },
{ "greek", VTL_GREEK , 0 },
{ "hebrew", VTL_HEBREW , 0 },
{ "hungarian", VTL_HUNGARIA, 0 },
{ "italian", VTL_ITALIAN , 0 },
{ "latin-american", VTL_LATIN_AM, 0 },
{ "north-american", VTL_NORTH_AM, 0 },
{ "norwegian", VTL_NORWEGIA, 0 },
{ "polish", VTL_POLISH , 0 },
{ "portugese", VTL_PORTUGES, 0 },
{ "romanian", VTL_ROMANIAN, 0 },
{ "russian", VTL_RUSSIAN , 0 },
{ "scs", VTL_SCS , CM_INV },
{ "slovak", VTL_SLOVAK , 0 },
{ "spanish", VTL_SPANISH , 0 },
{ "swedish", VTL_SWEDISH , 0 },
{ "swiss-french", VTL_SW_FR , 0 },
{ "swiss-german", VTL_SW_GR , 0 },
{ "turkish-f", VTL_TURK_F , CM_INV },
{ "turkish-q", VTL_TURK_Q , CM_INV }
};
int nvtlangtab = (sizeof(vtlangtab) / sizeof(struct keytab));
#endif /* NOCSETS */
#endif /* OS2 */
struct keytab crdtab[] = { /* Carriage-return display */
{ "crlf", 1, 0 },
{ "normal", 0, 0 }
};
extern int tt_crd; /* Carriage-return display variable */
#ifdef CK_APC
extern int apcstatus, apcactive;
static struct keytab apctab[] = { /* Terminal APC parameters */
{ "no-input", APC_ON|APC_NOINP,0 },
{ "off", APC_OFF, 0 },
{ "on", APC_ON, 0 },
{ "unchecked", APC_ON|APC_UNCH, 0 },
{ "unchecked-no-input", APC_ON|APC_NOINP|APC_UNCH, 0 }
};
int napctab = (sizeof(apctab) / sizeof(struct keytab));
#endif /* CK_APC */
#endif /* NOLOCAL */
extern int autodl, adl_err, adl_ask;
struct keytab beltab[] = { /* Terminal bell mode */
#ifdef OS2
{ "audible", XYB_AUD, 0 },
{ "none", XYB_NONE, 0 },
#else
{ "audible", XYB_AUD, CM_INV },
{ "none", XYB_NONE, CM_INV },
#endif /* OS2 */
#ifdef OS2
{ "off", XYB_NONE, CM_INV },
{ "on", XYB_AUD, CM_INV },
#else
{ "off", XYB_NONE, 0 },
{ "on", XYB_AUD, 0 },
#endif /* OS2 */
#ifdef OS2
{ "visible", XYB_VIS, 0 },
#endif /* OS2 */
{ "", 0, 0 }
};
int nbeltab = sizeof(beltab)/sizeof(struct keytab) - 1;
int tt_unicode = 1; /* Use Unicode if possible */
#ifdef CKTIDLE
int tt_idlesnd_tmo = 0; /* Idle Send Timeout, disabled */
char * tt_idlesnd_str = NULL; /* Idle Send String, none */
char * tt_idlestr = NULL;
extern int tt_idleact, tt_idlelimit;
#endif /* CKTIDLE */
#ifdef OS2
#ifndef NOLOCAL
/*
OS/2 serial communication devices.
*/
struct keytab os2devtab[] = {
{ "1", 1, CM_INV }, /* Invisible synonyms, like */
{ "2", 2, CM_INV }, /* "set port 1" */
{ "3", 3, CM_INV },
{ "4", 4, CM_INV },
{ "5", 5, CM_INV },
{ "6", 6, CM_INV },
{ "7", 7, CM_INV },
{ "8", 8, CM_INV },
{ "com1", 1, 0 }, /* Real device names */
{ "com2", 2, 0 },
{ "com3", 3, 0 },
{ "com4", 4, 0 },
{ "com5", 5, 0 },
{ "com6", 6, 0 },
{ "com7", 7, 0 },
{ "com8", 8, 0 },
#ifdef OS2ONLY
{ "slipcom1", 1, 0 }, /* For use with SLIP driver */
{ "slipcom2", 2, 0 }, /* shared access */
{ "slipcom3", 3, 0 },
{ "slipcom4", 4, 0 },
{ "slipcom5", 5, 0 },
{ "slipcom6", 6, 0 },
{ "slipcom7", 7, 0 },
{ "slipcom8", 8, 0 },
{ "pppcom1", 1, 0 }, /* For use with PPP driver */
{ "pppcom2", 2, 0 }, /* shared access */
{ "pppcom3", 3, 0 },
{ "pppcom4", 4, 0 },
{ "pppcom5", 5, 0 },
{ "pppcom6", 6, 0 },
{ "pppcom7", 7, 0 },
{ "pppcom8", 8, 0 }
#endif /* OS2ONLY */
};
int nos2dev = (sizeof(os2devtab) / sizeof(struct keytab)) - 1;
#ifdef OS2ONLY
struct keytab os2ppptab[] = {
{ "0", 0, CM_INV },
{ "1", 1, CM_INV }, /* Invisible synonyms, like */
{ "2", 2, CM_INV }, /* "set port 1" */
{ "3", 3, CM_INV },
{ "4", 4, CM_INV },
{ "5", 5, CM_INV },
{ "6", 6, CM_INV },
{ "7", 7, CM_INV },
{ "8", 8, CM_INV },
{ "9", 9, CM_INV },
{ "ppp0", 0, 0 },
{ "ppp1", 1, 0 }, /* For use with PPP driver */
{ "ppp2", 2, 0 }, /* shared access */
{ "ppp3", 3, 0 },
{ "ppp4", 4, 0 },
{ "ppp5", 5, 0 },
{ "ppp6", 6, 0 },
{ "ppp7", 7, 0 },
{ "ppp8", 8, 0 },
{ "ppp9", 9, 0 }
};
int nos2ppp = (sizeof(os2ppptab) / sizeof(struct keytab));
#endif /* OS2ONLY */
/*
Terminal parameters that can be set by SET commands.
Used by the ck?con.c terminal emulator code.
For now, only used for #ifdef OS2. Should add these for Macintosh.
*/
int tt_arrow = TTK_NORM; /* Arrow key mode: normal (cursor) */
int tt_keypad = TTK_NORM; /* Keypad mode: normal (numeric) */
int tt_shift_keypad = 0; /* Keypad Shift mode: Off */
int tt_wrap = 1; /* Terminal wrap, 1 = On */
int tt_type = TT_VT320; /* Terminal type, initially VT320 */
int tt_type_mode = TT_VT320; /* Terminal type set by host command */
int tt_cursor = 0; /* Terminal cursor, 0 = Underline */
int tt_cursor_usr = 0; /* Users Terminal cursor type */
int tt_cursorena_usr = 1; /* Users Terminal cursor enabled */
int tt_cursor_blink = 1; /* Terminal Cursor Blink */
int tt_answer = 0; /* Terminal answerback (disabled) */
int tt_scrsize[VNUM] = {512,512,512,1}; /* Terminal scrollback buffer size */
int tt_roll[VNUM] = {1,1,1,1}; /* Terminal roll (on) */
int tt_rkeys[VNUM] = {1,1,1,1}; /* Terminal roll keys (send) */
int tt_pacing = 0; /* Terminal output-pacing (none) */
int tt_ctstmo = 15; /* Terminal transmit-timeout */
int tt_codepage = -1; /* Terminal code-page */
int tt_update = 100; /* Terminal screen-update interval */
int tt_updmode = TTU_FAST; /* Terminal screen-update mode FAST */
extern int updmode;
#ifndef KUI
int tt_status[VNUM] = {1,1,0,0}; /* Terminal status line displayed */
int tt_status_usr[VNUM] = {1,1,0,0};
#else /* KUI */
extern CKFLOAT floatval;
CKFLOAT tt_linespacing[VNUM] = {1.0,1.0,1.0,1.0};
#ifdef K95G
int tt_status[VNUM] = {1,1,0,0}; /* Terminal status line displayed */
int tt_status_usr[VNUM] = {1,1,0,0};
#else /* K95G */
int tt_status[VNUM] = {0,0,0,0}; /* Terminal status line displayed */
int tt_status_usr[VNUM] = {0,0,0,0};
#endif /* K95G */
#endif /* KUI */
int tt_senddata = 0; /* Let host read terminal data */
extern int wy_blockend; /* Terminal Send Data EOB type */
int tt_hidattr = 1; /* Attributes are hidden */
extern unsigned char colornormal, colorselect,
colorunderline, colorstatus, colorhelp, colorborder,
colorgraphic, colordebug, colorreverse, coloritalic;
extern int trueblink, trueunderline, truereverse, trueitalic, truedim;
extern int bgi, fgi;
extern int scrninitialized[];
struct keytab audibletab[] = { /* Terminal Bell Audible mode */
{ "beep", XYB_BEEP, 0 }, /* Values ORd with bell mode */
{ "system-sounds", XYB_SYS, 0 }
};
int naudibletab = sizeof(audibletab)/sizeof(struct keytab);
struct keytab akmtab[] = { /* Arrow key mode */
{ "application", TTK_APPL, 0 },
{ "cursor", TTK_NORM, 0 }
};
struct keytab kpmtab[] = { /* Keypad mode */
{ "application", TTK_APPL, 0 },
{ "numeric", TTK_NORM, 0 }
};
struct keytab ttcolmodetab[] = {
{ "current-color", 0, 0 },
{ "default-color", 1, 0 }
};
int ncolmode = sizeof(ttcolmodetab)/sizeof(struct keytab);
#define TTCOLNOR 0
#define TTCOLREV 1
#define TTCOLUND 2
#define TTCOLSTA 3
#define TTCOLHLP 4
#define TTCOLBOR 5
#define TTCOLSEL 6
#define TTCOLDEB 7
#define TTCOLGRP 8
#define TTCOLITA 9
#define TTCOLRES 10
#define TTCOLERA 11
struct keytab ttycoltab[] = { /* Terminal Screen coloring */
{ "border", TTCOLBOR, 0 }, /* Screen border color */
{ "debug-terminal", TTCOLDEB, 0 }, /* Debug color */
{ "erase", TTCOLERA, 0 }, /* Erase mode */
{ "graphic", TTCOLGRP, 0 }, /* Graphic Color */
{ "help-text", TTCOLHLP, 0 }, /* Help screens */
{ "italic", TTCOLITA, 0 }, /* Italic Color */
{ "normal", TTCOLNOR, CM_INV }, /* Normal screen text */
{ "reset-on-esc[0m", TTCOLRES, 0 }, /* Reset on ESC [ 0 m */
{ "reverse-video", TTCOLREV, 0 }, /* Reverse video */
{ "status-line", TTCOLSTA, 0 }, /* Status line */
{ "selection", TTCOLSEL, 0 }, /* Selection color */
{ "terminal-screen", TTCOLNOR, 0 }, /* Better name than "normal" */
{ "underlined-text", TTCOLUND, 0 } /* Underlined text */
};
int ncolors = (sizeof(ttycoltab) / sizeof(struct keytab));
#define TTATTNOR 0
#define TTATTBLI 1
#define TTATTREV 2
#define TTATTUND 3
#define TTATTPRO 4
#define TTATTBLD 5
#define TTATTDIM 6
#define TTATTINV 7
#define TTATTITA 8
#define TTATTDONE 9
struct keytab ttyattrtab[] = {
{ "blink", TTATTBLI, 0 },
{ "dim", TTATTDIM, 0 },
{ "italic", TTATTITA, 0 },
{ "protected", TTATTPRO, 0 },
{ "reverse", TTATTREV, 0 },
{ "underline", TTATTUND, 0 }
};
int nattrib = (sizeof(ttyattrtab) / sizeof(struct keytab));
struct keytab ttyprotab[] = {
{ "blink", TTATTBLI, 0 },
{ "bold", TTATTBLD, 0 },
{ "dim", TTATTDIM, 0 },
{ "done", TTATTDONE, CM_INV },
{ "invisible", TTATTINV, 0 },
{ "italic", TTATTITA, 0 },
{ "normal", TTATTNOR, 0 },
{ "reverse", TTATTREV, 0 },
{ "underlined", TTATTUND, 0 }
};
int nprotect = (sizeof(ttyprotab) / sizeof(struct keytab));
struct keytab ttyseobtab[] = {
{ "crlf_etx", 1, 0 },
{ "us_cr", 0, 0 }
};
struct keytab ttyclrtab[] = { /* Colors */
{ "black", 0, 0 },
{ "blue", 1, 0 },
{ "brown", 6, 0 },
{ "cyan", 3, 0 },
{ "darkgray", 8, CM_INV },
{ "dgray", 8, 0 },
{ "green", 2, 0 },
{ "lblue", 9, CM_INV },
{ "lcyan", 11, CM_INV },
{ "lgray", 7, CM_INV },
{ "lgreen", 10, CM_INV },
{ "lightblue", 9, 0 },
{ "lightcyan", 11, 0 },
{ "lightgray", 7, 0 },
{ "lightgreen", 10, 0 },
{ "lightmagenta", 13, 0 },
{ "lightred", 12, 0 },
{ "lmagenta", 13, CM_INV },
{ "lred", 12, CM_INV },
{ "magenta", 5, 0 },
{ "red", 4, 0 },
{ "white", 15, 0 },
{ "yellow", 14, 0 }
};
int nclrs = (sizeof (ttyclrtab) / sizeof (struct keytab));
struct keytab ttycurtab[] = {
{ "full", TTC_BLOCK, 0 },
{ "half", TTC_HALF, 0 },
{ "underline", TTC_ULINE, 0 }
};
int ncursors = 3;
struct keytab ttyptab[] = {
{ "aaa", TT_AAA, CM_INV }, /* AnnArbor */
{ "adm3a", TT_ADM3A, 0 }, /* LSI ADM-3A */
{ "adm5", TT_ADM5, 0 }, /* LSI ADM-5 */
{ "aixterm", TT_AIXTERM, 0 }, /* IBM AIXterm */
{ "annarbor", TT_AAA, 0 }, /* AnnArbor */
{ "ansi-bbs", TT_ANSI, 0 }, /* ANSI.SYS (BBS) */
{ "at386", TT_AT386, 0 }, /* Unixware ANSI */
{ "avatar/0+",TT_ANSI, 0 }, /* AVATAR/0+ */
{ "ba80", TT_BA80, 0 }, /* Nixdorf BA80 */
{ "be", TT_BEOS, CM_INV|CM_ABR },
{ "beos-ansi",TT_BEOS, CM_INV }, /* BeOS ANSI */
{ "beterm", TT_BEOS, 0 }, /* BeOS Terminal (as of PR2 ) */
{ "d200", TT_DG200, CM_INV|CM_ABR }, /* Data General DASHER 200 */
{ "d210", TT_DG210, CM_INV|CM_ABR }, /* Data General DASHER 210 */
{ "d217", TT_DG217, CM_INV|CM_ABR }, /* Data General DASHER 217 */
{ "dg200", TT_DG200, 0 }, /* Data General DASHER 200 */
{ "dg210", TT_DG210, 0 }, /* Data General DASHER 210 */
{ "dg217", TT_DG217, 0 }, /* Data General DASHER 217 */
{ "h1500", TT_HZL1500, CM_INV }, /* Hazeltine 1500 */
{ "h19", TT_H19, CM_INV }, /* Heath-19 */
{ "heath19", TT_H19, 0 }, /* Heath-19 */
{ "hft", TT_HFT, 0 }, /* IBM High Function Terminal */
{ "hp2621a", TT_HP2621, 0 }, /* HP 2621A */
{ "hpterm", TT_HPTERM, 0 }, /* HP TERM */
{ "hz1500", TT_HZL1500, 0 }, /* Hazeltine 1500 */
{ "ibm3151", TT_IBM31, 0 }, /* IBM 3101-xx,3161 */
{ "linux", TT_LINUX, 0 }, /* Linux */
{ "qansi", TT_QANSI, 0 }, /* QNX ANSI */
{ "qnx", TT_QNX, 0 }, /* QNX Console */
{ "scoansi", TT_SCOANSI, 0 }, /* SCO ANSI */
{ "sni-97801",TT_97801, 0 }, /* SNI 97801 */
{ "sun", TT_SUN, 0 }, /* SUN Console */
/*
The idea of NONE is to let the console driver handle the escape sequences,
which, in theory at least, would give not only ANSI emulation, but also any
other kind of emulation that might be provided by alternative console
drivers, if any existed.
For this to work, ckocon.c would need to be modified to make higher-level
calls, like VioWrtTTY(), DosWrite(), or (simply) write(), rather than
VioWrt*Cell() and similar, and it would also have to give up its rollback
feature, and its status line and help screens would also have to be
forgotten or else done in an ANSI way.
As matters stand, we already have perfectly good ANSI emulation built in,
and there are no alternative console drivers available, so there is no point
in having a terminal type of NONE, so it is commented out. However, should
you uncomment it, it will work like a "glass tty" -- no escape sequence
interpretation at all; somewhat similar to debug mode, except without the
debugging (no highlighting of control chars or escape sequences); help
screens, status line, and rollback will still work.
*/
#ifdef OS2PM
#ifdef COMMENT
{ "tek4014", TT_TEK40, 0 },
#endif /* COMMENT */
#endif /* OS2PM */
{ "tty", TT_NONE, 0 },
{ "tvi910+", TT_TVI910, 0 },
{ "tvi925", TT_TVI925, 0 },
{ "tvi950", TT_TVI950, 0 },
{ "vc404", TT_VC4404, 0 },
{ "vc4404", TT_VC4404, CM_INV },
{ "vip7809", TT_VIP7809,0 },
{ "vt100", TT_VT100, 0 },
{ "vt102", TT_VT102, 0 },
{ "vt220", TT_VT220, 0 },
{ "vt220pc", TT_VT220PC,0 },
{ "vt320", TT_VT320, 0 },
{ "vt320pc", TT_VT320PC,0 },
{ "vt52", TT_VT52, 0 },
#ifdef NT
{ "vtnt", TT_VTNT, 0 },
#else /* NT */
{ "vtnt", TT_VTNT, CM_INV },
#endif /* NT */
{ "wy160", TT_WY160, 0 },
{ "wy30", TT_WY30, 0 },
{ "wy370", TT_WY370, 0 },
{ "wy50", TT_WY50, 0 },
{ "wy60", TT_WY60, 0 },
{ "wyse30", TT_WY30, CM_INV },
{ "wyse370", TT_WY370, CM_INV },
{ "wyse50", TT_WY50, CM_INV },
{ "wyse60", TT_WY60, CM_INV }
};
int nttyp = (sizeof(ttyptab) / sizeof(struct keytab));
struct keytab ttkeytab[] = {
{ "aaa", TT_AAA, CM_INV }, /* AnnArbor */
{ "adm3a", TT_ADM3A, 0 }, /* LSI ADM-3A */
{ "adm5", TT_ADM5, 0 }, /* LSI ADM-5 */
{ "aixterm", TT_AIXTERM, 0 }, /* IBM AIXterm */
{ "annarbor", TT_AAA, 0 }, /* AnnArbor */
{ "ansi-bbs", TT_ANSI, 0 }, /* ANSI.SYS (BBS) */
{ "at386", TT_AT386, 0 }, /* Unixware ANSI */
{ "avatar/0+", TT_ANSI, 0 }, /* AVATAR/0+ */
{ "ba80", TT_BA80, 0 }, /* Nixdorf BA80 */
{ "be", TT_BEOS, CM_INV|CM_ABR },
{ "beos-ansi", TT_BEOS, CM_INV }, /* BeOS ANSI */
{ "beterm", TT_BEOS, 0 }, /* BeOS Terminal (DR2) */
{ "d200", TT_DG200, CM_INV|CM_ABR }, /* DG DASHER 200 */
{ "d210", TT_DG210, CM_INV|CM_ABR }, /* DG DASHER 210 */
{ "d217", TT_DG217, CM_INV|CM_ABR }, /* DG DASHER 217 */
{ "dg200", TT_DG200, 0 }, /* DG DASHER 200 */
{ "dg210", TT_DG210, 0 }, /* DG DASHER 210 */
{ "dg217", TT_DG217, 0 }, /* DG DASHER 217 */
{ "emacs", TT_KBM_EMACS, 0 }, /* Emacs mode */
{ "h19", TT_H19, CM_INV }, /* Heath-19 */
{ "heath19", TT_H19, 0 }, /* Heath-19 */
{ "hebrew", TT_KBM_HEBREW, 0 }, /* Hebrew mode */
{ "hft", TT_HFT, 0 }, /* IBM High Function Term */
{ "hp2621a", TT_HP2621, 0 }, /* HP 2621A */
{ "hpterm", TT_HPTERM, 0 }, /* HP TERM */
{ "hz1500", TT_HZL1500, 0 }, /* Hazeltine 1500 */
{ "ibm3151", TT_IBM31, 0 }, /* IBM 3101-xx,3161 */
{ "linux", TT_LINUX, 0 }, /* Linux */
{ "qansi", TT_QANSI, 0 }, /* QNX ANSI */
{ "qnx", TT_QNX, 0 }, /* QNX */
{ "russian", TT_KBM_RUSSIAN,0 }, /* Russian mode */
{ "scoansi", TT_SCOANSI, 0 }, /* SCO ANSI */
{ "sni-97801", TT_97801, 0 }, /* SNI 97801 */
{ "sun", TT_SUN, 0 }, /* SUN Console */
#ifdef OS2PM
#ifdef COMMENT
{ "tek4014", TT_TEK40, 0 },
#endif /* COMMENT */
#endif /* OS2PM */
{ "tty", TT_NONE, 0 },
{ "tvi910+", TT_TVI910, 0 },
{ "tvi925", TT_TVI925, 0 },
{ "tvi950", TT_TVI950, 0 },
{ "vc404", TT_VC4404, 0 },
{ "vc4404", TT_VC4404, CM_INV },
{ "vip7809", TT_VIP7809, 0 },
{ "vt100", TT_VT100, 0 },
{ "vt102", TT_VT102, 0 },
{ "vt220", TT_VT220, 0 },
{ "vt220pc", TT_VT220PC, 0 },
{ "vt320", TT_VT320, 0 },
{ "vt320pc", TT_VT320PC, 0 },
{ "vt52", TT_VT52, 0 },
{ "vtnt", TT_VTNT, CM_INV },
{ "wp", TT_KBM_WP, 0 }, /* Word Perfect mode */
{ "wy160", TT_WY160, 0 },
{ "wy30", TT_WY30, 0 },
{ "wy370", TT_WY370, 0 },
{ "wy50", TT_WY50, 0 },
{ "wy60", TT_WY60, 0 },
{ "wyse30", TT_WY30, CM_INV },
{ "wyse370", TT_WY370, CM_INV },
{ "wyse50", TT_WY50, CM_INV },
{ "wyse60", TT_WY60, CM_INV }
};
int nttkey = (sizeof(ttkeytab) / sizeof(struct keytab));
#ifndef NOSETKEY
struct keytab kbmodtab[] = {
{ "emacs", KBM_EM, 0 },
{ "english", KBM_EN, CM_INV },
{ "hebrew", KBM_HE, 0 },
{ "normal", KBM_EN, 0 },
{ "none", KBM_EN, CM_INV },
{ "russian", KBM_RU, 0 },
{ "wp", KBM_WP, 0 }
};
int nkbmodtab = (sizeof(kbmodtab) / sizeof(struct keytab));
#endif /* NOSETKEY */
#endif /* NOLOCAL */
int tt_inpacing = 0; /* input-pacing (none) */
struct keytab prtytab[] = { /* OS/2 Priority Levels */
{ "foreground-server", XYP_SRV, 0 },
{ "idle", XYP_IDLE, CM_INV },
{ "regular", XYP_REG, 0 },
{ "time-critical", XYP_RTP, 0 }
};
int nprty = (sizeof(prtytab) / sizeof(struct keytab));
#endif /* OS2 */
#ifdef NT
struct keytab win95tab[] = { /* Win95 work-arounds */
{ "8.3-filenames", XYW8_3, 0 },
{ "alt-gr", XYWAGR, 0 },
{ "horizontal-scan-line-substitutions", XYWHSL, 0 },
{ "keyboard-translation", XYWKEY, 0 },
{ "lucida-substitutions", XYWLUC, 0 },
{ "overlapped-io", XYWOIO, 0 },
{ "popups", XYWPOPUP, 0 },
{ "select-bug", XYWSELECT, 0 }
};
int nwin95 = (sizeof(win95tab) / sizeof(struct keytab));
#endif /* NT */
#ifdef OS2MOUSE
extern int wideresult;
int tt_mouse = 1; /* Terminal mouse on/off */
struct keytab mousetab[] = { /* Mouse items */
{ "activate", XYM_ON, 0 },
{ "button", XYM_BUTTON, 0 },
{ "clear", XYM_CLEAR, 0 },
{ "debug", XYM_DEBUG, 0 }
};
int nmtab = (sizeof(mousetab)/sizeof(struct keytab));
struct keytab mousebuttontab[] = { /* event button */
{ "1", XYM_B1, 0 },
{ "2", XYM_B2, 0 },
{ "3", XYM_B3, 0 },
{ "one", XYM_B1, CM_INV },
{ "three", XYM_B3, CM_INV },
{ "two", XYM_B2, CM_INV }
};
int nmbtab = (sizeof(mousebuttontab) / sizeof(struct keytab));
struct keytab mousemodtab[] = { /* event button key modifier */
{ "alt", XYM_ALT, 0 },
{ "alt-shift", XYM_SHIFT|XYM_ALT, 0 },
{ "ctrl", XYM_CTRL, 0 },
{ "ctrl-alt", XYM_CTRL|XYM_ALT, 0 },
{ "ctrl-alt-shift", XYM_CTRL|XYM_SHIFT|XYM_ALT, 0 },
{ "ctrl-shift", XYM_CTRL|XYM_SHIFT, 0 },
{ "none", 0, 0 },
{ "shift", XYM_SHIFT, 0 }
};
int nmmtab = (sizeof(mousemodtab) / sizeof(struct keytab));
struct keytab mclicktab[] = { /* event button click modifier */
{ "click", XYM_C1, 0 },
{ "drag", XYM_DRAG, 0 },
{ "double-click", XYM_C2, 0 }
};
int nmctab = (sizeof(mclicktab) / sizeof(struct keytab));
#ifndef NOKVERBS
extern int nkverbs;
extern struct keytab kverbs[];
#endif /* NOKVERBS */
#endif /* OS2MOUSE */
/* #ifdef VMS */
struct keytab fbtab[] = { /* Binary record types for VMS */
{ "fixed", XYFT_B, 0 }, /* Fixed is normal for binary */
{ "undefined", XYFT_U, 0 } /* Undefined if they ask for it */
};
int nfbtyp = (sizeof(fbtab) / sizeof(struct keytab));
/* #endif */
#ifdef VMS
struct keytab lbltab[] = { /* Labeled File info */
{ "acl", LBL_ACL, 0 },
{ "backup-date", LBL_BCK, 0 },
{ "name", LBL_NAM, 0 },
{ "owner", LBL_OWN, 0 },
{ "path", LBL_PTH, 0 }
};
int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
#else
#ifdef OS2
struct keytab lbltab[] = { /* Labeled File info */
{ "archive", LBL_ARC, 0 },
{ "extended", LBL_EXT, 0 },
{ "hidden", LBL_HID, 0 },
{ "read-only", LBL_RO, 0 },
{ "system", LBL_SYS, 0 }
};
int nlblp = (sizeof(lbltab) / sizeof(struct keytab));
#endif /* OS2 */
#endif /* VMS */
#ifdef CK_CURSES
#ifdef CK_PCT_BAR
static struct keytab fdftab[] = { /* SET FILE DISPLAY FULL options */
{ "thermometer", 1, 0, },
{ "no-thermometer", 0, 0 }
};
extern int thermometer;
#endif /* CK_PCT_BAR */
#endif /* CK_CURSES */
static struct keytab fdtab[] = { /* SET FILE DISPLAY options */
#ifdef MAC /* Macintosh */
{ "fullscreen", XYFD_R, 0 }, /* Full-screen but not curses */
{ "none", XYFD_N, 0 },
{ "off", XYFD_N, CM_INV },
{ "on", XYFD_R, CM_INV },
{ "quiet", XYFD_N, CM_INV },
#else /* Not Mac */
{ "brief", XYFD_B, 0 }, /* Brief */
{ "crt", XYFD_S, 0 }, /* CRT display */
#ifdef CK_CURSES
#ifdef COMMENT
{ "curses", XYFD_C, CM_INV }, /* Full-screen, curses */
#endif /* COMMENT */
{ "fullscreen", XYFD_C, 0 }, /* Full-screen, whatever the method */
#endif /* CK_CURSES */
#ifdef KUI
{ "gui", XYFD_G, 0 }, /* GUI */
#endif /* KUI */
{ "none", XYFD_N, 0 }, /* No display */
{ "off", XYFD_N, CM_INV }, /* Ditto */
{ "on", XYFD_R, CM_INV }, /* On = Serial */
{ "quiet", XYFD_N, CM_INV }, /* No display */
{ "serial", XYFD_R, 0 }, /* Serial */
#endif /* MAC */
{ "", 0, 0 }
};
int nfdtab = (sizeof(fdtab) / sizeof(struct keytab)) - 1;
struct keytab rsrtab[] = { /* For REMOTE SET RECEIVE */
{ "packet-length", XYLEN, 0 },
{ "timeout", XYTIMO, 0 }
};
int nrsrtab = (sizeof(rsrtab) / sizeof(struct keytab));
/* Send/Receive Parameters */
struct keytab srtab[] = {
{ "backup", XYBUP, 0 },
#ifndef NOCSETS
{ "character-set-selection", XYCSET, 0 },
#endif /* NOCSETS */
{ "control-prefix", XYQCTL, 0 },
#ifdef CKXXCHAR
{ "double-character", XYDBL, 0 },
#endif /* CKXXCHAR */
{ "end-of-packet", XYEOL, 0 },
#ifdef PIPESEND
{ "filter", XYFLTR, 0 },
#endif /* PIPESEND */
#ifdef CKXXCHAR
{ "ignore-character", XYIGN, 0 },
#endif /* CKXXCHAR */
{ "i-packets", 993, 0 },
{ "move-to", XYMOVE, 0 },
{ "negotiation-string-max-length", XYINIL, CM_INV },
{ "packet-length", XYLEN, 0 },
{ "pad-character", XYPADC, 0 },
{ "padding", XYNPAD, 0 },
{ "pathnames", XYFPATH, 0 },
{ "pause", XYPAUS, 0 },
#ifdef CK_PERMS
{ "permissions", 994, 0}, /* 206 */
#endif /* CK_PERMS */
{ "quote", XYQCTL, CM_INV }, /* = CONTROL-PREFIX */
{ "rename-to", XYRENAME, 0 },
{ "start-of-packet", XYMARK, 0 },
{ "timeout", XYTIMO, 0 },
#ifdef VMS
{ "version-numbers", 887, 0 }, /* VMS version numbers */
#endif /* VMS */
{ "", 0, 0 }
};
int nsrtab = (sizeof(srtab) / sizeof(struct keytab)) - 1;
#ifdef UNICODE
#define UCS_BOM 1
#define UCS_BYT 2
static struct keytab ucstab[] = {
{ "bom", UCS_BOM, 0 },
{ "byte-order", UCS_BYT, 0 },
{ "", 0, 0 }
};
int nucstab = (sizeof(ucstab) / sizeof(struct keytab)) - 1;
static struct keytab botab[] = {
{ "big-endian", 0, 0 },
{ "little-endian", 1, 0 }
};
static int nbotab = 2;
#endif /* UNICODE */
/* REMOTE SET */
struct keytab rmstab[] = {
{ "attributes", XYATTR, 0 },
{ "block-check", XYCHKT, 0 },
{ "file", XYFILE, 0 },
{ "incomplete", XYIFD, CM_INV }, /* = REMOTE SET FILE INCOMPLETE */
{ "match", XYMATCH,0 },
{ "receive", XYRECV, 0 },
{ "retry", XYRETR, 0 },
{ "server", XYSERV, 0 },
{ "transfer", XYXFER, 0 },
{ "window", XYWIND, 0 },
{ "xfer", XYXFER, CM_INV }
};
int nrms = (sizeof(rmstab) / sizeof(struct keytab));
struct keytab attrtab[] = {
#ifdef STRATUS
{ "account", AT_ACCT, 0 },
#endif /* STRATUS */
{ "all", AT_XALL, 0 },
#ifdef COMMENT
{ "blocksize", AT_BLKS, 0 }, /* (not used) */
#endif /* COMMENT */
#ifndef NOCSETS
{ "character-set", AT_ENCO, 0 },
#endif /* NOCSETS */
#ifdef STRATUS
{ "creator", AT_CREA, 0 },
#endif /* STRATUS */
{ "date", AT_DATE, 0 },
{ "disposition", AT_DISP, 0 },
{ "encoding", AT_ENCO, CM_INV },
{ "format", AT_RECF, CM_INV },
{ "length", AT_LENK, 0 },
{ "off", AT_ALLN, 0 },
{ "on", AT_ALLY, 0 },
#ifdef COMMENT
{ "os-specific", AT_SYSP, 0 }, /* (not used by UNIX or VMS) */
#endif /* COMMENT */
#ifdef CK_PERMS
{ "protection", AT_LPRO, 0 },
{ "permissions", AT_LPRO, CM_INV },
#endif /* CK_PERMS */
{ "record-format", AT_RECF, 0 },
{ "system-id", AT_SYSI, 0 },
{ "type", AT_FTYP, 0 }
};
int natr = (sizeof(attrtab) / sizeof(struct keytab)); /* how many attributes */
#ifdef CKTIDLE
struct keytab idlacts[] = {
{ "exit", IDLE_EXIT, 0 },
{ "hangup", IDLE_HANG, 0 },
{ "output", IDLE_OUT, 0 },
{ "return", IDLE_RET, 0 },
#ifdef TNCODE
{ "telnet-nop", IDLE_TNOP, 0 },
{ "telnet-ayt", IDLE_TAYT, 0 },
#endif /* TNCODE */
{ "", 0, 0 }
};
int nidlacts = (sizeof(idlacts) / sizeof(struct keytab)) - 1;
#endif /* CKTIDLE */
#ifndef NOSPL
extern int indef, inecho, insilence, inbufsize, inautodl, inintr;
#ifdef CKFLOAT
extern CKFLOAT inscale;
#endif /* CKFLOAT */
extern char * inpbuf, * inpbp;
#ifdef OS2
extern int interm;
#endif /* OS2 */
struct keytab inptab[] = { /* SET INPUT parameters */
#ifdef CK_AUTODL
{ "autodownload", IN_ADL, 0 },
#endif /* CK_AUTODL */
{ "buffer-length", IN_BUF, 0 },
{ "cancellation", IN_CAN, 0 },
{ "case", IN_CAS, 0 },
{ "default-timeout", IN_DEF, CM_INV }, /* There is no default timeout */
{ "echo", IN_ECH, 0 },
#ifdef OS2
{ "pacing", IN_PAC, CM_INV },
#endif /* OS2 */
{ "scale-factor", IN_SCA, 0 },
{ "silence", IN_SIL, 0 },
#ifdef OS2
{ "terminal", IN_TRM, 0 },
#endif /* OS2 */
{ "timeout-action", IN_TIM, 0 }
};
int ninp = (sizeof(inptab) / sizeof(struct keytab));
struct keytab intimt[] = { /* SET INPUT TIMEOUT parameters */
{ "proceed", 0, 0 }, /* 0 = proceed */
{ "quit", 1, 0 } /* 1 = quit */
};
struct keytab incast[] = { /* SET INPUT CASE parameters */
{ "ignore", 0, 0 }, /* 0 = ignore */
{ "observe", 1, 0 } /* 1 = observe */
};
#endif /* NOSPL */
struct keytab nabltab[] = { /* For any command that needs */
{ "disabled", 0, 0 },
{ "enabled", 1, 0 },
{ "off", 0, CM_INV }, /* these keywords... */
{ "on", 1, CM_INV }
};
int nnabltab = sizeof(nabltab) / sizeof(struct keytab);
#ifdef OS2
struct keytab tvctab[] = { /* SET TERM VIDEO-CHANGE */
{ "disabled", TVC_DIS, 0 },
{ "enabled", TVC_ENA, 0 },
#ifdef NT
{ "win95-safe", TVC_W95, 0 },
#endif /* NT */
{ "", 0, 0 }
};
int ntvctab = (sizeof(tvctab) / sizeof(struct keytab)) - 1;
struct keytab msktab[] = { /* SET MS-DOS KERMIT compatibilities */
#ifdef COMMENT
{ "color", MSK_COLOR, 0 },
#endif /* COMMENT */
{ "keycodes", MSK_KEYS, 0 }
};
int nmsk = (sizeof(msktab) / sizeof(struct keytab));
struct keytab scrnupd[] = { /* SET TERMINAL SCREEN-UPDATE */
{ "fast", TTU_FAST, 0 },
{ "smooth", TTU_SMOOTH, 0 }
};
int nscrnupd = (sizeof(scrnupd) / sizeof(struct keytab));
#ifdef PCFONTS
/* This definition of the term_font[] table is only for */
/* the OS/2 Full Screen Session and is not used on Windows */
struct keytab term_font[] = { /* SET TERMINAL FONT */
#ifdef COMMENT
{ "cp111", TTF_111, 0 },
{ "cp112", TTF_112, 0 },
{ "cp113", TTF_113, 0 },
#endif /* COMMENT */
{ "cp437", TTF_437, 0 },
{ "cp850", TTF_850, 0 },
#ifdef COMMENT
{ "cp851", TTF_851, 0 },
#endif /* COMMENT */
{ "cp852", TTF_852, 0 },
#ifdef COMMENT
{ "cp853", TTF_853, 0 },
{ "cp860", TTF_860, 0 },
{ "cp861", TTF_861, 0 },
#endif /* COMMENT */
{ "cp862", TTF_862, 0 },
#ifdef COMMENT
{ "cp863", TTF_863, 0 },
{ "cp864", TTF_864, 0 },
{ "cp865", TTF_865, 0 },
#endif /* COMMENT */
{ "cp866", TTF_866, 0 },
#ifdef COMMENT
{ "cp880", TTF_880, 0 },
{ "cp881", TTF_881, 0 },
{ "cp882", TTF_882, 0 },
{ "cp883", TTF_883, 0 },
{ "cp884", TTF_884, 0 },
{ "cp885", TTF_885, 0 },
#endif /* COMMENT */
{ "default",TTF_ROM,0 }
};
int ntermfont = (sizeof(term_font) / sizeof(struct keytab));
int tt_font = TTF_ROM; /* Terminal screen font */
#else /* PCFONTS */
#ifdef NT
#ifdef KUI
struct keytab * term_font = NULL;
struct keytab * _term_font = NULL;
char * tt_facename = NULL;
int ntermfont = 0;
int tt_font = 0;
int tt_font_size = 0;
#endif /* KUI */
#endif /* NT */
#endif /* PCFONTS */
struct keytab anbktab[] = { /* For any command that needs */
{ "message", 2, 0 }, /* these keywords... */
{ "off", 0, 0 },
{ "on", 1, 0 },
{ "unsafe-messag0", 99, CM_INV },
{ "unsafe-message", 3, CM_INV }
};
int nansbk = (sizeof(anbktab) / sizeof(struct keytab));
int win95_popup = 1;
#ifdef NT
#ifdef KUI
int win95lucida = 0;
int win95hsl = 1;
#else /* KUI */
int win95lucida = 1;
int win95hsl = 1;
#endif /* KUI */
#else /* NT */
int win95lucida = 0;
int win95hsl = 1;
#endif /* NT */
#ifdef NT
int win95altgr = 0;
extern int win95selectbug;
extern int win95_8_3;
#ifdef COMMENT
extern CHAR (*xlr[MAXTCSETS+1][MAXFCSETS+1])(CHAR);
extern struct keytab tcstab[];
extern int ntcs;
#endif /* COMMENT */
extern int maxow, maxow_usr; owwait; /* Overlapped I/O variables */
#endif /* NT */
#endif /* OS2 */
/* The following routines broken out of doprm() to give compilers a break. */
/* S E T O N -- Parse on/off (default on), set parameter to result */
int
seton(prm) int *prm; {
int x, y;
if ((y = cmkey(onoff,2,"","on",xxstring)) < 0) return(y);
if ((x = cmcfm()) < 0) return(x);
*prm = y;
return(1);
}
/* S E T O N A U T O -- Parse on/off/auto (default auto) & set result */
struct keytab onoffaut[] = {
{ "auto", SET_AUTO, 0 }, /* 2 */
{ "off", SET_OFF, 0 }, /* 0 */
{ "on", SET_ON, 0 } /* 1 */
};
int
setonaut(prm) int *prm; {
int x, y;
if ((y = cmkey(onoffaut,3,"","auto",xxstring)) < 0) return(y);
if ((x = cmcfm()) < 0) return(x);
*prm = y;
return(1);
}
/* S E T N U M -- Set parameter to result of cmnum() parse. */
/*
Call with pointer to integer variable to be set,
x = number from cnum parse, y = return code from cmnum,
max = maximum value to accept, -1 if no maximum.
Returns -9 on failure, after printing a message, or 1 on success.
*/
int
setnum(prm,x,y,max) int x, y, *prm, max; {
debug(F101,"setnum","",y);
if (y == -3) {
printf("\n?Value required\n");
return(-9);
}
if (y == -2) {
printf("%s?Not a number: %s\n",cmflgs == 1 ? "" : "\n", atxbuf);
return(-9);
}
if (y < 0) return(y);
if (max > -1 && x > max) {
printf("?Sorry, %d is the maximum\n",max);
return(-9);
}
if ((y = cmcfm()) < 0) return(y);
*prm = x;
return(1);
}
/* S E T C C -- Set parameter var to an ASCII control character value. */
/*
Parses a number, or a literal control character, or a caret (^) followed
by an ASCII character whose value is 63-95 or 97-122, then gets confirmation,
then sets the parameter to the code value of the character given. If there
are any parse errors, they are returned, otherwise on success 1 is returned.
*/
int
setcc(dflt,var) char *dflt; int *var; {
int x, y;
unsigned int c;
char *hlpmsg = "Control character,\n\
numeric ASCII value,\n\
or in ^X notation,\n\
or preceded by a backslash and entered literally";
/* This is a hack to turn off complaints from expression evaluator. */
x_ifnum = 1;
y = cmnum(hlpmsg, dflt, 10, &x, xxstring); /* Parse a number */
x_ifnum = 0; /* Allow complaints again */
if (y < 0) { /* Parse failed */
if (y != -2) /* Reparse needed or somesuch */
return(y); /* Pass failure back up the chain */
}
/* Real control character or literal 8-bit character... */
for (c = strlen(atmbuf) - 1; c > 0; c--) /* Trim */
if (atmbuf[c] == SP) atmbuf[c] = NUL;
if (y < 0) { /* It was not a number */
if (((c = atmbuf[0])) && !atmbuf[1]) { /* Literal character? */
c &= 0xff;
if (((c > 31) && (c < 127)) || (c > 255)) {
printf("\n?%d: Out of range - must be 0-31 or 127-255\n",c);
return(-9);
} else {
if ((y = cmcfm()) < 0) /* Confirm */
return(y);
*var = c; /* Set the variable */
return(1);
}
} else if (atmbuf[0] == '^' && !atmbuf[2]) { /* Or ^X notation? */
c = atmbuf[1];
if (islower((char) c)) /* Uppercase lowercase letters */
c = toupper(c);
if (c > 62 && c < 96) { /* Check range */
if ((y = cmcfm()) < 0)
return(y);
*var = ctl(c); /* OK */
return(1);
} else {
printf("?Not a control character - %s\n", atmbuf);
return(-9);
}
} else { /* Something illegal was typed */
printf("?Invalid - %s\n", atmbuf);
return(-9);
}
}
if (((x > 31) && (x < 127)) || (x > 255)) { /* They typed a number */
printf("\n?%d: Out of range - must be 0-31 or 127-255\n",x);
return(-9);
}
if ((y = cmcfm()) < 0) /* In range, confirm */
return(y);
*var = x; /* Set variable */
return(1);
}
#ifndef NOSPL /* The SORT command... */
static struct keytab srtswtab[] = { /* SORT command switches */
{ "/case", SRT_CAS, CM_ARG },
{ "/key", SRT_KEY, CM_ARG },
{ "/numeric", SRT_NUM, 0 },
{ "/range", SRT_RNG, CM_ARG },
{ "/reverse", SRT_REV, 0 }
};
static int nsrtswtab = sizeof(srtswtab)/sizeof(struct keytab);
extern char **a_ptr[]; /* Array pointers */
extern int a_dim[]; /* Array dimensions */
int
dosort() { /* Do the SORT command */
char c, *p = NULL, ** ap, ** xp = NULL;
struct FDB sw, fl, cm;
int hi, lo;
int xn = 0, xr = -1, xk = -1, xc = -1, xs = 0;
int getval = 0, range[2], confirmed = 0;
cmfdbi(&sw, /* First FDB - command switches */
_CMKEY, /* fcode */
"Array name or switch",
"", /* default */
"", /* addtl string data */
nsrtswtab, /* addtl numeric data 1: tbl size */
4, /* addtl numeric data 2: 4 = cmswi */
NULL, /* Processing function */
srtswtab, /* Keyword table */
&fl /* Pointer to next FDB */
);
cmfdbi(&fl, /* Anything that doesn't match */
_CMFLD, /* fcode */
"Array name", /* hlpmsg */
"", /* default */
"", /* addtl string data */
0, /* addtl numeric data 1 */
0, /* addtl numeric data 2 */
NULL,
NULL,
&cm
);
cmfdbi(&cm, /* Or premature confirmation */
_CMCFM, /* fcode */
"", /* hlpmsg */
"", /* default */
"", /* addtl string data */
0, /* addtl numeric data 1 */
0, /* addtl numeric data 2 */
NULL,
NULL,
NULL
);
range[0] = -1;
range[1] = -1;
while (1) { /* Parse 0 or more switches */
x = cmfdb(&sw);
if (x < 0)
return(x);
if (cmresult.fcode != _CMKEY) /* Break out if not a switch */
break;
c = cmgbrk();
getval = (c == ':' || c == '=');
if (getval && !(cmresult.kflags & CM_ARG)) {
printf("?This switch does not take arguments\n");
return(-9);
}
switch (cmresult.nresult) {
case SRT_REV:
xr = 1;
break;
case SRT_KEY:
if (getval) {
if ((y = cmnum("Column for comparison (1-based)",
"1",10,&x,xxstring)) < 0)
return(y);
xk = x - 1;
} else
xk = 0;
break;
case SRT_CAS:
if (getval) {
if ((y = cmkey(onoff,2,"","on",xxstring)) < 0)
return(y);
xc = y;
} else
xc = 1;
break;
case SRT_RNG: /* /RANGE */
if (getval) {
char buf[32];
char buf2[16];
int i;
char * p, * q;
if ((y = cmfld("low:high element","1",&s,NULL)) < 0)
return(y);
s = brstrip(s);
ckstrncpy(buf,s,32);
p = buf;
for (i = 0; *p && i < 2; i++) { /* Get low and high */
q = p; /* Start of this piece */
while (*p) { /* Find end of this piece */
if (*p == ':') {
*p = NUL;
p++;
break;
}
p++;
}
y = 15; /* Evaluate this piece */
s = buf2;
zzstring(q,&s,&y);
s = evalx(buf2);
if (s) if (*s) ckstrncpy(buf2,s,16);
if (!rdigits(buf2)) {
printf("?Not numeric: %s\n",buf2);
return(-9);
}
range[i] = atoi(buf2);
}
}
break;
case SRT_NUM: /* /NUMERIC */
xn = 1;
break;
default:
return(-2);
}
}
switch (cmresult.fcode) {
case _CMCFM:
confirmed = 1;
break;
case _CMFLD:
ckstrncpy(line,cmresult.sresult,LINBUFSIZ); /* Safe copy of name */
s = line;
break;
default:
printf("?Unexpected function code: %d\n",cmresult.fcode);
return(-9);
}
if (confirmed) {
printf("?Array name required\n");
return(-9);
}
ckmakmsg(tmpbuf,TMPBUFSIZ,
"Second array to sort according to ",s,NULL,NULL);
if ((x = cmfld(tmpbuf,"",&p,NULL)) < 0)
if (x != -3)
return(x);
tmpbuf[0] = NUL;
ckstrncpy(tmpbuf,p,TMPBUFSIZ);
p = tmpbuf;
if ((x = cmcfm()) < 0) /* Get confirmation */
return(x);
x = arraybounds(s,&lo,&hi); /* Get array index & bounds */
if (x < 0) { /* Check */
printf("?Bad array name: %s\n",s);
return(-9);
}
if (lo > -1) range[0] = lo; /* Set range */
if (hi > -1) range[1] = hi;
ap = a_ptr[x]; /* Get pointer to array element list */
if (!ap) { /* Check */
printf("?Array not declared: %s\n", s);
return(-9);
}
if (range[0] < 0) /* Starting element */
range[0] = 1;
if (range[1] < 0) /* Final element */
range[1] = a_dim[x];
if (range[1] > a_dim[x]) {
printf("?range %d:%d exceeds array dimension %d\n",
range[0],range[1],a_dim[x]
);
return(-9);
}
ap += range[0];
xs = range[1] - range[0] + 1; /* Number of elements to sort */
if (xs < 1) { /* Check */
printf("?Bad range: %d:%d\n",range[0],range[1]);
return(-9);
}
if (xk < 0) xk = 0; /* Key position */
if (xr < 0) xr = 0; /* Reverse flag */
if (xn) /* Numeric flag */