home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume8 / keydef_fv < prev    next >
Text File  |  1989-09-06  |  41KB  |  1,395 lines
  1. Newsgroups: comp.sources.misc
  2. subject: v08i029: keydef2 - quickly, easily redefine VT[23]xx function keys
  3. from: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  4. Reply-To: fulvio@oliveb.ATC.Olivetti.Com (Fulvio MARINO)
  5.  
  6. Posting-number: Volume 8, Issue 29
  7. Submitted-by: fulvio@oliveb.ATC.Olivetti.Com (Fulvio MARINO)
  8. Archive-name: keydef_fv
  9.  
  10. On 8 Aug 89 00:05:21 GMT, gordon@prls.UUCP (Gordon Vickers)
  11. submitted to "comp.sources.misc" (posting-number: Volume 7, Issue 55 -
  12. archive-name: keydef) via allbery@uunet.UU.NET (Brandon S. Allbery -
  13. comp.sources.misc) the Subject:
  14.    v07i055: keydef - quickly, easily redefine VT[23]xx function keys
  15.  
  16. This is my turn.
  17.  
  18. My keydef program makes the VT[23]xx (and compatibles) key definition
  19. in a different way than the Brandon's.  [Huh?  I just moderate.  ++bsa]
  20. I have NOT encountered the problems that he declared (half of the keys
  21. are not programmable, errors in downloading long definitions, etc.).
  22. This keydef can define the entire set of the user-defined keys; more,
  23. it can clean all the keys, and/or lock all them.
  24. Not X/OPEN (or SysV) users will need to edit one line in keydef.c to
  25. change the #include <string.h> to #include <strings.h>. I don't know
  26. if other changes are requested for the sites that are not X/OPEN.
  27.  
  28. My English is very bad, but I hope that you will read the manual page,
  29. at least to see all the features.
  30.  
  31.             Fulvio MARINO (fulvio@oliveb.ATC.Olivetti.Com)
  32.             Olivetti Ivrea, Italy- Sep 4 1989
  33.  
  34.  
  35. #! /bin/sh
  36. # This is a shell archive.  Remove anything before this line, then unpack
  37. # it by saving it into a file and typing "sh file".  To overwrite existing
  38. # files, type "sh file -c".  You can also feed this as standard input via
  39. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  40. # will see the following message at the end:
  41. #        "End of archive 1 (of 1)."
  42. # Contents:  MANIFEST NOREM README keydef.1u keydef.c keydef.man
  43. #   makefile sample
  44. # Wrapped by fulvio@xmrxos2 on Mon Sep  4 15:57:51 1989
  45. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  46. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  47.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  48. else
  49. echo shar: Extracting \"'MANIFEST'\" \(501 characters\)
  50. sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  51. X   File Name        Archive #    Description
  52. X-----------------------------------------------------------
  53. X README                     1    Guess!
  54. X MANIFEST                   1    This shipping list
  55. X NOREM                1    List of precious file (see makefile)
  56. X keydef.1u                  1    Manual page
  57. X keydef.c                   1    The keydef program
  58. X keydef.man                 1    nroff -Tlp -man keydef.1u
  59. X makefile                   1    Make all, install and kit
  60. X sample                     1    A $HOME/.keydef for C-programmers
  61. END_OF_FILE
  62. if test 501 -ne `wc -c <'MANIFEST'`; then
  63.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  64. fi
  65. # end of 'MANIFEST'
  66. fi
  67. if test -f 'NOREM' -a "${1}" != "-c" ; then 
  68.   echo shar: Will not clobber existing file \"'NOREM'\"
  69. else
  70. echo shar: Extracting \"'NOREM'\" \(68 characters\)
  71. sed "s/^X//" >'NOREM' <<'END_OF_FILE'
  72. XMANIFEST
  73. XNOREM
  74. XREADME
  75. Xkeydef.1u
  76. Xkeydef.c
  77. Xkeydef.man
  78. Xmakefile
  79. Xsample
  80. END_OF_FILE
  81. if test 68 -ne `wc -c <'NOREM'`; then
  82.     echo shar: \"'NOREM'\" unpacked with wrong size!
  83. fi
  84. # end of 'NOREM'
  85. fi
  86. if test -f 'README' -a "${1}" != "-c" ; then 
  87.   echo shar: Will not clobber existing file \"'README'\"
  88. else
  89. echo shar: Extracting \"'README'\" \(883 characters\)
  90. sed "s/^X//" >'README' <<'END_OF_FILE'
  91. X
  92. XOn 8 Aug 89 00:05:21 GMT, gordon@prls.UUCP (Gordon Vickers)
  93. Xsubmitted to "comp.sources.misc" (posting-number: Volume 7, Issue 55 -
  94. Xarchive-name: keydef) via allbery@uunet.UU.NET (Brandon S. Allbery -
  95. Xcomp.sources.misc) the Subject:
  96. X   v07i055: keydef - quickly, easily redefine VT[23]xx function keys
  97. X
  98. XThis is my turn.
  99. X
  100. XMy keydef program makes the VT[23]xx (and compatibles) key definition
  101. Xin a different way than the Brandon's.
  102. XI have NOT encountered the problems that he declared (half of the keys
  103. Xare not programmable, errors in downloading long definitions, etc.).
  104. XThis keydef can define the entire set of the user-defined keys; more,
  105. Xit can clean all the keys, and/or lock all them.
  106. X
  107. XMy English is very bad, but I hope that you will read the manual page,
  108. Xat least to see all the features.
  109. X
  110. X            Fulvio MARINO (fulvio@oliveb.ATC.Olivetti.Com)
  111. X            Olivetti Ivrea, Italy- Sep 4 1989
  112. END_OF_FILE
  113. if test 883 -ne `wc -c <'README'`; then
  114.     echo shar: \"'README'\" unpacked with wrong size!
  115. fi
  116. # end of 'README'
  117. fi
  118. if test -f 'keydef.1u' -a "${1}" != "-c" ; then 
  119.   echo shar: Will not clobber existing file \"'keydef.1u'\"
  120. else
  121. echo shar: Extracting \"'keydef.1u'\" \(5314 characters\)
  122. sed "s/^X//" >'keydef.1u' <<'END_OF_FILE'
  123. X.TH KEYDEF local
  124. X.SH NAME
  125. Xkeydef - quickly / easily redefines VT2xx and VT3xx function keys.
  126. X.SH SYNTAX
  127. Xkeydef { [-c] [-l] [keyname1 keyname2 ...] }
  128. X.br
  129. Xkeydef [-f filename [keyname1 keyname2 ...]]
  130. X.SH DESCRIPTION
  131. XThe first sintax specification for the \fIkeydef\fP command is
  132. Xinteractive; at least one flag or a keyname must be specified. For
  133. Xeach \fIkeyname\fP, \fIkeydef\fP asks for its definition. The \fB-c\fP
  134. Xand \fB-l\fP flags have the same meaning, respectively, of
  135. Xthe \fIclear\fP and \fIlock\fP commands used in non-interactive mode
  136. X(see below). Definition follows the same sintax used not interactively.
  137. X.PP
  138. XUsing the 2nd form, \fIkeydef\fP reads its instructions
  139. Xfrom \fIfilename\fP; if \fIfilename\fP is "\fB-\fP", commands are taken
  140. Xfrom standard input, else if it is missing ("\fIkeydef\fP" with no
  141. Xarguments specified), then \fI$HOME/.keydef\fP is read.
  142. X.PP
  143. XCommands in \fIfilename\fP are specified in a shell-like sintax.
  144. XA command is a sequence of non-blank words separated by blanks (a blank
  145. Xis a tab or a space). The first word specifies the name of the command
  146. Xto be executed. Possible commands are \fIclear\fP (to clear all the
  147. Xdefinitions previously set), \fIlock\fP (to lock definitions: i.e.,
  148. Xall the User Defined Keys will be locked after the execution
  149. Xof \fIkeydef\fP -- keys unlock is possible only via Set-Up),
  150. Xor \fIkeyname\fP (to set a definition for \fIkeyname\fP function-key);
  151. X\fIkeyname\fP must be a valid name of a function key, and a
  152. X\fIdefinition\fP follows it.
  153. X.PP
  154. XA word beginning with \fB#\fP causes that word and all the following
  155. Xcharacters up to a new line to be ignored. Explicit null arguments
  156. X(\fB""\fP or \fB''\fP) are retained. A character may be quoted (i.e.,
  157. Xmade to stand for itself) by preceding it with a \fB\\\fP. The
  158. Xpair \fB\\newline\fP is ignored. All characters enclosed between a pair
  159. Xof quote marks (\fB''\fP or \fB""\fP), except the mark itself, are
  160. Xquoted; inside them, \fB\\\fP has no quoting properties.
  161. X.PP
  162. XValid \fIkeynames\fP are \fBF6\fP to \fBF20\f, and \fBS6\fP to \fBS20\fP
  163. X(referenced pressing both the \fBShift\fP and the function key). Some
  164. Xkeys are also referenced by the associated name (ESC, BS, LF, Help, Do).
  165. XType "\fIkeydef -\fP" to print the list of all the possible keynames.
  166. X.PP
  167. XThe (mandatory) argument of a \fIkeyname\fP command is the
  168. X\fIdefinition\fP for that key; inside it, \fB\\\fP and \fB^\fP have a
  169. Xspecial meaning. Certain characters may be represented according to the
  170. Xfollowing table:
  171. X.nf
  172. X
  173. X        CHARACTER       ASCII SYMBOL    ESCAPE SEQUENCE
  174. X
  175. X        newline(NL)          LF              \\n
  176. X        horizontal-tab       HT              \\t
  177. X        vertical-tab         VT              \\v
  178. X        backspace            BS              \\b
  179. X        carriage-return      CR              \\r
  180. X        formfeed             FF              \\f
  181. X        escape               ESC             \\e
  182. X        backslah             \\              \\\\
  183. X        single-quote         '               \\' or \\Q
  184. X        double-quote         "               \\D
  185. X        bit-pattern          ddd             \\ddd
  186. X
  187. X.fi
  188. XThe escape \fB\\ddd\fP consists of the backslash followed by 1, 2, or 3
  189. Xoctal digits, which are taken to specify the value of the desired
  190. Xcharacter. If the character following a backslash is not one of those
  191. Xspecified, the backslash is ignored. \fB^x\fP maps to a control-x for
  192. Xany appropriate x. To program a literal circumflex, preceed it with a
  193. Xbackslash.
  194. X.PP
  195. XA function key is executed by pressing one of the function keys
  196. X(\fBF*\fP), or by pressing SHIFT + function key (\fBS*\fP).
  197. X.SH WARNINGS
  198. XThere is a finite amount of memory in the terminal for storing the
  199. Xdefinitions. The exceeding characters are discharged.
  200. X.PP
  201. XTerminal is getting confused when any character is asynchronously
  202. Xreceived/typed during the execution of \fIkeydef\fP.
  203. X.PP
  204. XDepending on the terminal type and/or setting, not all the keys
  205. Xcan be programmed; typically, F11 (ESC), F12 (BS) and F13 (LF)
  206. Xcan be protected from the user's redefinition.
  207. X.PP
  208. XThis program has been developed and tested on an \fIOlivetti WS 685\fP
  209. Xdesktop video display terminal emulating DEC terminals VT220, VT100 and
  210. XVT52, connected via RS232 to an \fIOlivetti LSX-3010\fP with the \fIL2
  211. XX/OS R2.0\fP Unix System. You should not have porting problems on any
  212. XX/OPEN system.
  213. X.PP
  214. X.SH "SEE ALSO"
  215. XVT220 or VT320 Programmer Pocket Guide, and/or WS 685 User Guide.
  216. X.SH AUTHOR
  217. XFulvio MARINO, Olivetti, Ivrea, Italy (fulvio@oliveb.ATC.Olivetti.Com)
  218. X.PP
  219. XComments, suggestions, and patches welcomed.
  220. X.SH COPYRIGHT
  221. XCopyright (c) 1989 Olivetti S.p.A. Ivrea, Italy.
  222. X.br
  223. XAll rights reserved.
  224. X.PP
  225. XRedistribution and use in source and binary forms are permitted
  226. Xprovided that the above copyright notice and this paragraph are
  227. Xduplicated in all such forms and that any documentation,
  228. Xadvertising materials, and other materials related to such
  229. Xdistribution and use acknowledge that the software was developed
  230. Xby the Olivetti S.p.A., Italy.  The name of Olivetti S.p.A. may
  231. Xnot be used to endorse or promote products derived from this
  232. Xsoftware without specific prior written permission.
  233. X.br
  234. XTHIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  235. XIMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  236. XWARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  237. END_OF_FILE
  238. if test 5314 -ne `wc -c <'keydef.1u'`; then
  239.     echo shar: \"'keydef.1u'\" unpacked with wrong size!
  240. fi
  241. # end of 'keydef.1u'
  242. fi
  243. if test -f 'keydef.c' -a "${1}" != "-c" ; then 
  244.   echo shar: Will not clobber existing file \"'keydef.c'\"
  245. else
  246. echo shar: Extracting \"'keydef.c'\" \(13595 characters\)
  247. sed "s/^X//" >'keydef.c' <<'END_OF_FILE'
  248. X/*
  249. X * Copyright (c) 1989 Olivetti S.p.A. Ivrea, Italy.
  250. X * All rights reserved.
  251. X *
  252. X * Redistribution and use in source and binary forms are permitted
  253. X * provided that the above copyright notice and this paragraph are
  254. X * duplicated in all such forms and that any documentation,
  255. X * advertising materials, and other materials related to such
  256. X * distribution and use acknowledge that the software was developed
  257. X * by the Olivetti S.p.A. Ivrea, Italy.  The name of Olivetti may
  258. X * not be used to endorse or promote products derived from this
  259. X * software without specific prior written permission.
  260. X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  261. X * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  262. X * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  263. X */
  264. X
  265. X/*
  266. X * keydef() - easily / quickly redefine vt200, vt300 function keys
  267. X *
  268. X *        (Fulvio MARINO - Sep 4, 1989)
  269. X */
  270. X
  271. X
  272. X#if defined(lint) && defined(m68k)
  273. Xchar *strdup(a,b) char *a, *b; { return (a?a:b); }
  274. X#endif lint
  275. X
  276. X
  277. X#include <stdio.h>
  278. X#include <string.h>
  279. X#include <sys/types.h>
  280. X#include <sys/param.h>
  281. X
  282. X
  283. Xextern void    perror();
  284. Xextern char    *getenv(), *malloc(), *realloc();
  285. X
  286. X
  287. X#define Fprintf    (void)fprintf
  288. X
  289. X#define    ctrl(ch)    ((ch) & 037)
  290. X
  291. X#define ESC    ctrl('[')
  292. X#define BSe    ESC
  293. X#define BSn    '\n'
  294. X#define BSt    '\t'
  295. X#define BSv    '\v'
  296. X#define BSb    '\b'
  297. X#define BSr    '\r'
  298. X#define BSf    '\f'
  299. X#define BSbs    '\\'
  300. X#define BSq    '\''
  301. X#define BSdq    '"'
  302. X
  303. X
  304. X/*
  305. X * Error codes and messages
  306. X */
  307. X
  308. Xstatic int    Err_No = 0;
  309. X
  310. Xstatic char    *ErrTable[] = {
  311. X    "",
  312. X#define E_INT        1
  313. X    "Internal error",
  314. X#define E_INV_KN    2
  315. X    "Invalid key name",
  316. X#define E_INV_SN    3
  317. X    "Invalid string definition",
  318. X#define E_SINTAXERR    4
  319. X    "Sintax error",
  320. X#define E_INVCMD    5
  321. X    "Invalid command",
  322. X#define E_INVARG    6
  323. X    "Invalid argument",
  324. X#define E_KEXP        7
  325. X    "Key value expected",
  326. X#define E_TOO        8
  327. X    "Too many args for command",
  328. X#define E_NOSPC        9
  329. X    "Not enough space",
  330. X#define E_INV_CH    10
  331. X    "Value do not fit in a character"
  332. X};
  333. X
  334. X
  335. X/*
  336. X * Pclr values:
  337. X *    '1'    Clear only the key(s) being programmed
  338. X *    not '1'    Clear all keys before programming
  339. X */
  340. X
  341. X#define K_NOCLR        '1'
  342. X#define K_CLRALL    '0'
  343. X
  344. Xstatic u_char    Pclr = K_NOCLR;
  345. X
  346. X
  347. X/*
  348. X * Plk denotes whether or not to lock keys against redefinition:
  349. X *    '1'    Do not lock
  350. X *    '0'    Lock
  351. X */
  352. X
  353. X#define K_NOLCK        '1'
  354. X#define K_LCK        '0'
  355. X
  356. Xstatic u_char    Plk = K_NOLCK;
  357. X
  358. X
  359. X/*
  360. X * Kn: denotes the function key to be programmed; next table is mapping
  361. X * each key name on its function number.
  362. X */
  363. X
  364. Xtypedef struct {
  365. X        char    *Key;    /* Key name */
  366. X        u_char    Fn;    /* Function number */
  367. X} t_table;
  368. X
  369. Xstatic t_table    Table[] = {
  370. X    { "F6",   1 }, { "F7",   2 }, { "F8",   3 },
  371. X    { "F9",   4 }, { "F10",  5 }, { "F11",  6 },
  372. X    { "F12",  7 }, { "F13",  8 }, { "F14",  9 },
  373. X    { "F15", 10 }, { "F16", 11 }, { "F17", 12 },
  374. X    { "F18", 13 }, { "F19", 14 }, { "F20", 15 },
  375. X    { "S6",  17 }, { "S7",  18 }, { "S8",  19 },
  376. X    { "S9",  20 }, { "S10", 21 }, { "S11", 23 },
  377. X    { "S12", 24 }, { "S13", 25 }, { "S14", 26 },
  378. X    { "S15", 28 }, { "S16", 29 }, { "S17", 31 },
  379. X    { "S18", 32 }, { "S19", 33 }, { "S20", 34 },
  380. X    /* Next items to allow multiple names for some key */
  381. X    { "F-ESC", 6 }, { "F-BS", 7 }, { "F-LF", 8 },
  382. X    { "F-Help", 10 }, { "F-Do", 11 },
  383. X    { "S-ESC", 23 }, { "S-BS", 24 }, { "S-LF", 25 },
  384. X    { "S-Help", 28 }, { "S-Do", 29 }
  385. X};
  386. X
  387. X#define Tsize    (sizeof(Table) / sizeof(Table[0]))
  388. X
  389. Xstatic u_char    Kt[Tsize];
  390. X
  391. X
  392. X/*
  393. X * GetKn(Fn)
  394. X *    returns the function number of a given key name Fn;
  395. X *    on error, 0 is returned and Err_No is set.
  396. X */
  397. X
  398. Xstatic u_char
  399. XGetKn(Fn)
  400. Xchar    *Fn;
  401. X{
  402. X    int    i = 0;
  403. X
  404. X    if (Fn) {
  405. X        do {
  406. X            if (! strcmp(Fn, Table[i].Key))
  407. X                return(Table[i].Fn);
  408. X        } while (++i < Tsize);
  409. X    }
  410. X
  411. X    Err_No = E_INV_KN;
  412. X    return((u_char)0);
  413. X}
  414. X
  415. X
  416. Xstatic char    *Tokbuf = NULL;
  417. Xstatic unsigned    Toksize = 0;
  418. X
  419. Xstatic u_char    *UDKbuf = (u_char)NULL;
  420. Xstatic unsigned    UDKsize = 0;
  421. X
  422. X
  423. X/*
  424. X * Prepare_DECUDK(kinfo)
  425. X *    prepares in UDKbuf the DECUDK sequence, the format of which is
  426. X *        DCS Pclr ; Plk | K1 / S1 ; K2 / S2 ; ... ; Kn / Sn ST
  427. X *    (kinfo)(&Kn, &Str) is called to get the function number (in Kn)
  428. X *    and the programming string (in Str); (kinfo) returns 0 on end,
  429. X *    -1 (+ Err_No set) on error, or a positive value if ok.
  430. X *    Backslashes in UDKbuf are interpreted as the Green Hills
  431. X *    C-compiler does.
  432. X *    The number of character(s) in UDKbuf is returned on success,
  433. X *    else -1.
  434. X */
  435. X
  436. Xstatic int
  437. XPrepare_DECUDK(kinfo)
  438. Xint    (*kinfo)();
  439. X{
  440. X    int        n, t;
  441. X    u_char        Kn;
  442. X    u_char        *Str, c;
  443. X    u_int        d;
  444. X
  445. X    if (! UDKsize
  446. X       && (UDKbuf = (u_char *)malloc(UDKsize = BUFSIZ)) == NULL) {
  447. X        Err_No = E_NOSPC;
  448. X        return -1;
  449. X    }
  450. X    UDKbuf[0] = ESC,  UDKbuf[1] = 'P';    /* DCS */
  451. X    UDKbuf[3] = ';';            /* Pclr ender */
  452. X    UDKbuf[5] = '|';            /* Plk ender */
  453. X    n = 6;                    /* Start of Kn/Sn seq */
  454. X
  455. X    while ((t = (kinfo)(&Kn, &Str)) > 0) {
  456. X        if (!Kn)
  457. X            continue;
  458. X        /* Verify if Kn is in the selected key set */
  459. X        for (d = 0; d < Tsize; d++)
  460. X            if (Kn == Kt[d])
  461. X                break;
  462. X        if (d >= Tsize)
  463. X            continue;
  464. X
  465. X        if (! Str) {
  466. X            Err_No = E_INT;
  467. X            return (-1);
  468. X        }
  469. X
  470. X        /* Kn */
  471. X        if (Kn > 9)
  472. X            UDKbuf[n++] = (Kn / 10) + '0';
  473. X        UDKbuf[n++] = (Kn % 10) + '0';
  474. X        UDKbuf[n++] = '/';
  475. X
  476. X        /* Sn */
  477. X        t = 0;
  478. X        while (c = *Str++) {
  479. X            if (n > (UDKsize - 10) && (UDKbuf =
  480. X               (u_char *)realloc((char *)UDKbuf,
  481. X               UDKsize += BUFSIZ)) == NULL) {
  482. X                Err_No = E_NOSPC;
  483. X                return -1;
  484. X            }
  485. X            if (c == '^') {
  486. X                if (! (c = *Str++)) {
  487. X                    Err_No = E_INV_SN;
  488. X                    return (-1);
  489. X                }
  490. X                c = ctrl(c);
  491. X            } else if (c == '\\') {
  492. X                if (! (c = *Str++)) {
  493. X                    Err_No = E_INV_SN;
  494. X                    return (-1);
  495. X                }
  496. X                switch (c) {
  497. X                case '\'':
  498. X                case 'Q':    c = BSq; break;
  499. X                case '\\':    c = BSbs; break;
  500. X                case 'D':    c = BSdq; break;
  501. X                case 'b':    c = BSb; break;
  502. X                case 'e':    c = BSe; break;
  503. X                case 'f':    c = BSf; break;
  504. X                case 'n':    c = BSn; break;
  505. X                case 'r':    c = BSr; break;
  506. X                case 't':    c = BSt; break;
  507. X                case 'v':    c = BSv; break;
  508. X                default:
  509. X/*----------------------------- FOLDING ------------------------------*/
  510. X    if (c < '0' || c > '7')
  511. X        break;
  512. X    d = 0;
  513. X    for (t = 0; t++ < 3; ) {
  514. X        if ((d = 8 * d + (u_int)c - '0') > (u_int)((u_char)~0)) {
  515. X            Err_No = E_INV_CH;
  516. X            return -1;
  517. X        }
  518. X        c = *Str++;
  519. X        if (c < '0' || c > '7')
  520. X            break;
  521. X    }
  522. X    Str--;
  523. X    c = (u_char)d;
  524. X/*---------------------------- UNFOLDING -----------------------------*/
  525. X                }
  526. X            }
  527. X            UDKbuf[n] = c / 16;
  528. X            UDKbuf[n] += UDKbuf[n] > 9 ? 'a' - 10 : '0';
  529. X            UDKbuf[++n] = c % 16;
  530. X            UDKbuf[n] += UDKbuf[n] > 9 ? 'a' - 10 : '0';
  531. X            n++;
  532. X        }
  533. X        UDKbuf[n++] = ';';
  534. X    }
  535. X
  536. X    if (t < 0) {
  537. X        return (-1);
  538. X    }
  539. X
  540. X    UDKbuf[2] = Pclr;            /* Pclr value */
  541. X    UDKbuf[4] = Plk;            /* Plk value */
  542. X    UDKbuf[n] = ESC, UDKbuf[++n] = '\\';    /* ST */
  543. X
  544. X    return(n + 1);
  545. X}
  546. X
  547. X
  548. X/*
  549. X * Line Parsing
  550. X */
  551. X
  552. Xstatic int    lineno = 0;
  553. Xstatic FILE    *input = (FILE *)NULL;
  554. X
  555. X/*
  556. X * Get_Char()
  557. X *    gets a character from `input' (must be set correctly!);
  558. X *    the global lineno keeps trace of input.
  559. X */
  560. X
  561. Xstatic int
  562. XGet_Char()
  563. X{
  564. X    static int    c = 0;
  565. X
  566. X    switch (c = c == EOF ? EOF : getc(input)) {
  567. X    case '\n':    lineno++; break;
  568. X    case EOF:    return(-1);
  569. X    }
  570. X    return(c);
  571. X    
  572. X}
  573. X
  574. X#define G_EOF        -1
  575. X#define G_NULLTOK    -2
  576. X#define G_SINTAXERR    -3
  577. X
  578. X/*
  579. X * Get_Token(o)
  580. X *    scans input for next token (command, argument, ...), and writes
  581. X *    it in Tokbuf, starting at offset o; input sintax is like in
  582. X #    /bin/sh (it uses ", ', #, backslashes, and multi-line);
  583. X *    it returns the characters written in buf (>0),
  584. X *    or 0        if no token found in line
  585. X *    or G_EOF    on end-of-file detection
  586. X *    or G_NULLTOK    if there is a null token ('' or "")
  587. X *    or G_SINTAXERR    on a sintax error (in this case the global
  588. X *            Err_No is set)
  589. X */
  590. X
  591. Xstatic int
  592. XGet_Token(o)
  593. Xint    o;
  594. X{
  595. X    static int    oc = 0;
  596. X    int    c, got = 0, inside = 0, n = o, takenext = 0;
  597. X
  598. X    if (oc == '\n')
  599. X        return (oc = 0);
  600. X
  601. X    for ( ; ; ) {
  602. X        if (n >= Toksize &&
  603. X           (Tokbuf = Toksize
  604. X            ? realloc(Tokbuf, Toksize += BUFSIZ)
  605. X            : malloc(Toksize = BUFSIZ)
  606. X           ) == NULL) {
  607. X            Err_No = E_NOSPC;
  608. X            return G_SINTAXERR;
  609. X        }
  610. X        c = Get_Char();
  611. X        if (takenext) {
  612. X            if (c == -1) {
  613. X                Err_No = E_SINTAXERR;
  614. X                return(G_SINTAXERR);
  615. X            }
  616. X            if (c != '\n')
  617. X                Tokbuf[n++] = (u_char)c;
  618. X            takenext = 0;
  619. X            continue;
  620. X        }
  621. X        if (c == '\\' && ! inside) {
  622. X            takenext = 1;
  623. X            continue;
  624. X        }
  625. X        if (c == '"' || c == '\'') {
  626. X            if (c == inside) {
  627. X                got = G_NULLTOK;
  628. X                inside = 0;
  629. X                continue;
  630. X            } else if (!inside) {
  631. X                inside = c;
  632. X                continue;
  633. X            }
  634. X        }
  635. X        if (inside) {
  636. X            Tokbuf[n++] = (u_char)c;
  637. X            continue;
  638. X        }
  639. X        if (c == '#')
  640. X            while (c = Get_Char())
  641. X                if (c == '\n')
  642. X                    break;
  643. X        if ((c == ' ' || c == '\t') && ((n - o) || got)
  644. X            || c == '\n' || c == -1) {
  645. X            Tokbuf[n] = '\0';
  646. X            n -= o;
  647. X            oc = c;
  648. X            return (n ? n : (got ? got : (c == -1 ? G_EOF : 0)));
  649. X        }
  650. X        if (c != ' ' && c != '\t')
  651. X            Tokbuf[n++] = (u_char)c;
  652. X    }
  653. X
  654. X    /* NOTREACHED */
  655. X
  656. X}
  657. X
  658. X
  659. Xstatic int
  660. XFromFile(Key, Str)
  661. Xu_char    *Key;
  662. Xchar    **Str;
  663. X{
  664. X    int    n;
  665. X
  666. X    for ( ; ; ) {
  667. X        switch (n = Get_Token(0)) {
  668. X        case 0:            continue;    /* next line */
  669. X        case G_EOF:        return 0;    /* data end */
  670. X        case G_SINTAXERR:    return -1;    /* error */
  671. X        case G_NULLTOK:        break;        /* null token */
  672. X        default:        if (n < 0) {
  673. X                        /* internal error */
  674. X                        Err_No = E_INT;
  675. X                        return -1;
  676. X                    }
  677. X        }
  678. X        break;
  679. X    }
  680. X
  681. X    n = -1;
  682. X
  683. X    /*
  684. X     * Validate object token
  685. X     */
  686. X    *Key = 0;
  687. X    if (!strcmp(Tokbuf, "clear"))
  688. X        Pclr = K_CLRALL, Tokbuf[0] = '\0';
  689. X    else if (!strcmp(Tokbuf, "lock"))
  690. X        Plk = K_LCK, Tokbuf[0] = '\0';
  691. X    else if ((*Key = GetKn(Tokbuf)) == 0) {
  692. X        Err_No = E_INV_KN;
  693. X        return -1;
  694. X    } else {
  695. X        /*
  696. X         * Get key arg
  697. X         */
  698. X        switch (n = Get_Token(0)) {
  699. X        case G_EOF:
  700. X        case 0:            Err_No = E_KEXP;    /* set how ? */
  701. X        case G_SINTAXERR:
  702. X                    return -1;
  703. X        case G_NULLTOK:        n = 0;
  704. X                    Tokbuf[0] = '\0';
  705. X                    break;        /* null token */
  706. X        default:        if (n < 0) {
  707. X                        /* internal error */
  708. X                        Err_No = E_INT;
  709. X                        return -1;
  710. X                    }
  711. X        }
  712. X    }
  713. X
  714. X    /*
  715. X     * No more arguments expected
  716. X     */
  717. X    switch (n = Get_Token(n+1)) {
  718. X    case G_EOF:
  719. X    case 0:            break;        /* eof/eol are right */
  720. X    case G_SINTAXERR:    return -1;    /* error */
  721. X    case G_NULLTOK:        n = 0;        /* null token */
  722. X    default:        if (n < 0) {
  723. X                    /* internal error */
  724. X                    Err_No = E_INT;
  725. X                } else
  726. X                    Err_No = E_TOO;
  727. X                return -1;
  728. X    }
  729. X
  730. X    *Str = Tokbuf;
  731. X
  732. X    return 1;
  733. X}
  734. X
  735. X
  736. Xstatic int
  737. XFromTty(Key, Str)
  738. Xu_char    *Key;
  739. Xchar    **Str;
  740. X{
  741. X    static int    ind = 0;
  742. X    int    i, k;
  743. X
  744. X    if ((*Key = k = Kt[ind++]) == 0)
  745. X        return 0;
  746. X
  747. X    for (i = 0; k != Table[i].Fn; i++)
  748. X        ;
  749. X    Fprintf(stderr, "Key \"%s\"", Table[i].Key);
  750. X    while(++i < Tsize) {
  751. X        if (k == Table[i].Fn) {
  752. X            Fprintf(stderr, "==\"%s\"", Table[i].Key);
  753. X        }
  754. X    }
  755. X    Fprintf(stderr, ": ");
  756. X    (void)fflush(stderr);
  757. X
  758. X    /*
  759. X     * Get key arg
  760. X     */
  761. X    switch (i = Get_Token(0)) {
  762. X    case G_EOF:
  763. X    case 0:            Err_No = E_KEXP;    /* set how ? */
  764. X    case G_SINTAXERR:
  765. X                return -1;
  766. X    case G_NULLTOK:        i = 0;
  767. X                Tokbuf[0] = '\0';
  768. X                break;        /* null token */
  769. X    default:        if (i < 0) {
  770. X                    /* internal error */
  771. X                    Err_No = E_INT;
  772. X                    return -1;
  773. X                }
  774. X    }
  775. X
  776. X    /*
  777. X     * No more arguments expected
  778. X     */
  779. X    switch (i = Get_Token(i+1)) {
  780. X    case G_EOF:
  781. X    case 0:            break;        /* eof/eol are right */
  782. X    case G_SINTAXERR:    return -1;    /* error */
  783. X    case G_NULLTOK:        i = 0;        /* null token */
  784. X    default:        if (i < 0) {
  785. X                    /* internal error */
  786. X                    Err_No = E_INT;
  787. X                } else
  788. X                    Err_No = E_TOO;
  789. X                return -1;
  790. X    }
  791. X
  792. X    *Str = Tokbuf;
  793. X
  794. X    return 1;
  795. X}
  796. X
  797. X
  798. Xstatic void
  799. Xusage()
  800. X{
  801. X    Fprintf(stderr, "\
  802. XUsage: keydef [-f {filename|-}] [--] [keyname ...]\n\
  803. X       keydef [-c] [-l] keyname ...\n\
  804. X       keydef -{c|l} [keyname ...]\n");
  805. X
  806. X}
  807. X
  808. X
  809. X/*
  810. X *    MAIN
  811. X */
  812. X
  813. X#define KEYRC "/.keydef"
  814. X
  815. Xmain(argc, argv)
  816. Xint    argc;
  817. Xchar    **argv;
  818. X{
  819. X    extern int    getopt(), optind, opterr;
  820. X    extern char    *optarg;
  821. X    int        c, errflg, fflg, cflg, lflg;
  822. X    char        *ifile, *p;
  823. X    u_char        Kn;
  824. X    int        (*kinfo)();
  825. X
  826. X    opterr = 0;
  827. X    errflg = fflg = cflg = lflg = 0;
  828. X
  829. X    if (argc > 1) {
  830. X
  831. X        while ((c = getopt(argc, argv, "f:cl")) != EOF)
  832. X            switch(c) {
  833. X            case 'f':
  834. X                if ( fflg++ || cflg || lflg || ! optarg)
  835. X                    errflg = 1;
  836. X                else
  837. X                    ifile = optarg;
  838. X                break;
  839. X            case 'c':
  840. X                if (cflg++ || fflg)
  841. X                    errflg = 1;
  842. X                else
  843. X                    Pclr = K_CLRALL;
  844. X                break;
  845. X            case 'l':
  846. X                if (lflg++ || fflg)
  847. X                    errflg = 1;
  848. X                else
  849. X                    Plk = K_LCK;
  850. X                break;
  851. X            case '?':
  852. X                errflg = 1;
  853. X                break;
  854. X            }
  855. X    
  856. X    
  857. X        if (errflg) {
  858. X            usage();
  859. X            return 1;
  860. X        }
  861. X    
  862. X    } else {
  863. X
  864. X        if ((p = getenv("HOME")) == NULL) {
  865. X            Fprintf(stderr, "\"$HOME\" not found.\n");
  866. X            return 1;
  867. X        }
  868. X        if ((ifile = malloc((unsigned)(strlen(p)
  869. X            + sizeof(KEYRC)))) == NULL) {
  870. X            Fprintf(stderr, "malloc error.\n");
  871. X            return 1;
  872. X        }
  873. X        (void)strcpy(ifile, p);
  874. X        (void)strcat(ifile, KEYRC);
  875. X
  876. X        fflg = optind = 1;
  877. X
  878. X    }
  879. X
  880. X    for (c = 0; optind < argc; ) {
  881. X        p = argv[optind++];
  882. X        if ((Kn = GetKn(p)) == 0) {
  883. X            Fprintf(stderr, "\"%s\": bad key name.\n", p);
  884. X            Fprintf(stderr, "Available key names are:\n\t", p);
  885. X            c = 0;
  886. X            for ( ; ; ) {
  887. X                Fprintf(stderr, "%s ", Table[c++].Key);
  888. X                if (c == Tsize) {
  889. X                    (void)putc('\n', stderr);
  890. X                    break;
  891. X                }
  892. X                if (!(c % 5))
  893. X                    (void)putc('\n', stderr);
  894. X                (void)putc('\t', stderr);
  895. X            }
  896. X            return 1;
  897. X        }
  898. X        errflg = c; /* using errflg as temp */
  899. X        while(errflg-- > 0)
  900. X            if (Kt[errflg] == Kn)
  901. X                break;
  902. X        if (errflg < 0)    /* Not already selected */
  903. X            Kt[c++] = Kn;
  904. X    }
  905. X    if (! (Kn = c) && fflg) /* If no key args, select all keys */
  906. X        for (c = 0; c < Tsize; c++)
  907. X            Kt[c] = Table[c].Fn;
  908. X
  909. X    if (fflg) {
  910. X        if (strcmp(ifile, "-")
  911. X            && (input = freopen (ifile, "r", stdin)) == NULL) {
  912. X            perror(ifile);
  913. X            return(1);
  914. X        } else
  915. X            input = stdin;
  916. X        kinfo = FromFile;
  917. X    } else {
  918. X        input = stdin;
  919. X        kinfo = FromTty;
  920. X    }
  921. X
  922. X    if ((c = Prepare_DECUDK(kinfo)) > 0
  923. X        && write(fileno(stdout), (char *)UDKbuf, (unsigned)c) != c) {
  924. X        perror("output error");
  925. X        return 1;
  926. X    } else if (c < 0) {
  927. X        (void)Fprintf(stderr, "line %d: %s.\n", lineno, ErrTable[Err_No]);
  928. X        return 1;
  929. X    }
  930. X
  931. X#if defined(lint) && defined(m68k)
  932. X    return((int)strdup(NULL,NULL));
  933. X#else
  934. X    return 0;
  935. X#endif lint
  936. X}
  937. END_OF_FILE
  938. if test 13595 -ne `wc -c <'keydef.c'`; then
  939.     echo shar: \"'keydef.c'\" unpacked with wrong size!
  940. fi
  941. # end of 'keydef.c'
  942. fi
  943. if test -f 'keydef.man' -a "${1}" != "-c" ; then 
  944.   echo shar: Will not clobber existing file \"'keydef.man'\"
  945. else
  946. echo shar: Extracting \"'keydef.man'\" \(8947 characters\)
  947. sed "s/^X//" >'keydef.man' <<'END_OF_FILE'
  948. X
  949. X
  950. X
  951. X     KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))               UUUUNNNNIIIIXXXX 5555....0000                KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))
  952. X
  953. X
  954. X
  955. X     NNNNAAAAMMMMEEEE
  956. X          keydef - quickly / easily redefines VT2xx and VT3xx function
  957. X          keys.
  958. X
  959. X     SSSSYYYYNNNNTTTTAAAAXXXX
  960. X          keydef { [-c] [-l] [keyname1 keyname2 ...] }
  961. X          keydef [-f filename [keyname1 keyname2 ...]]
  962. X
  963. X     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  964. X          The first sintax specification for the _k_e_y_d_e_f command is
  965. X          interactive; at least one flag or a keyname must be
  966. X          specified. For each _k_e_y_n_a_m_e, _k_e_y_d_e_f asks for its definition.
  967. X          The ----cccc and ----llll flags have the same meaning, respectively, of
  968. X          the _c_l_e_a_r and _l_o_c_k commands used in non-interactive mode
  969. X          (see below). Definition follows the same sintax used not
  970. X          interactively.
  971. X
  972. X          Using the 2nd form, _k_e_y_d_e_f reads its instructions from
  973. X          _f_i_l_e_n_a_m_e; if _f_i_l_e_n_a_m_e is "----", commands are taken from
  974. X          standard input, else if it is missing ("_k_e_y_d_e_f" with no
  975. X          arguments specified), then $_H_O_M_E/._k_e_y_d_e_f is read.
  976. X
  977. X          Commands in _f_i_l_e_n_a_m_e are specified in a shell-like sintax.
  978. X          A command is a sequence of non-blank words separated by
  979. X          blanks (a blank is a tab or a space). The first word
  980. X          specifies the name of the command to be executed. Possible
  981. X          commands are _c_l_e_a_r (to clear all the definitions previously
  982. X          set), _l_o_c_k (to lock definitions: i.e., all the User Defined
  983. X          Keys will be locked after the execution of _k_e_y_d_e_f -- keys
  984. X          unlock is possible only via Set-Up), or _k_e_y_n_a_m_e (to set a
  985. X          definition for _k_e_y_n_a_m_e function-key); _k_e_y_n_a_m_e must be a
  986. X          valid name of a function key, and a _d_e_f_i_n_i_t_i_o_n follows it.
  987. X
  988. X          A word beginning with #### causes that word and all the
  989. X          following characters up to a new line to be ignored.
  990. X          Explicit null arguments ("""""""" or '''''''') are retained. A character
  991. X          may be quoted (i.e., made to stand for itself) by preceding
  992. X          it with a \\\\. The pair \\\\nnnneeeewwwwlllliiiinnnneeee is ignored. All characters
  993. X          enclosed between a pair of quote marks ('''''''' or """"""""), except
  994. X          the mark itself, are quoted; inside them, \\\\ has no quoting
  995. X          properties.
  996. X
  997. X          Valid _k_e_y_n_a_m_e_s are FFFF6666 to FFFF22220000 aaaannnndddd SSSS6666 ttttoooo SSSS22220000 ((((rrrreeeeffffeeeerrrreeeennnncccceeeedddd
  998. X          pppprrrreeeessssssssiiiinnnngggg bbbbooootttthhhh tttthhhheeee SSSShhhhiiiifffftttt aaaannnndddd tttthhhheeee ffffuuuunnnnccccttttiiiioooonnnn kkkkeeeeyyyy)))).... SSSSoooommmmeeee kkkkeeeeyyyyssss aaaarrrreeee
  999. X          aaaallllssssoooo rrrreeeeffffeeeerrrreeeennnncccceeeedddd bbbbyyyy tttthhhheeee aaaassssssssoooocccciiiiaaaatttteeeedddd nnnnaaaammmmeeee ((((EEEESSSSCCCC,,,, BBBBSSSS,,,, LLLLFFFF,,,, HHHHeeeellllpppp,,,,
  1000. X          DDDDoooo))))....  TTTTyyyyppppeeee """"_k_e_y_d_e_f -"""" ttttoooo pppprrrriiiinnnntttt tttthhhheeee lllliiiisssstttt ooooffff aaaallllllll tttthhhheeee ppppoooossssssssiiiibbbblllleeee
  1001. X          kkkkeeeeyyyynnnnaaaammmmeeeessss....
  1002. X
  1003. X          The (mandatory) argument of a _k_e_y_n_a_m_e command is the
  1004. X          _d_e_f_i_n_i_t_i_o_n for that key; inside it, \\\\ and ^^^^ have a special
  1005. X          meaning. Certain characters may be represented according to
  1006. X          the following table:
  1007. X
  1008. X
  1009. X
  1010. X     Page 1                                           (printed 9/4/89)
  1011. X
  1012. X
  1013. X
  1014. X
  1015. X
  1016. X
  1017. X     KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))               UUUUNNNNIIIIXXXX 5555....0000                KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))
  1018. X
  1019. X
  1020. X
  1021. X                  CHARACTER       ASCII SYMBOL    ESCAPE SEQUENCE
  1022. X
  1023. X                  newline(NL)          LF              \n
  1024. X                  horizontal-tab       HT              \t
  1025. X                  vertical-tab         VT              \v
  1026. X                  backspace            BS              \b
  1027. X                  carriage-return      CR              \r
  1028. X                  formfeed             FF              \f
  1029. X                  escape               ESC             \e
  1030. X                  backslah             \               \\
  1031. X                  single-quote         '               \' or \Q
  1032. X                  double-quote         "               \D
  1033. X                  bit-pattern          ddd             \ddd
  1034. X
  1035. X          The escape \\\\dddddddddddd consists of the backslash followed by 1, 2,
  1036. X          or 3 octal digits, which are taken to specify the value of
  1037. X          the desired character. If the character following a
  1038. X          backslash is not one of those specified, the backslash is
  1039. X          ignored. ^^^^xxxx maps to a control-x for any appropriate x. To
  1040. X          program a literal circumflex, preceed it with a backslash.
  1041. X
  1042. X          A function key is executed by pressing one of the function
  1043. X          keys (FFFF****), or by pressing SHIFT + function key (SSSS****).
  1044. X
  1045. X     WWWWAAAARRRRNNNNIIIINNNNGGGGSSSS
  1046. X          There is a finite amount of memory in the terminal for
  1047. X          storing the definitions. The exceeding characters are
  1048. X          discharged.
  1049. X
  1050. X          Terminal is getting confused when any character is
  1051. X          asynchronously received/typed during the execution of
  1052. X          _k_e_y_d_e_f.
  1053. X
  1054. X          Depending on the terminal type and/or setting, not all the
  1055. X          keys can be programmed; typically, F11 (ESC), F12 (BS) and
  1056. X          F13 (LF) can be protected from the user's redefinition.
  1057. X
  1058. X          This program has been developed and tested on an _O_l_i_v_e_t_t_i _W_S
  1059. X          _6_8_5 desktop video display terminal emulating DEC terminals
  1060. X          VT220, VT100 and VT52, connected via RS232 to an _O_l_i_v_e_t_t_i
  1061. X          _L_S_X-_3_0_1_0 with the _L_2 _X/_O_S _R_2._0 Unix System. You should not
  1062. X          have porting problems on any X/OPEN system.
  1063. X
  1064. X     SSSSEEEEEEEE AAAALLLLSSSSOOOO
  1065. X          VT220 or VT320 Programmer Pocket Guide, and/or WS 685 User
  1066. X          Guide.
  1067. X
  1068. X     AAAAUUUUTTTTHHHHOOOORRRR
  1069. X          Fulvio MARINO, Olivetti, Ivrea, Italy
  1070. X          (fulvio@oliveb.ATC.Olivetti.Com)
  1071. X
  1072. X          Comments, suggestions, and patches welcomed.
  1073. X
  1074. X
  1075. X
  1076. X     Page 2                                           (printed 9/4/89)
  1077. X
  1078. X
  1079. X
  1080. X
  1081. X
  1082. X
  1083. X     KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))               UUUUNNNNIIIIXXXX 5555....0000                KKKKEEEEYYYYDDDDEEEEFFFF((((llllooooccccaaaallll))))
  1084. X
  1085. X
  1086. X
  1087. X     CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
  1088. X          Copyright (c) 1989 Olivetti S.p.A. Ivrea, Italy.
  1089. X          All rights reserved.
  1090. X
  1091. X          Redistribution and use in source and binary forms are
  1092. X          permitted provided that the above copyright notice and this
  1093. X          paragraph are duplicated in all such forms and that any
  1094. X          documentation, advertising materials, and other materials
  1095. X          related to such distribution and use acknowledge that the
  1096. X          software was developed by the Olivetti S.p.A., Italy.  The
  1097. X          name of Olivetti S.p.A. may not be used to endorse or
  1098. X          promote products derived from this software without specific
  1099. X          prior written permission.
  1100. X          THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS
  1101. X          OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE
  1102. X          IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A
  1103. X          PARTICULAR PURPOSE.
  1104. X
  1105. X
  1106. X
  1107. X
  1108. X
  1109. X
  1110. X
  1111. X
  1112. X
  1113. X
  1114. X
  1115. X
  1116. X
  1117. X
  1118. X
  1119. X
  1120. X
  1121. X
  1122. X
  1123. X
  1124. X
  1125. X
  1126. X
  1127. X
  1128. X
  1129. X
  1130. X
  1131. X
  1132. X
  1133. X
  1134. X
  1135. X
  1136. X
  1137. X
  1138. X
  1139. X
  1140. X
  1141. X
  1142. X     Page 3                                           (printed 9/4/89)
  1143. X
  1144. X
  1145. X
  1146. END_OF_FILE
  1147. echo shar: 1273 control characters may be missing from \"'keydef.man'\"
  1148. if test 8947 -ne `wc -c <'keydef.man'`; then
  1149.     echo shar: \"'keydef.man'\" unpacked with wrong size!
  1150. fi
  1151. # end of 'keydef.man'
  1152. fi
  1153. if test -f 'makefile' -a "${1}" != "-c" ; then 
  1154.   echo shar: Will not clobber existing file \"'makefile'\"
  1155. else
  1156. echo shar: Extracting \"'makefile'\" \(1430 characters\)
  1157. sed "s/^X//" >'makefile' <<'END_OF_FILE'
  1158. X
  1159. X########################################################################
  1160. X#
  1161. X# Copyright (c) 1989 Olivetti S.p.A. Ivrea, Italy.
  1162. X# All rights reserved.
  1163. X#
  1164. X# Redistribution and use in source and binary forms are permitted
  1165. X# provided that the above copyright notice and this paragraph are
  1166. X# duplicated in all such forms and that any documentation,
  1167. X# advertising materials, and other materials related to such
  1168. X# distribution and use acknowledge that the software was developed
  1169. X# by the Olivetti S.p.A. Ivrea, Italy.  The name of Olivetti may
  1170. X# not be used to endorse or promote products derived from this
  1171. X# software without specific prior written permission.
  1172. X# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  1173. X# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  1174. X# WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1175. X#
  1176. X########################################################################
  1177. X
  1178. XSHELL=/bin/sh
  1179. X
  1180. XBINDIR=/usr/local/bin
  1181. XMANDIR=/usr/local/man
  1182. X
  1183. XBIN=$(BINDIR)/keydef
  1184. XMAN=$(MANDIR)/keydef.1
  1185. X
  1186. X
  1187. Xall install:: keydef    # Use built-in rules
  1188. X
  1189. Xinstall:: # For super-user only
  1190. X    cp keydef $(BIN)
  1191. X    cp keydef.1u $(MAN)
  1192. X
  1193. Xclean: NOREM    # rm all files not specified in NOREM
  1194. X    @- a="`ls . | fgrep -vx -f NOREM`" \
  1195. X        || exit 0 \
  1196. X        && echo rm -rf $$a \
  1197. X        && rm -rf $$a
  1198. X
  1199. Xkeydef.man: keydef.1u
  1200. X    nroff -Tlp -man $? > $@
  1201. X
  1202. XMANIFEST: NOREM
  1203. X    makekit -m `cat $@`
  1204. X
  1205. Xkit: keydef.man MANIFEST
  1206. X    makekit -i MANIFEST -h 2
  1207. END_OF_FILE
  1208. if test 1430 -ne `wc -c <'makefile'`; then
  1209.     echo shar: \"'makefile'\" unpacked with wrong size!
  1210. fi
  1211. # end of 'makefile'
  1212. fi
  1213. if test -f 'sample' -a "${1}" != "-c" ; then 
  1214.   echo shar: Will not clobber existing file \"'sample'\"
  1215. else
  1216. echo shar: Extracting \"'sample'\" \(3610 characters\)
  1217. sed "s/^X//" >'sample' <<'END_OF_FILE'
  1218. X########################################################################
  1219. X#
  1220. X# Copyright (c) 1989 Olivetti S.p.A. Ivrea, Italy.
  1221. X# All rights reserved.
  1222. X#
  1223. X# Redistribution and use in source and binary forms are permitted
  1224. X# provided that the above copyright notice and this paragraph are
  1225. X# duplicated in all such forms and that any documentation,
  1226. X# advertising materials, and other materials related to such
  1227. X# distribution and use acknowledge that the software was developed
  1228. X# by the Olivetti S.p.A. Ivrea, Italy.  The name of Olivetti may
  1229. X# not be used to endorse or promote products derived from this
  1230. X# software without specific prior written permission.
  1231. X# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  1232. X# IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  1233. X# WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  1234. X#
  1235. X########################################################################
  1236. X
  1237. X
  1238. Xclear    # erase the contents of all the f-keys.
  1239. X
  1240. X#lock    # after the settings here specified, disable key definitions
  1241. X    # (enabling can be done only via Set-Up)
  1242. X
  1243. X# The following f-keys can be redefined only if your terminal setting
  1244. X# allows this.
  1245. XF-ESC    \\e
  1246. XF-BS    \\b
  1247. XF-LF    \\n
  1248. X
  1249. XS11    \\e    # Function key S11 may default to 'esc' but you can
  1250. X        # override it here
  1251. XS12    \\b
  1252. XS13    \\n
  1253. X
  1254. X#
  1255. X# Set my C-lang `vi-environment'
  1256. X#
  1257. X
  1258. XF6 \
  1259. X"Qset ai eb ic nomesg nu opt para= prompt redraw noremap"\
  1260. X" report=1 sections= shell=/bin/sh sm smd tl=0 tags=tags terse"\
  1261. X" timeout noremap
  1262. Xmap! #/ /*^V\r * ^V\r*/^V^[kA
  1263. Xmap! #in #include <>^V^[i
  1264. Xmap! #de #define \t/*  */^V^[0f a
  1265. Xmap! #un #undef\t
  1266. Xmap! #id #ifdef 
  1267. Xmap! #if #if defined()^V^[i
  1268. Xmap! #el #else
  1269. Xmap! #en #endif
  1270. Xmap! br' break;
  1271. Xmap! ca' case : /*  */^V\r\tbreak;^V^[k0f:i
  1272. Xmap! ch' char\t;^V^[i
  1273. Xmap! co' continue;
  1274. Xmap! de' default: /*  */^V\r\tbreak;^V^[O
  1275. Xmap! do' double\t;^V^[i
  1276. Xmap! dw' do {^V\r} while();^V^[O\t
  1277. Xmap! ei' else if () {^V\r}^V^[k0f(a
  1278. Xmap! el' else {^V\r}^V^[O\t
  1279. Xmap! en' enum {^V\r};^V^[O\t
  1280. Xmap! ex' extern ;^V^[i
  1281. Xmap! fl' float ;^V^[i
  1282. Xmap! fo' for (;;) {^V\r}^V^[k0f(a
  1283. Xmap! go' goto ;^V^[i
  1284. Xmap! if' if () {^V\r}^V^[k0f(a
  1285. Xmap! in' int\t;^V^[i
  1286. Xmap! lo' long\t;^V^[i
  1287. Xmap! ma' main(argc, argv, environ)^V\rint\targc;^V\rchar\t*argv[], *environ[];^V\r{^V\r}^V^[O\t
  1288. Xmap! re' return();^V^[hi
  1289. Xmap! rg' register ;^V^[i
  1290. Xmap! sc' static ;^V^[i
  1291. Xmap! sh' short ;^V^[i
  1292. Xmap! si' sizeof()^V^[i
  1293. Xmap! st' struct {^V\r};^V^[k0f a
  1294. Xmap! sw' switch () {^V\rcase : /* */^V\r\tbreak;^V\r ^V^[xr}kkk0f(a
  1295. Xmap! ty' typedef ;^V^[i
  1296. Xmap! un' union {^V\r};^V^[O\t
  1297. Xmap! us' unsigned ;^V^[i
  1298. Xmap! wh' while () {^V\r}^V^[k0f(a
  1299. Xvi .\n"
  1300. X
  1301. X#
  1302. X# Reset to my standard  `vi-environment'
  1303. X#
  1304. X
  1305. XS6 \
  1306. X"Qset notimeout
  1307. Xunmap! #/
  1308. Xunmap! #in
  1309. Xunmap! #de
  1310. Xunmap! #un
  1311. Xunmap! #id
  1312. Xunmap! #if
  1313. Xunmap! #el
  1314. Xunmap! #en
  1315. Xunmap! br'
  1316. Xunmap! ca'
  1317. Xunmap! ch'
  1318. Xunmap! co'
  1319. Xunmap! de'
  1320. Xunmap! do'
  1321. Xunmap! dw'
  1322. Xunmap! ei'
  1323. Xunmap! el'
  1324. Xunmap! en'
  1325. Xunmap! ex'
  1326. Xunmap! fl'
  1327. Xunmap! fo'
  1328. Xunmap! go'
  1329. Xunmap! if'
  1330. Xunmap! in'
  1331. Xunmap! lo'
  1332. Xunmap! ma'
  1333. Xunmap! re'
  1334. Xunmap! rg'
  1335. Xunmap! sc'
  1336. Xunmap! sh'
  1337. Xunmap! si'
  1338. Xunmap! st'
  1339. Xunmap! sw'
  1340. Xunmap! ty'
  1341. Xunmap! un'
  1342. Xunmap! us'
  1343. Xunmap! wh'
  1344. Xvi .\n"
  1345. X
  1346. X
  1347. X# I use my function key F7 for temporary, repetitive things; complicated
  1348. X# commands, sequences, etc. Real nice if application allows shell
  1349. X# escapes.  Most often used with complicated vi commands. 
  1350. X
  1351. XS7    'keydef F7\n'
  1352. X
  1353. X
  1354. XF-Help    apropos\\t
  1355. XS-Help    man\\t
  1356. X
  1357. X# Two ways to make a 'shell escape' from vi:
  1358. XF-Do    ^Z
  1359. XS-Do    :!/bin/csh
  1360. X
  1361. X# To execute remote commands on my preferred systems:
  1362. XF14    "/usr/ucb/bin/rsh icodap "
  1363. XS14    "/usr/ucb/bin/rsh newgest -l vigna "
  1364. X
  1365. X
  1366. X# Sometime I use bc with the numeric keypad; I find this useful:
  1367. XF17    ' + '
  1368. XF18    ' - '
  1369. XF19    ' * '
  1370. XF20    ' / '
  1371. END_OF_FILE
  1372. if test 3610 -ne `wc -c <'sample'`; then
  1373.     echo shar: \"'sample'\" unpacked with wrong size!
  1374. fi
  1375. # end of 'sample'
  1376. fi
  1377. echo shar: End of archive 1 \(of 1\).
  1378. cp /dev/null ark1isdone
  1379. MISSING=""
  1380. for I in 1 ; do
  1381.     if test ! -f ark${I}isdone ; then
  1382.     MISSING="${MISSING} ${I}"
  1383.     fi
  1384. done
  1385. if test "${MISSING}" = "" ; then
  1386.     echo You have the archive.
  1387.     rm -f ark[1-9]isdone
  1388. else
  1389.     echo You still need to unpack the following archives:
  1390.     echo "        " ${MISSING}
  1391. fi
  1392. ##  End of shell archive.
  1393. exit 0
  1394.  
  1395.