![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sugg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed|
Return to sugg.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
2: static char rcsid[] = "$Header: sugg.c,v 2.4 84/10/26 12:10:51 guido Exp $";
3:
4: /*
5: * B editor -- New suggestion handling module.
6: */
7:
8: #include "feat.h"
9:
10: #ifdef USERSUGG
11:
12: #include "b.h"
13: #include "bobj.h"
14: #include "node.h"
15: #include "supr.h"
16: #include "gram.h"
17: #include "queu.h"
18:
19: #include <ctype.h>
20:
21: extern bool dflag;
22: extern bool edontop;
23:
24: extern bool lefttorite;
25:
26: #ifndef SUGGFILE
27: #define SUGGFILE ".Bed_sugg"
28: #endif
29:
30: #define MAXNSUGG 1000
31:
32: Hidden value sugg[MAXNSUGG];
33: Hidden int nsugg;
34: Hidden int nbuiltin;
35: Hidden bool suggchanges;
36: Hidden bool ignorefirstcall; /* Communication between killsugg and setsugg */
37:
38: /*
39: * Read the suggestion table from file.
40: */
41:
42: Visible Procedure
43: initsugg()
44: {
45: char buffer[1000];
46: register FILE *fp;
47: register c;
48:
49: fp = fopen(SUGGFILE, "r");
50: if (!fp) {
51: if (dflag) {
52: fprintf(stderr, "*** No suggestion file: ");
53: perror(SUGGFILE);
54: }
55: return;
56: }
57: while (fgets(buffer, sizeof buffer, fp)) {
58: if (!index(buffer, '\n')) { /* Skip long line */
59: fprintf(stderr,
60: "*** Excessively long suggestion ignored\n");
61: while ((c = getc(fp)) != '\n' && c != EOF)
62: ;
63: }
64: else
65: addsugg(buffer, -1);
66: }
67: fclose(fp);
68: }
69:
70:
71: /*
72: * Make sure a line looks like a suggestion, return No if not.
73: * Replace the trailing newline or comment-sign by a zero byte.
74: * ***** Should check more thoroughly. *****
75: */
76:
77: Hidden bool
78: checksugg(bp)
79: string bp;
80: {
81: if (!isascii(*bp) || !isupper(*bp))
82: return No;
83: while (*bp && *bp != '\n' && *bp != '\\')
84: ++bp;
85: *bp = 0;
86: return Yes;
87: }
88:
89:
90: /*
91: * Procedure to add a suggestion to the suggestion table.
92: */
93:
94: Visible Procedure
95: addsugg(str, builtin)
96: string str;
97: int builtin;
98: {
99: int i;
100: int j;
101: int len;
102: int cmp;
103: string suggi;
104: int where = (builtin == -1) ? nsugg : nbuiltin;
105:
106: if (!checksugg(str))
107: return;
108: for (len = 0; str[len] && str[len] != ' '; ++len)
109: ;
110: for (i = nsugg-1; i >= 0; --i) {
111: suggi = Str(sugg[i]);
112: cmp = strncmp(str, suggi, len);
113: if (cmp < 0)
114: continue;
115: if (cmp > 0) {
116: if (i >= where)
117: where = i+1;
118: continue;
119: }
120: if (suggi[len] && suggi[len] != ' ')
121: continue; /* No match, just prefix */
122: if (Strequ(str+len, suggi+len))
123: return; /* Ignore exact duplicates */
124: if (i < nbuiltin)
125: return; /* Cannot replace built-in */
126: /* Replacement */
127: sugg[i] = mk_text(str); /* No use to release the old one... */
128: /* ...its refcount is infinite */
129: fix(sugg[i]);
130: suggchanges = Yes;
131: return;
132: }
133: /* Insertion */
134: if (nsugg >= MAXNSUGG)
135: return; /* Table overflow */
136: if (builtin == Yes)
137: ++nbuiltin;
138: for (j = nsugg; j > where; --j)
139: sugg[j] = sugg[j-1];
140: ++nsugg;
141: sugg[where] = mk_text(str);
142: fix(sugg[where]);
143: suggchanges = Yes;
144: }
145:
146:
147: /*
148: * Procedure to delete a suggestion from the suggestion table.
149: * Must supply the whole string as argument.
150: */
151:
152: Hidden Procedure
153: delsugg(str)
154: string str;
155: {
156: int i;
157:
158: for (i = 0; i < nsugg; ++i) {
159: if (Strequ(str, Str(sugg[i]))) {
160: --nsugg;
161: for (; i < nsugg; ++i)
162: sugg[i] = sugg[i+1];
163: suggchanges = Yes;
164: return;
165: }
166: }
167: }
168:
169:
170: /*
171: * Return a suitable suggestion which matches str for len characters.
172: * If len > 1, and all of str (even beyond len) equals some table
173: * entry, the first matching entry after that is preferred; otherwise,
174: * the first matching entry at all is returned.
175: * Vnil is returned if no entry matches.
176: */
177:
178: Hidden node
179: nextsugg(str, len)
180: string str;
181: int len;
182: {
183: bool found = !str[len];
184: int first = -1;
185: int i;
186:
187: for (i = 0; i < nsugg; ++i) {
188: if (!Strnequ(str, Str(sugg[i]), len))
189: continue;
190: if (found)
191: return (node) sugg[i];
192: if (Strequ(str+len, Str(sugg[i])+len))
193: found = Yes;
194: if (first < 0)
195: first = i;
196: }
197: if (first >= 0)
198: return (node) sugg[first];
199: return Nnil;
200: }
201:
202:
203: /*
204: * Procedure to save the suggestion file if it has been changed.
205: */
206:
207: Visible Procedure
208: endsugg()
209: {
210: FILE *fp;
211: int i;
212:
213: if (!suggchanges)
214: return;
215: suggchanges = No;
216: fp = fopen(SUGGFILE, "w");
217: if (!fp) {
218: if (dflag) {
219: fprintf(stderr, "*** Can't rewrite ");
220: perror(SUGGFILE);
221: }
222: return;
223: }
224: if (dflag)
225: fprintf(stderr, "*** [Rewriting suggestion file]\n");
226: for (i = nbuiltin; i < nsugg; ++i)
227: fprintf(fp, "%s\n", Str(sugg[i]));
228: if (fclose(fp) == EOF) {
229: fprintf(stderr, "*** Can't finish writing ");
230: perror(SUGGFILE);
231: return;
232: }
233: }
234:
235:
236: /*
237: * Find a new suggestion or advance in the current one.
238: * Interface styled like resuggest: string pointer is advanced here.
239: */
240:
241: Visible bool
242: newsugg(ep, pstr, alt_c)
243: environ *ep;
244: string *pstr;
245: int alt_c;
246: {
247: char buffer[1000];
248: node n = tree(ep->focus);
249: node nn;
250: int sym = symbol(n);
251: string str;
252: string bp;
253: bool end;
254:
255: Assert(pstr && *pstr);
256: if (sym != Suggestion || ep->mode != VHOLE || ep->s1 != 2)
257: return No;
258: strncpy(buffer, Str((value)firstchild(n)), sizeof buffer);
259: for (str = *pstr, bp = buffer+ep->s2, end = No;
260: *str && bp < buffer + sizeof buffer; ++str, ++bp) {
261: if (!*bp)
262: end = Yes;
263: *bp = *str;
264: }
265: if (end)
266: *bp = 0;
267: nn = (node)nextsugg(buffer, ep->s2 + 1);
268: if (!nn) {
269: if (!alt_c)
270: return No;
271: buffer[ep->s2] = alt_c;
272: nn = (node)nextsugg(buffer, ep->s2 + 1);
273: if (!nn)
274: return No;
275: }
276: if (nn != firstchild(n)) {
277: s_down(ep);
278: replace(&ep->focus, nn);
279: s_up(ep);
280: }
281: /* No need to release because its refcount is infinite anyway */
282: ++ep->s2;
283: if (**pstr == ' ')
284: accsugg(ep);
285: ++*pstr;
286: return Yes;
287: }
288:
289:
290: /*
291: * Kill suggestion -- only the part to the left of the focus is kept.
292: */
293:
294: Visible Procedure
295: killsugg(ep)
296: environ *ep;
297: {
298: queue q = Qnil;
299: char buffer[1000];
300: node n = tree(ep->focus);
301:
302: Assert(ep->mode == VHOLE && ep->s1 == 2 && symbol(n) == Suggestion);
303: strncpy(buffer, Str((value)firstchild(n)), ep->s2);
304: buffer[ep->s2] = 0;
305: delfocus(&ep->focus);
306: ep->mode = WHOLE;
307: ignorefirstcall = Yes;
308: ins_string(ep, buffer, &q, 0);
309: qrelease(q);
310: ignorefirstcall = No;
311: }
312:
313:
314: /*
315: * Place an initial suggestion in a node.
316: */
317:
318: Visible bool
319: setsugg(pp, c, ep)
320: path *pp;
321: char c;
322: environ *ep;
323: {
324: char buf[2];
325: node n;
326:
327: if (lefttorite)
328: return No;
329: if (ignorefirstcall) {
330: ignorefirstcall = No;
331: return No;
332: }
333: buf[0] = c;
334: buf[1] = 0;
335: n = (node)nextsugg(buf, 1);
336: if (!n)
337: return No;
338: replace(pp, newnode(1, Suggestion, &n));
339: ep->mode = VHOLE;
340: ep->s1 = 2;
341: ep->s2 = 1;
342: return Yes;
343: }
344:
345:
346: /*
347: * Accept a suggestion -- turn it into real nodes.
348: */
349:
350: Visible Procedure
351: accsugg(ep)
352: environ *ep;
353: {
354: node n = tree(ep->focus);
355: int s2 = ep->s2;
356: queue q = Qnil;
357: environ env;
358:
359: Assert(symbol(n) == Suggestion && ep->mode == VHOLE && ep->s1 == 2);
360: stringtoqueue(Str((value)firstchild(n)) + s2, &q);
361: killsugg(ep);
362: Ecopy(*ep, env);
363: if (app_queue(ep, &q))
364: Erelease(env);
365: else {
366: Erelease(*ep);
367: Emove(env, *ep);
368: qrelease(q);
369: }
370: }
371:
372:
373: /*
374: * Procedure called when a unit is read in.
375: * It tries to update the suggestion database.
376: * It also remembers the suggestion so that it can be removed by writesugg
377: * if that finds the unit was deleted.
378: */
379:
380: Hidden char lastsugg[1000];
381:
382: Visible Procedure
383: readsugg(p)
384: path p;
385: {
386: p = pathcopy(p);
387: top(&p);
388: getpattern(lastsugg, tree(p));
389: pathrelease(p);
390: addsugg(lastsugg, No);
391: }
392:
393:
394: /*
395: * Procedure called when a unit is saved.
396: * It tries to update the suggestion database.
397: * If the unit appears empty, the last suggestion passed to readsugg
398: * will be deleted.
399: */
400:
401: Visible Procedure
402: writesugg(p)
403: path p;
404: {
405: p = pathcopy(p);
406: top(&p);
407: if (width(tree(p)) == 0)
408: delsugg(lastsugg);
409: else {
410: getpattern(lastsugg, tree(p));
411: if (lastsugg[0])
412: addsugg(lastsugg, No);
413: }
414: pathrelease(p);
415: }
416:
417:
418: /*
419: * Procedure to find out the suggestion that fits the current unit.
420: * Makes the buffer empty if not a HOW'TO unit.
421: * ***** Won't work if B-grammar is severely changed! *****
422: */
423:
424: Hidden Procedure
425: getpattern(buffer, n)
426: string buffer;
427: node n;
428: {
429: string *rp = noderepr(n);
430:
431: buffer[0] = 0;
432: while (Fw_zero(rp[0])) {
433: if (nchildren(n) == 0)
434: return;
435: n = firstchild(n);
436: rp = noderepr(n);
437: }
438: if (!Strequ(rp[0], "HOW'TO ") || nchildren(n) < 1)
439: return;
440: subgetpattern(&buffer, firstchild(n));
441: *buffer = 0;
442: }
443:
444:
445: /*
446: * Refinement for getpattern to do the work.
447: */
448:
449: Hidden Procedure
450: subgetpattern(pbuf, n)
451: string *pbuf;
452: node n;
453: {
454: string *rp;
455: int i;
456: int nch;
457:
458: rp = noderepr(n);
459: nch = (Type(n) == Tex) ? 0 : nchildren(n);
460: for (i = 0; i <= nch; ++i) {
461: if (i > 0)
462: subgetpattern(pbuf, child(n, i));
463: if (Fw_positive(rp[i])) {
464: if (islower(rp[i][0]))
465: *(*pbuf)++ = '?';
466: else {
467: strcpy(*pbuf, rp[i]);
468: *pbuf += strlen(*pbuf);
469: }
470: }
471: }
472: }
473:
474: #endif USERSUGG
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.