![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to abbrev.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to abbrev.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9:
10: #ifdef ABBREV
11:
12: #include "io.h"
13: #include "ctype.h"
14:
15: #ifdef MSDOS
16: #include <io.h>
17: #endif
18: #define HASHSIZE 20
19:
20: struct abbrev {
21: unsigned int a_hash;
22: char *a_abbrev,
23: *a_phrase;
24: struct abbrev *a_next;
25: data_obj *a_cmdhook;
26: };
27:
28: #ifdef MAC
29: # undef private
30: # define private
31: #endif
32:
33: #ifdef LINT_ARGS
34: private void
35: define(struct abbrev **, char *, char *),
36: def_abbrev(struct abbrev **),
37: rest_abbrevs(char *),
38: save_abbrevs(char *);
39:
40: private unsigned int hash(char *);
41: private struct abbrev * lookup(struct abbrev **, char *);
42: #else
43: private void
44: define(),
45: def_abbrev(),
46: rest_abbrevs(),
47: save_abbrevs();
48:
49: private unsigned int hash();
50: private struct abbrev * lookup();
51: #endif /* LINT_ARGS */
52:
53: #ifdef MAC
54: # undef private
55: # define private static
56: #endif
57:
58: #define GLOBAL NMAJORS
59: private struct abbrev *A_tables[NMAJORS + 1][HASHSIZE] = {0};
60:
61: int AutoCaseAbbrev = 1;
62:
63: private unsigned int
64: hash(a)
65: register char *a;
66: {
67: register unsigned int hashval = 0;
68: register int c;
69:
70: while (c = *a++)
71: hashval = (hashval << 2) + c;
72:
73: return hashval;
74: }
75:
76: private void
77: def_abbrev(table)
78: struct abbrev *table[HASHSIZE];
79: {
80: char abbrev[100],
81: phrase[100];
82:
83: strcpy(abbrev, ask((char *) 0, "abbrev: "));
84: strcpy(phrase, ask((char *) 0, "abbrev: %s phrase: ", abbrev));
85: define(table, abbrev, phrase);
86: }
87:
88: private struct abbrev *
89: lookup(table, abbrev)
90: register struct abbrev *table[HASHSIZE];
91: register char *abbrev;
92: {
93: register struct abbrev *ap;
94: unsigned int h;
95:
96: h = hash(abbrev);
97: for (ap = table[h % HASHSIZE]; ap; ap = ap->a_next)
98: if (ap->a_hash == h && strcmp(ap->a_abbrev, abbrev) == 0)
99: break;
100: return ap;
101: }
102:
103: private void
104: define(table, abbrev, phrase)
105: register struct abbrev *table[HASHSIZE];
106: char *abbrev,
107: *phrase;
108: {
109: register struct abbrev *ap;
110:
111: ap = lookup(table, abbrev);
112: if (ap == 0) {
113: register unsigned int h = hash(abbrev);
114:
115: ap = (struct abbrev *) emalloc(sizeof *ap);
116: ap->a_hash = h;
117: ap->a_abbrev = copystr(abbrev);
118: h %= HASHSIZE;
119: ap->a_next = table[h];
120: ap->a_cmdhook = 0;
121: table[h] = ap;
122: } else
123: free(ap->a_phrase);
124: ap->a_phrase = copystr(phrase);
125: }
126:
127: void
128: AbbrevExpand()
129: {
130: Bufpos point;
131: char wordbuf[100];
132: register char *wp = wordbuf,
133: *cp;
134: #if !(defined(IBMPC) || defined(MAC))
135: register int c;
136: #else
137: int c;
138: #endif
139: int UC_count = 0;
140: struct abbrev *ap;
141:
142: DOTsave(&point);
143: WITH_TABLE(curbuf->b_major)
144: b_word(1);
145: while (curchar < point.p_char && ismword(c = linebuf[curchar])) {
146: if (AutoCaseAbbrev) {
147: if (isupper(c)) {
148: UC_count += 1;
149: #if (defined(IBMPC) || defined(MAC))
150: lower(&c);
151: #else
152: c = tolower(c);
153: #endif
154: }
155: }
156: *wp++ = c;
157: curchar += 1;
158: }
159: *wp = '\0';
160: END_TABLE();
161:
162: if ((ap = lookup(A_tables[curbuf->b_major], wordbuf)) == 0 &&
163: (ap = lookup(A_tables[GLOBAL], wordbuf)) == 0) {
164: SetDot(&point);
165: return;
166: }
167: del_char(BACKWARD, (wp - wordbuf));
168:
169: for (cp = ap->a_phrase; c = *cp; ) {
170: if (AutoCaseAbbrev) {
171: insert_c(islower(c) && UC_count &&
172: (cp == ap->a_phrase || (UC_count > 1 && (cp[-1] == ' '))) ?
173: toupper(c) : c, 1);
174: } else
175: insert_c(c, 1);
176: cp += 1;
177: }
178: if (ap->a_cmdhook != 0)
179: ExecCmd(ap->a_cmdhook);
180: }
181:
182: private char *mode_names[NMAJORS + 1] = {
183: "Fundamental Mode",
184: "Text Mode",
185: "C Mode",
186: #ifdef LISP
187: "Lisp Mode",
188: #endif
189: "Global"
190: };
191:
192: private void
193: save_abbrevs(file)
194: char *file;
195: {
196: File *fp;
197: struct abbrev *ap,
198: **tp;
199: char buf[LBSIZE];
200: int i,
201: count = 0;
202:
203: fp = open_file(file, buf, F_WRITE, COMPLAIN, QUIET);
204: for (i = 0; i <= GLOBAL; i++) {
205: fprintf(fp, "------%s abbrevs------\n", mode_names[i]);
206: for (tp = A_tables[i]; tp < &A_tables[i][HASHSIZE]; tp++)
207: for (ap = *tp; ap; ap = ap->a_next) {
208: fprintf(fp, "%s:%s\n",
209: ap->a_abbrev,
210: ap->a_phrase);
211: count += 1;
212: }
213: }
214: f_close(fp);
215: add_mess(" %d written.", count);
216: }
217:
218: private void
219: rest_abbrevs(file)
220: char *file;
221: {
222: int eof = 0,
223: mode = -1, /* Will be ++'d immediately */
224: lnum = 0;
225: char *phrase_p;
226: File *fp;
227: char buf[LBSIZE];
228:
229: fp = open_file(file, buf, F_READ, COMPLAIN, QUIET);
230: while (mode <= GLOBAL) {
231: eof = f_gets(fp, genbuf, LBSIZE);
232: if (eof || genbuf[0] == '\0')
233: break;
234: lnum += 1;
235: if (strncmp(genbuf, "------", 6) == 0) {
236: mode += 1;
237: continue;
238: }
239: if (mode == -1)
240: fmterr: complain("Abbrev. format error, line %d.", file, lnum);
241: phrase_p = index(genbuf, ':');
242: if (phrase_p == 0)
243: goto fmterr;
244: *phrase_p++ = '\0'; /* Null terminate the abbrev. */
245: define(A_tables[mode], genbuf, phrase_p);
246: }
247: f_close(fp);
248: message(NullStr);
249: }
250:
251: void
252: DefGAbbrev()
253: {
254: def_abbrev(A_tables[GLOBAL]);
255: }
256:
257: void
258: DefMAbbrev()
259: {
260: def_abbrev(A_tables[curbuf->b_major]);
261: }
262:
263: void
264: SaveAbbrevs()
265: {
266: char filebuf[FILESIZE];
267:
268: save_abbrevs(ask_file((char *) 0, (char *) 0, filebuf));
269: }
270:
271: void
272: RestAbbrevs()
273: {
274: char filebuf[FILESIZE];
275:
276: rest_abbrevs(ask_file((char *) 0, (char *) 0, filebuf));
277: }
278:
279: void
280: EditAbbrevs()
281: {
282: char *tname = "jove_wam.$$$",
283: *EditName = "Abbreviation Edit";
284: Buffer *obuf = curbuf,
285: *ebuf;
286:
287: if (ebuf = buf_exists(EditName)) {
288: if (ebuf->b_type != B_SCRATCH)
289: confirm("Over-write buffer %b?", ebuf);
290: }
291: SetBuf(ebuf = do_select(curwind, EditName));
292: ebuf->b_type = B_SCRATCH;
293: initlist(ebuf);
294: /* Empty buffer. Save the definitions to a tmp file
295: and read them into this buffer so we can edit them. */
296: save_abbrevs(tname);
297: read_file(tname, NO);
298: message("[Edit definitions and then type C-X C-C]");
299: Recur(); /* We edit them ... now */
300: /* RESetBuf in case we deleted the buffer while we were editing. */
301: SetBuf(ebuf = do_select(curwind, EditName));
302: if (IsModified(ebuf)) {
303: SetBuf(ebuf);
304: file_write(tname, 0);
305: rest_abbrevs(tname);
306: unmodify();
307: }
308: (void) unlink(tname);
309: SetBuf(do_select(curwind, obuf->b_name));
310: }
311:
312: void
313: BindMtoW()
314: {
315: struct abbrev *ap;
316: char *word;
317: data_obj *hook;
318:
319: word = ask((char *) 0, "Word: ");
320:
321: if ((ap = lookup(A_tables[curbuf->b_major], word)) == 0 &&
322: (ap = lookup(A_tables[GLOBAL], word)) == 0)
323: complain("%s: unknown abbrev.", word);
324:
325: hook = findmac("Macro: ");
326: if (hook == 0)
327: complain("[Undefined macro]");
328: ap->a_cmdhook = hook;
329: }
330:
331: #endif /* ABBREV */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.