![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to extend.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 extend.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: #include "io.h"
10: #include "termcap.h"
11: #include "ctype.h"
12: #ifdef JOB_CONTROL
13: # include <signal.h>
14: #endif
15:
16: #ifdef MAC
17: # include "mac.h"
18: #else
19: # include <varargs.h>
20: #endif
21:
22: #ifdef MSDOS
23: #include <process.h>
24: #endif
25:
26: #ifdef MAC
27: # undef private
28: # define private
29: #endif
30:
31: #ifdef LINT_ARGS
32: private void
33: fb_aux(data_obj *, data_obj **, char *, char *),
34: find_binds(data_obj *, char *),
35: vpr_aux(struct variable *, char *);
36: #else
37: private void
38: fb_aux(),
39: find_binds(),
40: vpr_aux();
41: #endif /* LINT_ARGS */
42:
43: #ifdef MAC
44: # undef private
45: # define private static
46: #endif
47:
48:
49: int InJoverc = 0;
50:
51: extern int getch(),
52: getchar();
53:
54: /* Auto execute code */
55:
56: #define NEXECS 20
57:
58: private struct {
59: char *a_pattern;
60: data_obj *a_cmd;
61: } AutoExecs[NEXECS] = {0};
62:
63: private int ExecIndex = 0;
64:
65: /* Command auto-execute. */
66:
67: void
68: CAutoExec()
69: {
70: DefAutoExec(findcom);
71: }
72:
73: /* Macro auto-execute. */
74:
75: void
76: MAutoExec()
77: {
78: DefAutoExec(findmac);
79: }
80:
81: /* VARARGS0 */
82:
83: void
84: DefAutoExec(proc)
85: #ifdef LINT_ARGS
86: data_obj *(*proc)(char *);
87: #else
88: data_obj *(*proc)();
89: #endif
90: {
91: data_obj *d;
92: char *pattern;
93: int i;
94:
95: if (ExecIndex >= NEXECS)
96: complain("Too many auto-executes, max %d.", NEXECS);
97: if ((d = (*proc)(ProcFmt)) == 0)
98: return;
99: pattern = do_ask("\r\n", (int (*)()) 0, (char *) 0, ": %f %s ", d->Name);
100: if (pattern != 0)
101: for (i = 0; i < ExecIndex; i++)
102: if ((AutoExecs[i].a_cmd == d) &&
103: (strcmp(pattern, AutoExecs[i].a_pattern) == 0))
104: return; /* eliminate duplicates */
105: AutoExecs[ExecIndex].a_pattern = copystr(pattern);
106: AutoExecs[ExecIndex].a_cmd = d;
107: ExecIndex += 1;
108: }
109:
110: /* DoAutoExec: NEW and OLD are file names, and if NEW and OLD aren't the
111: same kind of file (i.e., match the same pattern) or OLD is 0 and it
112: matches, OR if the pattern is 0 (none was specified) then, we execute
113: the command associated with that kind of file. */
114:
115: void
116: DoAutoExec(new, old)
117: register char *new,
118: *old;
119: {
120: register int i;
121:
122: set_arg_value(1);
123: for (i = 0; i < ExecIndex; i++)
124: if ((AutoExecs[i].a_pattern == 0) ||
125: ((new != 0 && LookingAt(AutoExecs[i].a_pattern, new, 0)) &&
126: (old == 0 || !LookingAt(AutoExecs[i].a_pattern, old, 0))))
127: ExecCmd(AutoExecs[i].a_cmd);
128: }
129:
130: void
131: BindAKey()
132: {
133: BindSomething(findcom);
134: }
135:
136: void
137: BindMac()
138: {
139: BindSomething(findmac);
140: }
141:
142: extern void EscPrefix(),
143: CtlxPrefix(),
144: MiscPrefix();
145:
146: data_obj **
147: IsPrefix(cp)
148: data_obj *cp;
149: {
150: #ifdef MAC
151: void (*proc)();
152: #else
153: int (*proc)();
154: #endif
155:
156: if (cp == 0 || (cp->Type & TYPEMASK) != FUNCTION)
157: return 0;
158: proc = ((struct cmd *) cp)->c_proc;
159: if (proc == EscPrefix)
160: return pref1map;
161: if (proc == CtlxPrefix)
162: return pref2map;
163: if (proc == MiscPrefix)
164: return miscmap;
165: return 0;
166: }
167:
168: void
169: UnbindC()
170: {
171: char *keys;
172: data_obj **map = mainmap;
173:
174: keys = ask((char *) 0, ProcFmt);
175: for (;;) {
176: if (keys[1] == '\0')
177: break;
178: if ((map = IsPrefix(map[*keys])) == 0)
179: break;
180: keys += 1;
181: }
182: if (keys[1] != 0)
183: complain("That's not a legitimate key sequence.");
184: map[keys[0]] = 0;
185: }
186:
187: int
188: addgetc()
189: {
190: int c;
191:
192: if (!InJoverc) {
193: Asking = strlen(mesgbuf);
194: c = getch();
195: Asking = 0;
196: add_mess("%p ", c);
197: } else {
198: c = getch();
199: if (c == '\n')
200: return EOF; /* this isn't part of the sequence */
201: else if (c == '\\') {
202: if ((c = getch()) == LF)
203: complain("[Premature end of line]");
204: } else if (c == '^') {
205: if ((c = getch()) == '?')
206: c = RUBOUT;
207: else if (isalpha(c) || index("@[\\]^_", c))
208: c = CTL(c);
209: else
210: complain("[Unknown control character]");
211: }
212: }
213: return c;
214: }
215:
216: void
217: BindWMap(map, lastkey, cmd)
218: data_obj **map,
219: *cmd;
220: {
221: data_obj **nextmap;
222: int c;
223:
224: c = addgetc();
225: if (c == EOF) {
226: if (lastkey == EOF)
227: complain("[Empty key sequence]");
228: complain("[Premature end of key sequence]");
229: } else {
230: if (nextmap = IsPrefix(map[c]))
231: BindWMap(nextmap, c, cmd);
232: else {
233: map[c] = cmd;
234: #ifdef MAC
235: ((struct cmd *) cmd)->c_key = c; /* see about_j() in mac.c */
236: if(map == mainmap) ((struct cmd *) cmd)->c_map = F_MAINMAP;
237: else if(map == pref1map) ((struct cmd *) cmd)->c_map = F_PREF1MAP;
238: else if(map == pref2map) ((struct cmd *) cmd)->c_map = F_PREF2MAP;
239: #endif
240: }
241: }
242: }
243:
244: /* VARARGS0 */
245:
246: void
247: BindSomething(proc)
248: #ifdef LINT_ARGS
249: data_obj *(*proc)(char *);
250: #else
251: data_obj *(*proc)();
252: #endif
253: {
254: data_obj *d;
255:
256: if ((d = (*proc)(ProcFmt)) == 0)
257: return;
258: s_mess(": %f %s ", d->Name);
259: BindWMap(mainmap, EOF, d);
260: }
261:
262: /* Describe key */
263:
264: void
265: DescWMap(map, key)
266: data_obj **map;
267: {
268: data_obj *cp = map[key],
269: **prefp;
270:
271: if (cp == 0)
272: add_mess("is unbound.");
273: else if (prefp = IsPrefix(cp))
274: DescWMap(prefp, addgetc());
275: else
276: add_mess("is bound to %s.", cp->Name);
277: }
278:
279: void
280: KeyDesc()
281: {
282: s_mess(ProcFmt);
283: DescWMap(mainmap, addgetc());
284: }
285:
286: void
287: DescCom()
288: {
289: data_obj *dp;
290: char pattern[100],
291: doc_type[40],
292: *the_type,
293: *file = CmdDb;
294: File *fp;
295: int is_var;
296:
297: if (!strcmp(LastCmd->Name, "describe-variable")) {
298: dp = (data_obj *) findvar(ProcFmt);
299: the_type = "Variable";
300: is_var = YES;
301: } else {
302: dp = (data_obj *) findcom(ProcFmt);
303: the_type = "Command";
304: is_var = NO;
305: }
306: if (dp == 0)
307: return;
308: fp = open_file(file, iobuff, F_READ, COMPLAIN, QUIET);
309: Placur(ILI, 0);
310: flusho();
311: sprintf(pattern, "^:entry \"%s\" \"\\([^\"]*\\)\"", dp->Name);
312: TOstart("Help", TRUE);
313: for (;;) {
314: if (f_gets(fp, genbuf, LBSIZE) == EOF) {
315: Typeout("There is no documentation for \"%s\".", dp->Name);
316: goto outahere;
317: }
318: if ((strncmp(genbuf, ":entry", 6) == 0) &&
319: (LookingAt(pattern, genbuf, 0))) {
320: char type[64];
321:
322: putmatch(1, type, sizeof type);
323: if (strcmp(type, the_type) == 0)
324: break;
325: }
326: }
327: /* found it ... let's print it */
328: putmatch(1, doc_type, sizeof doc_type);
329: if (is_var == YES)
330: Typeout(dp->Name);
331: else {
332: char binding[128];
333:
334: find_binds(dp, binding);
335: if (blnkp(binding))
336: Typeout("To invoke %s, type \"ESC X %s<cr>\".",
337: dp->Name,
338: dp->Name);
339: else
340: Typeout("Type \"%s\" to invoke %s.", binding, dp->Name);
341: }
342: Typeout("");
343: while (f_gets(fp, genbuf, LBSIZE) != EOF)
344: if (strncmp(genbuf, ":entry", 6) == 0)
345: goto outahere;
346: else
347: Typeout("%s", genbuf);
348: outahere:
349: f_close(fp);
350: TOstop();
351: }
352:
353: void
354: DescBindings()
355: {
356: extern void Typeout();
357:
358: TOstart("Key Bindings", TRUE);
359: DescMap(mainmap, NullStr);
360: TOstop();
361: }
362:
363: extern int specialmap;
364:
365: void
366: DescMap(map, pref)
367: data_obj **map;
368: char *pref;
369: {
370: int c1,
371: c2 = 0,
372: numbetween;
373: char keydescbuf[40];
374: data_obj **prefp;
375:
376: #ifdef IBMPC
377: specialmap = (map == miscmap);
378: #endif
379:
380: for (c1 = 0; c1 < NCHARS && c2 < NCHARS; c1 = c2 + 1) {
381: c2 = c1;
382: if (map[c1] == 0)
383: continue;
384: while (++c2 < NCHARS && map[c1] == map[c2])
385: ;
386: c2 -= 1;
387: numbetween = c2 - c1;
388: if (numbetween == 1)
389: sprintf(keydescbuf, "%s {%p,%p}", pref, c1, c2);
390: else if (numbetween == 0)
391: sprintf(keydescbuf, "%s %p", pref, c1);
392: else
393: sprintf(keydescbuf, "%s [%p-%p]", pref, c1, c2);
394: if ((prefp = IsPrefix(map[c1])) && (prefp != map))
395: DescMap(prefp, keydescbuf);
396: else
397: Typeout("%-18s%s", keydescbuf, map[c1]->Name);
398: }
399: }
400:
401: private void
402: find_binds(dp, buf)
403: data_obj *dp;
404: char *buf;
405: {
406: char *endp;
407:
408: buf[0] = '\0';
409: fb_aux(dp, mainmap, (char *) 0, buf);
410: endp = buf + strlen(buf) - 2;
411: if ((endp > buf) && (strcmp(endp, ", ") == 0))
412: *endp = '\0';
413: }
414:
415: private void
416: fb_aux(cp, map, prefix, buf)
417: register data_obj *cp,
418: **map;
419: char *buf,
420: *prefix;
421: {
422: int c1,
423: c2;
424: char *bufp = buf + strlen(buf),
425: prefbuf[20];
426: data_obj **prefp;
427:
428: #ifdef IBMPC
429: specialmap = (map == miscmap);
430: #endif
431:
432: for (c1 = c2 = 0; c1 < NCHARS && c2 < NCHARS; c1 = c2 + 1) {
433: c2 = c1;
434: if (map[c1] == cp) {
435: while (++c2 < NCHARS && map[c1] == map[c2])
436: ;
437: c2 -= 1;
438: if (prefix)
439: sprintf(bufp, "%s ", prefix);
440: bufp += strlen(bufp);
441: switch (c2 - c1) {
442: case 0:
443: sprintf(bufp, "%p, ", c1);
444: break;
445:
446: case 1:
447: sprintf(bufp, "{%p,%p}, ", c1, c2);
448: break;
449:
450: default:
451: sprintf(bufp, "[%p-%p], ", c1, c2);
452: break;
453: }
454: }
455: if ((prefp = IsPrefix(map[c1])) && (prefp != map)) {
456: sprintf(prefbuf, "%p", c1);
457: fb_aux(cp, prefp, prefbuf, bufp);
458: }
459: bufp += strlen(bufp);
460: }
461: }
462:
463: void
464: Apropos()
465: {
466: register struct cmd *cp;
467: register struct macro *m;
468: register struct variable *v;
469: char *ans;
470: int anyfs = NO,
471: anyvs = NO,
472: anyms = NO;
473: char buf[256];
474:
475: ans = ask((char *) 0, ": %f (keyword) ");
476: TOstart("Help", TRUE);
477: for (cp = commands; cp->Name != 0; cp++)
478: if (sindex(ans, cp->Name)) {
479: if (anyfs == 0) {
480: Typeout("Commands");
481: Typeout("--------");
482: }
483: find_binds((data_obj *) cp, buf);
484: if (buf[0])
485: Typeout(": %-35s(%s)", cp->Name, buf);
486: else
487: Typeout(": %s", cp->Name);
488: anyfs = YES;
489: }
490: if (anyfs)
491: Typeout(NullStr);
492: for (v = variables; v->Name != 0; v++)
493: if (sindex(ans, v->Name)) {
494: if (anyvs == 0) {
495: Typeout("Variables");
496: Typeout("---------");
497: }
498: anyvs = YES;
499: vpr_aux(v, buf);
500: Typeout(": set %-26s%s", v->Name, buf);
501: }
502: if (anyvs)
503: Typeout(NullStr);
504: for (m = macros; m != 0; m = m->m_nextm)
505: if (sindex(ans, m->Name)) {
506: if (anyms == 0) {
507: Typeout("Macros");
508: Typeout("------");
509: }
510: anyms = YES;
511: find_binds((data_obj *) m, buf);
512: if (buf[0])
513: Typeout(": %-35s(%s)", m->Name, buf);
514: else
515: Typeout(": %-35s%s", "execute-macro", m->Name);
516: }
517: TOstop();
518: }
519:
520: void
521: Extend()
522: {
523: data_obj *d;
524:
525: if (d = findcom(": "))
526: ExecCmd(d);
527: }
528:
529: /* Read a positive integer from CP. It must be in base BASE, and
530: complains if it isn't. If allints is nonzero, all the characters
531: in the string must be integers or we return -1; otherwise we stop
532: reading at the first nondigit. */
533:
534: int
535: chr_to_int(cp, base, allints, result)
536: register char *cp;
537: register int *result;
538: {
539: register int c;
540: int value = 0,
541: sign;
542:
543: if ((c = *cp) == '-') {
544: sign = -1;
545: cp += 1;
546: } else
547: sign = 1;
548: while (c = *cp++) {
549: if (!isdigit(c)) {
550: if (allints == YES)
551: return INT_BAD;
552: break;
553: }
554: c = c - '0';
555: if (c >= base)
556: complain("You must specify in base %d.", base);
557: value = value * base + c;
558: }
559: *result = value * sign;
560: return INT_OKAY;
561: }
562:
563: int
564: ask_int(prompt, base)
565: char *prompt;
566: int base;
567: {
568: char *val = ask((char *) 0, prompt);
569: int value;
570:
571: if (chr_to_int(val, base, YES, &value) == INT_BAD)
572: complain("That's not a number!");
573: return value;
574: }
575:
576: private void
577: vpr_aux(vp, buf)
578: register struct variable *vp;
579: char *buf;
580: {
581: switch (vp->v_flags & V_TYPEMASK) {
582: case V_BASE10:
583: sprintf(buf, "%d", *(vp->v_value));
584: break;
585:
586: case V_BASE8:
587: sprintf(buf, "%o", *(vp->v_value));
588: break;
589:
590: case V_BOOL:
591: sprintf(buf, (*(vp->v_value)) ? "on" : "off");
592: break;
593:
594: case V_STRING:
595: case V_FILENAME:
596: sprintf(buf, "%s", (char *) vp->v_value);
597: break;
598:
599: case V_CHAR:
600: sprintf(buf, "%p", *(vp->v_value));
601: break;
602: }
603: }
604:
605: void
606: PrVar()
607: {
608: struct variable *vp;
609: char prbuf[256];
610:
611: if ((vp = (struct variable *) findvar(ProcFmt)) == 0)
612: return;
613: vpr_aux(vp, prbuf);
614: s_mess(": %f %s => %s", vp->Name, prbuf);
615: }
616:
617: void
618: SetVar()
619: {
620: struct variable *vp;
621: char *prompt;
622:
623: if ((vp = (struct variable *) findvar(ProcFmt)) == 0)
624: return;
625: prompt = sprint(": %f %s ", vp->Name);
626:
627: switch (vp->v_flags & V_TYPEMASK) {
628: case V_BASE10:
629: case V_BASE8:
630: {
631: int value;
632:
633: value = ask_int(prompt, ((vp->v_flags & V_TYPEMASK) == V_BASE10)
634: ? 10 : 8);
635: *(vp->v_value) = value;
636: break;
637: }
638:
639: case V_BOOL:
640: {
641: char *def = *(vp->v_value) ? "off" : "on",
642: *on_off;
643: int value;
644:
645: on_off = ask(def, prompt);
646: if (casecmp(on_off, "on") == 0)
647: value = ON;
648: else if (casecmp(on_off, "off") == 0)
649: value = OFF;
650: else
651: complain("Boolean variables must be ON or OFF.");
652: *(vp->v_value) = value;
653: #ifdef MAC
654: MarkVar(vp,-1,0); /* mark the menu item */
655: #endif
656: s_mess("%s%s", prompt, value ? "on" : "off");
657: break;
658: }
659:
660: case V_FILENAME:
661: {
662: char fbuf[FILESIZE];
663:
664: sprintf(&prompt[strlen(prompt)], "(default %s) ", vp->v_value);
665: (void) ask_file(prompt, (char *) vp->v_value, fbuf);
666: strcpy((char *) vp->v_value, fbuf);
667: break;
668: }
669:
670: case V_STRING:
671: {
672: char *str;
673:
674: /* Do_ask() so you can set string to "" if you so desire. */
675: str = do_ask("\r\n", (int (*)()) 0, (char *) vp->v_value, prompt);
676: if (str == 0)
677: str = NullStr;
678: strcpy((char *) vp->v_value, str);
679: /* ... and hope there is enough room. */
680: break;
681: }
682: case V_CHAR:
683: f_mess(prompt);
684: *(vp->v_value) = addgetc();
685: break;
686:
687: }
688: if (vp->v_flags & V_MODELINE)
689: UpdModLine = YES;
690: if (vp->v_flags & V_CLRSCREEN) {
691: #ifdef IBMPC
692: setcolor(Fgcolor, Bgcolor);
693: #endif /* IBMPC */
694: ClAndRedraw();
695: }
696: if (vp->v_flags & V_TTY_RESET)
697: tty_reset();
698: }
699:
700: /* Command completion - possible is an array of strings, prompt is
701: the prompt to use, and flags are ... well read jove.h.
702:
703: If flags are RET_STATE, and the user hits <return> what they typed
704: so far is in the Minibuf string. */
705:
706: private char **Possible;
707: private int comp_value,
708: comp_flags;
709:
710: int
711: aux_complete(c)
712: {
713: int command,
714: length,
715: i;
716:
717: if (comp_flags & CASEIND) {
718: char *lp;
719:
720: for (lp = linebuf; *lp != '\0'; lp++)
721: #if (defined(IBMPC) || defined(MAC))
722: lower(lp);
723: #else
724: if (isupper(*lp))
725: *lp = tolower(*lp);
726: #endif
727: }
728: switch (c) {
729: case EOF:
730: comp_value = -1;
731: return 0;
732:
733: case '\r':
734: case '\n':
735: command = match(Possible, linebuf);
736: if (command >= 0) {
737: comp_value = command;
738: return 0; /* tells ask to stop */
739: }
740: if (eolp() && bolp()) {
741: comp_value = NULLSTRING;
742: return 0;
743: }
744: if (comp_flags & RET_STATE) {
745: comp_value = command;
746: return 0;
747: }
748: if (InJoverc)
749: complain("[\"%s\" unknown]", linebuf);
750: rbell();
751: break;
752:
753: case '\t':
754: case ' ':
755: {
756: int minmatch = 1000,
757: maxmatch = 0,
758: numfound = 0,
759: lastmatch = -1,
760: length = strlen(linebuf);
761:
762: for (i = 0; Possible[i] != 0; i++) {
763: int this_len;
764:
765: this_len = numcomp(Possible[i], linebuf);
766: maxmatch = max(maxmatch, this_len);
767: if (this_len >= length) {
768: if (numfound)
769: minmatch = min(minmatch, numcomp(Possible[lastmatch], Possible[i]));
770: else
771: minmatch = strlen(Possible[i]);
772: numfound += 1;
773: lastmatch = i;
774: if (strcmp(linebuf, Possible[i]) == 0)
775: break;
776: }
777: }
778:
779: if (numfound == 0) {
780: rbell();
781: if (InJoverc)
782: complain("[\"%s\" unknown]", linebuf);
783: /* If we're not in the .joverc then
784: let's do something helpful for the
785: user. */
786: if (maxmatch < length) {
787: char *cp;
788:
789: cp = linebuf + maxmatch;
790: *cp = 0;
791: Eol();
792: }
793: break;
794: }
795: if (c != '\t' && numfound == 1) {
796: comp_value = lastmatch;
797: return 0;
798: }
799: null_ncpy(linebuf, Possible[lastmatch], minmatch);
800: Eol();
801: if (minmatch == length) /* No difference */
802: rbell();
803: break;
804: }
805:
806: case '?':
807: if (InJoverc)
808: complain((char *) 0);
809: /* kludge: in case we're using UseBuffers, in which case
810: linebuf gets written all over */
811: strcpy(Minibuf, linebuf);
812: length = strlen(Minibuf);
813: TOstart("Completion", TRUE); /* for now ... */
814: for (i = 0; Possible[i]; i++)
815: if (numcomp(Possible[i], Minibuf) >= length) {
816: Typeout(Possible[i]);
817: if (TOabort != 0)
818: break;
819: }
820:
821: TOstop();
822: break;
823: }
824: return !FALSE;
825: }
826:
827: int
828: complete(possible, prompt, flags)
829: register char *possible[];
830: char *prompt;
831: {
832: Possible = possible;
833: comp_flags = flags;
834: (void) do_ask("\r\n \t?", aux_complete, NullStr, prompt);
835: return comp_value;
836: }
837:
838: int
839: match(choices, what)
840: register char **choices,
841: *what;
842: {
843: register int len;
844: int i,
845: found = 0,
846: save,
847: exactmatch = -1;
848:
849: len = strlen(what);
850: if (len == 0)
851: return NULLSTRING;
852: for (i = 0; choices[i]; i++) {
853: if (strncmp(what, choices[i], len) == 0) {
854: if (strcmp(what, choices[i]) == 0)
855: exactmatch = i;
856: save = i;
857: found += 1; /* found one */
858: }
859: }
860:
861: if (found == 0)
862: save = ORIGINAL;
863: else if (found > 1) {
864: if (exactmatch != -1)
865: save = exactmatch;
866: else
867: save = AMBIGUOUS;
868: }
869:
870: return save;
871: }
872:
873: void
874: Source()
875: {
876: char *com, *getenv(),
877: buf[FILESIZE];
878:
879: #ifndef MSDOS
880: sprintf(buf, "%s/.joverc", getenv("HOME"));
881: #else /* MSDOS */
882: if (com = getenv("JOVERC"))
883: strcpy(buf, com);
884: else
885: strcpy(buf, Joverc);
886: #endif /* MSDOS */
887: com = ask_file((char *) 0, buf, buf);
888: if (joverc(buf) == 0)
889: complain(IOerr("read", com));
890: }
891:
892: void
893: BufPos()
894: {
895: register Line *lp = curbuf->b_first;
896: register int i,
897: dotline;
898: long dotchar,
899: nchars;
900:
901: for (i = nchars = 0; lp != 0; i++, lp = lp->l_next) {
902: if (lp == curline) {
903: dotchar = nchars + curchar;
904: dotline = i + 1;
905: }
906: nchars += length(lp) + (lp->l_next != 0); /* include the NL */
907: }
908:
909: s_mess("[\"%s\" line %d/%d, char %D/%D (%d%%), cursor = %d/%d]",
910: filename(curbuf), dotline, i, dotchar, nchars,
911: (nchars == 0) ? 100 : (int) (((long) dotchar * 100) / nchars),
912: calc_pos(linebuf, curchar),
913: calc_pos(linebuf, strlen(linebuf)));
914: }
915:
916: #define IF_UNBOUND -1
917: #define IF_TRUE 1
918: #define IF_FALSE !IF_TRUE
919:
920: #ifndef MAC
921: int
922: do_if(cmd)
923: char *cmd;
924: {
925: #ifdef MSDOS
926: int status;
927: #else
928: int pid,
929: status;
930: #endif /* MSDOS */
931: #ifndef MSDOS
932:
933: switch (pid = fork()) {
934: case -1:
935: complain("[Fork failed: if]");
936:
937: case 0:
938: {
939: #endif /* MSDOS */
940: char *args[12],
941: *cp = cmd,
942: **ap = args;
943:
944: *ap++ = cmd;
945: for (;;) {
946: if ((cp = index(cp, ' ')) == 0)
947: break;
948: *cp++ = '\0';
949: *ap++ = cp;
950: }
951: *ap = 0;
952:
953: #ifndef MSDOS
954: close(0); /* we want reads to fail */
955: /* close(1); but not writes or ioctl's
956: close(2); */
957: #else /* MSDOS */
958: if ((status = spawnvp(0, args[0], args)) < 0)
959: complain("[Spawn failed: if]");
960: #endif /* MSDOS */
961:
962: #ifndef MSDOS
963: (void) execvp(args[0], args);
964: _exit(-10); /* signals exec error (see below) */
965: }
966: }
967: #ifdef IPROCS
968: sighold(SIGCHLD);
969: #endif
970: dowait(pid, &status);
971: #ifdef IPROCS
972: sigrelse(SIGCHLD);
973: #endif
974: if (status == -10)
975: complain("[Exec failed]");
976: if (status < 0)
977: complain("[Exit %d]", status);
978: #endif /* MSDOS */
979: return (status == 0); /* 0 means successful */
980: }
981: #endif /* MAC */
982:
983: int
984: joverc(file)
985: char *file;
986: {
987: char buf[LBSIZE],
988: lbuf[LBSIZE];
989: int lnum = 0,
990: eof = FALSE;
991: jmp_buf savejmp;
992: int IfStatus = IF_UNBOUND;
993: File *fp;
994:
995: fp = open_file(file, buf, F_READ, !COMPLAIN, QUIET);
996: if (fp == NIL)
997: return NO; /* joverc returns an integer */
998:
999: /* Catch any errors, here, and do the right thing with them,
1000: and then restore the error handle to whoever did a setjmp
1001: last. */
1002:
1003: InJoverc += 1;
1004: push_env(savejmp);
1005: if (setjmp(mainjmp)) {
1006: Buffer *savebuf = curbuf;
1007:
1008: SetBuf(do_select((Window *) 0, "RC errors"));
1009: ins_str(sprint("%s:%d:%s\t%s\n", pr_name(file, YES), lnum, lbuf, mesgbuf), NO);
1010: unmodify();
1011: SetBuf(savebuf);
1012: Asking = 0;
1013: }
1014: if (!eof) do {
1015: eof = (f_gets(fp, lbuf, sizeof lbuf) == EOF);
1016: lnum += 1;
1017: if (lbuf[0] == '#') /* a comment */
1018: continue;
1019: #ifndef MAC
1020: if (casencmp(lbuf, "if", 2) == 0) {
1021: char cmd[128];
1022:
1023: if (IfStatus != IF_UNBOUND)
1024: complain("[Cannot have nested if's]");
1025: if (LookingAt("if[ \t]*\\(.*\\)$", lbuf, 0) == 0)
1026: complain("[If syntax error]");
1027: putmatch(1, cmd, sizeof cmd);
1028: IfStatus = do_if(cmd) ? IF_TRUE : IF_FALSE;
1029: continue;
1030: } else if (casencmp(lbuf, "else", 4) == 0) {
1031: if (IfStatus == IF_UNBOUND)
1032: complain("[Unexpected `else']");
1033: IfStatus = !IfStatus;
1034: continue;
1035: } else if (casencmp(lbuf, "endif", 5) == 0) {
1036: if (IfStatus == IF_UNBOUND)
1037: complain("[Unexpected `endif']");
1038: IfStatus = IF_UNBOUND;
1039: continue;
1040: }
1041: #endif
1042: if (IfStatus == IF_FALSE)
1043: continue;
1044: (void) strcat(lbuf, "\n");
1045: Inputp = lbuf;
1046: while (*Inputp == ' ' || *Inputp == '\t')
1047: Inputp += 1; /* skip white space */
1048: Extend();
1049: } while (!eof);
1050:
1051: f_close(fp);
1052: pop_env(savejmp);
1053: Inputp = 0;
1054: Asking = 0;
1055: InJoverc -= 1;
1056: if (IfStatus != IF_UNBOUND)
1057: complain("[Missing endif]");
1058: return 1;
1059: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.