![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to execute.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / me|
Return to execute.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / me |
1.1 root 1: /*
2: * This program is in public domain; written by Dave G. Conroy.
3: * This file contains the functions that bind keys to macros and functions,
4: * as well as the execution of macros and functions.
5: * code, for the MicroEMACS screen editor.
6: */
7: #include <stdio.h>
8: #include "ed.h"
9: BIND bind;
10: short *kbdm; /* Current Macro */
11: unsigned kbdlen; /* Curent Macro len in bytes */
12: short *kbdmip; /* Input for above */
13: short *kbdmop; /* Output for above */
14: int thisflag; /* Flags, this command */
15: int lastflag; /* Flags, last command */
16: extern char *realloc();
17: extern FILE *ffp;
18: /*
19: * find keybinding or return NULL
20: */
21: static KEYTAB *
22: findBind(c, tab)
23: int c;
24: KEYTAB *tab;
25: {
26: register KEYTAB *ktp;
27: register int i;
28:
29: for (i = c % HASHP; -1 != i; i = ktp->k_synonym)
30: if ((ktp = tab + i)->k_code == c)
31: return (ktp);
32: return (NULL);
33: }
34:
35: /*
36: * This is the general command execution routine.
37: * It handles the fake binding of all the keys to "self-insert".
38: * It also clears out the "thisflag" word, and arranges to move it
39: * to the "lastflag", so that the next command can look at it.
40: * Return the status of command.
41: */
42: execute(c, f, n)
43: register int c;
44: {
45: register KEYTAB *ktp;
46: int status;
47:
48: if ((NULL != (ktp = findBind(c, bind.table))) ||
49: (NULL != (ktp = findBind((c & ~OBND), keytab)))) {
50: thisflag = 0;
51: status = (ktp->k_fun < 0) ?
52: doMac(bind.macs - (2 + ktp->k_fun), f, n) :
53: (*(funtab[ktp->k_fun].f_fp))(f, n);
54: lastflag = thisflag;
55: return (status);
56: }
57:
58: if (c >= 0x20 && c <= 0xFF) { /* Self inserting. */
59: if (n <= 0) { /* Fenceposts. */
60: lastflag = 0;
61: return (n<0 ? FALSE : TRUE);
62: }
63: thisflag = 0; /* For the future. */
64: status = linsert(n, c);
65: lastflag = thisflag;
66:
67: /*
68: * If fill column is defined perform word wrap.
69: */
70: if (bind.fillcol)
71: wrapword();
72:
73: return (status);
74: }
75: lastflag = 0; /* Fake last flags. */
76: return (FALSE);
77: }
78:
79: /*
80: * Begin a keyboard macro.
81: * Error if not at the top level in keyboard processing.
82: * Set up variables and return.
83: */
84: ctlxlp(f, n)
85: {
86: if (kbdmip!=NULL) {
87: mlwrite("Not now");
88: return (FALSE);
89: }
90: if (NULL != kbdm)
91: free(kbdm);
92: mlwrite("[Start macro]");
93: if (NULL == (kbdmip = kbdm = malloc(kbdlen = NKBDM))) {
94: mlwrite("Out of space");
95: return (FALSE);
96: }
97: return (TRUE);
98: }
99:
100: /*
101: * End keyboard macro. Check for the same limit conditions as the
102: * above routine. Set up the variables and return to the caller.
103: */
104: ctlxrp(f, n)
105: {
106: if (kbdmip == NULL) {
107: mlwrite("Not now");
108: return (FALSE);
109: }
110: mlwrite("[End macro]");
111: kbdmip[-1] = -1; /* unique end marker */
112: *kbdmip++ = 0;
113: kbdm = realloc(kbdm, kbdlen = ((char *)kbdmip) - ((char *)kbdm));
114: kbdmip = NULL;
115: return (TRUE);
116: }
117:
118: /*
119: * Execute default macro.
120: */
121: ctlxe(f, n)
122: {
123: if (kbdmip!=NULL) { /* close macro first */
124: mlwrite("Not now");
125: return (FALSE);
126: }
127: return (doMac(&kbdm, f, n));
128: }
129:
130: /*
131: * Get a keybinding and remove it.
132: * return the binding.
133: */
134: static
135: unBind(c)
136: {
137: register short i;
138: register KEYTAB *ktp;
139:
140: mlerase();
141: if (NULL == (ktp = findBind(c, bind.table)))
142: return;
143: if ((i = ktp->k_fun) < 0) {
144: free(bind.macs[i = -(2 + i)]);
145: bind.macs[i] = NULL;
146: bind.maclen[i] = 0;
147: }
148: if (-1 != (i = ktp->k_synonym)) {
149: memcpy(ktp, (bind.table + i), sizeof(*ktp));
150: bind.table[i].k_code = bind.table[i].k_synonym = -1;
151: }
152: else
153: ktp->k_code = -1;
154: }
155:
156: /*
157: * Create a new binding in bind.table.
158: */
159: static
160: reBind(c, i)
161: {
162: register KEYTAB *ktp, *kh;
163:
164: kh = ktp = bind.table + (c % HASHP);
165: if (-1 != ktp->k_code) {
166: for (ktp = bind.table + MAXREB; --ktp >= bind.table; )
167: if (-1 == ktp->k_code)
168: break;
169: if (ktp < bind.table) {
170: mlwrite("No free spaces in mod tab");
171: return (FALSE);
172: }
173: ktp->k_synonym = kh->k_synonym;
174: kh->k_synonym = ktp - bind.table;
175: }
176: ktp->k_code = c;
177: ktp->k_fun = i;
178: return (TRUE);
179: }
180:
181: /*
182: * Bind a function PFX1|'R' to another function.
183: */
184: bindFun()
185: {
186: register int c, d;
187: register KEYTAB *ktp;
188:
189: mlwrite("Enter old keybinding ");
190: d = getbind(0);
191: ktp = findBind(d, keytab);
192: mlwrite("Enter new keybinding ");
193: if ((PFX1|'R') == (c = getbind(0))) {
194: mlwrite("Cannot rebind <ctl>-x r");
195: return (FALSE);
196: }
197: if (d == c) {
198: unBind(c);
199: return (TRUE);
200: }
201: if (NULL == ktp) {
202: mlwrite("Non existant binding");
203: return (FALSE);
204: }
205: unBind(c);
206: return (reBind(c, ktp->k_fun));
207: }
208:
209: /*
210: * Load flexable bindings from file.
211: */
212: loadBinds()
213: {
214: uchar fname[NFILEN];
215:
216: if (mlreply("Load bindings file: ", fname, NFILEN) != TRUE)
217: return (FALSE);
218: return (loadBup(fname, FALSE));
219: }
220:
221: /*
222: * report io error in various ways.
223: */
224: ioTrouble(fname, startsw)
225: uchar *fname;
226: {
227: switch (startsw) {
228: case FALSE: /* callec from ctl-x l */
229: mlwrite("I/O toruble with %s", fname);
230: return (FALSE);
231: case ABORT: /* called from -f switch */
232: fprintf(stderr, "I/O trouble with %s\n", fname);
233: exit(1);
234: case TRUE: /* default bindings file */
235: return (TRUE);
236: }
237: }
238: /*
239: * Actual work of load bindings.
240: */
241: loadBup(fname, startsw)
242: uchar *fname;
243: {
244: register int i;
245: short magic;
246:
247: if (((ffp=fopen(fname, "rb")) == NULL) ||
248: (1 != fread(&magic, sizeof(magic), 1, ffp)) ||
249: (magic != BINDID))
250: return (ioTrouble(fname, startsw));
251:
252: if (1 != fread(&bind, sizeof(bind), 1, ffp))
253: return (ioTrouble(fname, ABORT));
254:
255: for (i = 0; i < (MAXMAC + 2); i++) {
256: if (NULL != bind.macs[i]) {
257: if (NULL == (bind.macs[i] = malloc(bind.maclen[i]))) {
258: mlwrite("Out of memory");
259: for (; i <= MAXMAC; i++)
260: bind.macs[i] = NULL;
261: return (FALSE);
262: }
263: if (1 != fread(bind.macs[i], bind.maclen[i], 1, ffp))
264: return (ioTrouble(fname, ABORT));
265: }
266: }
267: if (NULL != bind.macs[MAXMAC+1]) {
268: if (NULL != kbdm)
269: free(kbdm);
270: kbdmip = NULL;
271: kbdm = bind.macs[MAXMAC+1];
272: kbdlen = bind.maclen[MAXMAC+1];
273: }
274: ffclose();
275: return (TRUE);
276: }
277:
278: /*
279: * Store flexable bindings to a file.
280: */
281: storBinds()
282: {
283: register int i;
284: static short magic = BINDID;
285: uchar fname[NFILEN];
286:
287: if (mlreply("Store bindings file: ", fname, NFILEN) != TRUE)
288: return (FALSE);
289: if (FIOSUC != ffwopen(fname, "wb"))
290: return (FALSE);
291: if (kbdmip != NULL || kbdm == NULL) /* store closed mac only */
292: bind.macs[MAXMAC+1] = NULL;
293: else {
294: bind.macs[MAXMAC+1] = kbdm;
295: bind.maclen[MAXMAC+1] = kbdlen;
296: }
297: fwrite(&magic, sizeof(magic), 1, ffp);
298: fwrite(&bind, sizeof(bind), 1, ffp);
299: for (i = 0; i < (MAXMAC + 2); i++)
300: if (NULL != bind.macs[i])
301: fwrite(bind.macs[i], bind.maclen[i], 1, ffp);
302: ffclose();
303: }
304:
305: /*
306: * declare macro to be a binding. PFX1|'M'
307: */
308: nameMac()
309: {
310: register int i, c;
311:
312: if (kbdmip != NULL)
313: ctlxrp();
314: if (kbdm == NULL) {
315: mlwrite("Not now");
316: return (FALSE);
317: }
318: mlwrite("Enter keybinding for macro ");
319: if ((PFX1|'R') == (c = getbind(0))) {
320: mlwrite("Cannot rebind <ctl>-x r");
321: return (FALSE);
322: }
323: unBind(c);
324:
325: for (i = 0; (i < MAXMAC) && (NULL != bind.macs[i]); i++)
326: ;
327: if (MAXMAC == i) {
328: mlwrite("Too many macros bound");
329: return (FALSE);
330: }
331: if (reBind(c, -(i + 2)) == FALSE)
332: return (FALSE);
333: bind.macs[i] = kbdm;
334: bind.maclen[i] = kbdlen;
335: kbdm = NULL;
336: kbdlen = 0;
337: return (TRUE);
338: }
339:
340: /*
341: * Bind current macro to initialization macro.
342: */
343: initMac()
344: {
345: if (kbdmip!=NULL || kbdmop!=NULL) {
346: mlwrite("Not now");
347: return (FALSE);
348: }
349: bind.macs[MAXMAC] = kbdm;
350: bind.maclen[MAXMAC] = kbdlen;
351: kbdm = NULL;
352: kbdlen = 0;
353: mlwrite("init mac bound");
354: return (TRUE);
355: }
356:
357: /*
358: * Execute a macro.
359: * The command argument is the number of times to loop. Quit as
360: * soon as a command gets an error.
361: * Return TRUE if all ok, else FALSE.
362: */
363: doMac(macro, f, n)
364: uchar **macro;
365: {
366: register int c;
367: register int af;
368: register int an;
369: register int s;
370: short *kbdsav;
371: uchar *macsav;
372:
373: if (!n)
374: return (TRUE);
375: if (NULL == (macsav = *macro)) {
376: mlwrite("Not now");
377: return (FALSE);
378: }
379: *macro = NULL; /* prevent regress */
380: kbdsav = kbdmop;
381: do {
382: kbdmop = macsav;
383: do {
384: af = FALSE;
385: an = 1;
386: if ((c = *kbdmop++) == bind.repeat) {
387: af = TRUE;
388: an = *kbdmop++;
389: c = *kbdmop++;
390: }
391: s = TRUE;
392: } while ((c != -1) && (s = execute(c, af, an)) == TRUE);
393: } while ((s == TRUE) && ((-1 == n) || --n));
394: if (-1 == n)
395: s = TRUE;
396: kbdmop = kbdsav;
397: *macro = macsav;
398: return (s);
399: }
400:
401: static
402: setpf(loc, no)
403: int *loc, no;
404: {
405: mlwrite("Enter prefix character %d or space ", no);
406: if (' ' != (no = getkey()))
407: *loc = no;
408: }
409:
410: /*
411: * Set prefix characters.
412: */
413: setPrefix()
414: {
415: int c;
416:
417: setpf(&bind.pfx1, 1);
418: setpf(&bind.pfx2, 2);
419: setpf(&bind.pfx3, 3);
420: mlwrite("Enter repeat code or space ");
421: if (' ' != (c = getkey()))
422: bind.repeat = c;
423: mlerase();
424: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.