![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tclHistory.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / worm / scsi / tcl|
Return to tclHistory.c CVS log | Up to [Research Unix] / researchv10no / cmd / worm / scsi / tcl |
1.1 root 1: /*
2: * tclHistory.c --
3: *
4: * This module implements history as an optional addition to Tcl.
5: * It can be called to record commands ("events") before they are
6: * executed, and it provides a command that may be used to perform
7: * history substitutions.
8: *
9: * Copyright 1990 Regents of the University of California
10: * Permission to use, copy, modify, and distribute this
11: * software and its documentation for any purpose and without
12: * fee is hereby granted, provided that the above copyright
13: * notice appear in all copies. The University of California
14: * makes no representations about the suitability of this
15: * software for any purpose. It is provided "as is" without
16: * express or implied warranty.
17: */
18:
19: #ifndef lint
20: static char rcsid[] = "$Header: /sprite/src/lib/tcl/RCS/tclHistory.c,v 1.6 90/03/29 13:20:04 ouster Exp $ SPRITE (Berkeley)";
21: #pragma ref rcsid
22: #endif not lint
23:
24: #define _POSIX_SOURCE
25:
26: #include "tclInt.h"
27: #include <ctype.h>
28: #include <stdio.h>
29: #include <stdlib.h>
30: #include <string.h>
31:
32: /*
33: * This history stuff is mostly straightforward, except for one thing
34: * that makes everything very complicated. Suppose that the following
35: * commands get executed:
36: * echo foo
37: * history redo
38: * It's important that the history event recorded for the second command
39: * be "echo foo", not "history redo". Otherwise, if another "history redo"
40: * command is typed, it will result in infinite recursions on the
41: * "history redo" command. Thus, the actual recorded history must be
42: * echo foo
43: * echo foo
44: * To do this, the history command revises recorded history as part of
45: * its execution. In the example above, when "history redo" starts
46: * execution, the current event is "history redo", but the history
47: * command arranges for the current event to be changed to "echo foo".
48: *
49: * There are three additional complications. The first is that history
50: * substitution may only be part of a command, as in the following
51: * command sequence:
52: * echo foo bar
53: * echo [history word 3]
54: * In this case, the second event should be recorded as "echo bar". Only
55: * part of the recorded event is to be modified. Fortunately, Tcl_Eval
56: * helps with this by recording (in the evalFirst and evalLast fields of
57: * the intepreter) the location of the command being executed, so the
58: * history module can replace exactly the range of bytes corresponding
59: * to the history substitution command.
60: *
61: * The second complication is that there are two ways to revise history:
62: * replace a command, and replace the result of a command. Consider the
63: * two examples below:
64: * format {result is %d} $num | format {result is %d} $num
65: * print [history redo] | print [history word 3]
66: * Recorded history for these two cases should be as follows:
67: * format {result is %d} $num | format {result is %d} $num
68: * print [format {result is %d} $num] | print $num
69: * In the left case, the history command was replaced with another command
70: * to be executed (the brackets were retained), but in the case on the
71: * right the result of executing the history command was replaced (i.e.
72: * brackets were replaced too).
73: *
74: * The third complication is that there could potentially be many
75: * history substitutions within a single command, as in:
76: * echo [history word 3] [history word 2]
77: * There could even be nested history substitutions, as in:
78: * history subs abc [history word 2]
79: * If history revisions were made immediately during each "history" command
80: * invocations, it would be very difficult to produce the correct cumulative
81: * effect from several substitutions in the same command. To get around
82: * this problem, the actual history revision isn't made during the execution
83: * of the "history" command. Information about the changes is just recorded,
84: * in xxx records, and the actual changes are made during the next call to
85: * Tcl_RecordHistory (when we know that execution of the previous command
86: * has finished).
87: */
88:
89: /*
90: * Default space allocation for command strings:
91: */
92:
93: #define INITIAL_CMD_SIZE 40
94:
95: /*
96: * Forward declarations for procedures defined later in this file:
97: */
98:
99: static void DisableRevs();
100: static void DoRevs();
101: static HistoryEvent * GetEvent();
102: static char * GetWords();
103: static void HistoryInit();
104: static void InsertRev();
105: static void MakeSpace();
106: static void RevCommand();
107: static void RevResult();
108: static int SubsAndEval();
109:
110: /*
111: *----------------------------------------------------------------------
112: *
113: * Tcl_RecordAndEval --
114: *
115: * This procedure adds its command argument to the current list of
116: * recorded events and then executes the command by calling Tcl_Eval.
117: *
118: * Results:
119: * The return value is a standard Tcl return value, the result of
120: * executing cmd.
121: *
122: * Side effects:
123: * The command is recorded and executed. In addition, pending history
124: * revisions are carried out, and information is set up to enable
125: * Tcl_Eval to identify history command ranges. This procedure also
126: * initializes history information for the interpreter, if it hasn't
127: * already been initialized.
128: *
129: *----------------------------------------------------------------------
130: */
131:
132: int
133: Tcl_RecordAndEval(interp, cmd, flags)
134: Tcl_Interp *interp; /* Token for interpreter in which command
135: * will be executed. */
136: char *cmd; /* Command to record. */
137: int flags; /* Additional flags to pass to Tcl_Eval.
138: * TCL_NO_EVAL means only record: don't
139: * execute command. */
140: {
141: register Interp *iPtr = (Interp *) interp;
142: register HistoryEvent *eventPtr;
143: char *savedFirst;
144: int length, result;
145:
146: if (iPtr->numEvents == 0) {
147: HistoryInit(iPtr, 20);
148: }
149: DoRevs(iPtr);
150:
151: /*
152: * Don't record empty commands.
153: */
154:
155: while (isspace(*cmd)) {
156: cmd++;
157: }
158: if (*cmd == '\0') {
159: Tcl_Return(interp, (char *) NULL, TCL_STATIC);
160: return TCL_OK;
161: }
162:
163: iPtr->curEventNum++;
164: iPtr->curEvent++;
165: if (iPtr->curEvent >= iPtr->numEvents) {
166: iPtr->curEvent = 0;
167: }
168: eventPtr = &iPtr->events[iPtr->curEvent];
169:
170: /*
171: * Chop off trailing newlines before recording the command.
172: */
173:
174: length = strlen(cmd);
175: while (cmd[length-1] == '\n') {
176: length--;
177: }
178: MakeSpace(eventPtr, length + 1);
179: strncpy(eventPtr->command, cmd, length);
180: eventPtr->command[length] = 0;
181:
182: if (flags == -1) {
183: return TCL_OK;
184: }
185:
186: /*
187: * Execute the command.
188: */
189:
190: savedFirst = iPtr->historyFirst;
191: iPtr->historyFirst = cmd;
192: result = Tcl_Eval(interp, cmd, flags | TCL_RECORD_BOUNDS, (char **) NULL);
193: iPtr->historyFirst = savedFirst;
194: return result;
195: }
196:
197: /*
198: *----------------------------------------------------------------------
199: *
200: * Tcl_HistoryCmd --
201: *
202: * This procedure is invoked to process the "history" Tcl command.
203: * See the user documentation for details on what it does.
204: *
205: * Results:
206: * A standard Tcl result.
207: *
208: * Side effects:
209: * See the user documentation.
210: *
211: *----------------------------------------------------------------------
212: */
213:
214: /* ARGSUSED */
215: int
216: Tcl_HistoryCmd(dummy, interp, argc, argv)
217: ClientData dummy; /* Not used. */
218: Tcl_Interp *interp; /* Current interpreter. */
219: int argc; /* Number of arguments. */
220: char **argv; /* Argument strings. */
221: {
222: #pragma ref dummy
223: register Interp *iPtr = (Interp *) interp;
224: register HistoryEvent *eventPtr;
225: int length;
226: char c;
227:
228: /*
229: * If no arguments, redo last command.
230: */
231:
232: if (argc == 1) {
233: eventPtr = GetEvent(iPtr, "-1");
234: if (eventPtr == NULL) {
235: return TCL_ERROR;
236: }
237: RevCommand(iPtr, eventPtr->command);
238: return Tcl_Eval(interp, eventPtr->command, 0, (char **) NULL);
239: }
240:
241: c = argv[1][0];
242: length = strlen(argv[1]);
243:
244: if ((c == 'a') && (strncmp(argv[1], "add", length)) == 0) {
245: if ((argc != 3) && (argc != 4)) {
246: sprintf(iPtr->result,
247: "wrong # args: should be \"%.50s add event [exec]\"",
248: argv[0]);
249: return TCL_ERROR;
250: }
251: if (argc == 4) {
252: if (strncmp(argv[3], "exec", strlen(argv[3])) != 0) {
253: sprintf(iPtr->result,
254: "bad arg \"%.50s\": should be \"exec\"", argv[3]);
255: return TCL_ERROR;
256: }
257: return Tcl_RecordAndEval(interp, argv[2], 0);
258: }
259: return Tcl_RecordAndEval(interp, argv[2], -1);
260: } else if ((c == 'c') && (strncmp(argv[1], "change", length)) == 0) {
261: if ((argc != 3) && (argc != 4)) {
262: sprintf(iPtr->result, "wrong # args: should be \"%.50s change newValue [event]\"",
263: argv[0]);
264: return TCL_ERROR;
265: }
266: if (argc == 3) {
267: eventPtr = &iPtr->events[iPtr->curEvent];
268: DisableRevs(iPtr);
269: } else {
270: eventPtr = GetEvent(iPtr, argv[3]);
271: if (eventPtr == NULL) {
272: return TCL_ERROR;
273: }
274: }
275: MakeSpace(eventPtr, strlen(argv[2]) + 1);
276: strcpy(eventPtr->command, argv[2]);
277: return TCL_OK;
278: } else if ((c == 'e') && (strncmp(argv[1], "event", length)) == 0) {
279: if (argc > 3) {
280: sprintf(iPtr->result,
281: "too many args: should be \"%.50s event [event]\"",
282: argv[0]);
283: return TCL_ERROR;
284: }
285: eventPtr = GetEvent(iPtr, argc==2 ? "-1" : argv[2]);
286: if (eventPtr == NULL) {
287: return TCL_ERROR;
288: }
289: RevResult(iPtr, eventPtr->command);
290: Tcl_Return(interp, eventPtr->command, TCL_VOLATILE);
291: return TCL_OK;
292: } else if ((c == 'i') && (strncmp(argv[1], "info", length)) == 0) {
293: char *p;
294: int count, indx, i;
295:
296: if ((argc != 2) && (argc != 3)) {
297: sprintf(iPtr->result,
298: "wrong # args: should be \"%.50s info [count]\"",
299: argv[0]);
300: return TCL_ERROR;
301: }
302: if (argc == 3) {
303: char *end;
304:
305: count = strtoul(argv[2], &end, 0);
306: if (end == argv[2]) {
307: sprintf(iPtr->result, "bad count \"%.50s\"", argv[2]);
308: return TCL_ERROR;
309: }
310: if (count > iPtr->numEvents) {
311: count = iPtr->numEvents;
312: }
313: } else {
314: count = iPtr->numEvents;
315: }
316: length = 0;
317: for (i = 0, indx = iPtr->curEvent + 1 + iPtr->numEvents - count;
318: i < count; i++, indx++) {
319: if (indx >= iPtr->numEvents) {
320: indx -= iPtr->numEvents;
321: }
322: p = iPtr->events[indx].command;
323: length += 9 + strlen(p);
324: while (1) {
325: p = strchr(p, '\n');
326: if (p == NULL) {
327: break;
328: }
329: length++;
330: p++;
331: }
332: length += 9 + strlen(iPtr->events[indx].command);
333: }
334: p = malloc((unsigned) (length+1));
335: iPtr->result = p;
336: iPtr->dynamic = 1;
337: for (i = 0, indx = iPtr->curEvent + 1 + iPtr->numEvents - count;
338: i < count; i++, indx++) {
339: char *cur, *next;
340: int length;
341:
342: if (indx >= iPtr->numEvents) {
343: indx -= iPtr->numEvents;
344: }
345: cur = iPtr->events[indx].command;
346: if (*cur == '\0') {
347: continue; /* No command recorded here. */
348: }
349: sprintf(p, "%6d ", iPtr->curEventNum + 1 - (count - i));
350: p += 8;
351:
352: /*
353: * Tricky formatting here: for multi-line commands, indent
354: * the continuation lines.
355: */
356:
357: while (1) {
358: next = strchr(cur, '\n');
359: if (next == NULL) {
360: break;
361: }
362: length = next+1-cur;
363: strncpy(p, cur,length);
364: cur += length;
365: p += length;
366: *p = '\t';
367: p++;
368: }
369: strcpy(p, cur);
370: p += strlen(p);
371: *p = '\n';
372: p++;
373: }
374: p[-1] = '\0';
375: return TCL_OK;
376: } else if ((c == 'k') && (strncmp(argv[1], "keep", length)) == 0) {
377: int count, i, src;
378: char *end;
379: HistoryEvent *events;
380:
381: if (argc != 3) {
382: sprintf(iPtr->result,
383: "wrong # args: should be \"%.50s keep number\"",
384: argv[0]);
385: return TCL_ERROR;
386: }
387: count = strtoul(argv[2], &end, 0);
388: if ((end == argv[2]) || (count > 1000) || (count == 0)) {
389: sprintf(iPtr->result, "bad number \"%.50s\"", argv[2]);
390: return TCL_ERROR;
391: }
392:
393: /*
394: * Create a new history array and copy as much existing history
395: * as possible from the old array.
396: */
397:
398: events = (HistoryEvent *)
399: malloc((unsigned) (count * sizeof(HistoryEvent)));
400: if (count < iPtr->numEvents) {
401: src = iPtr->curEvent + 1 - count;
402: if (src < 0) {
403: src += iPtr->numEvents;
404: }
405: } else {
406: src = iPtr->curEvent + 1;
407: }
408: for (i = 0; i < count; i++, src++) {
409: if (src >= iPtr->numEvents) {
410: src = 0;
411: }
412: if (i < iPtr->numEvents) {
413: events[i] = iPtr->events[src];
414: iPtr->events[src].command = NULL;
415: } else {
416: events[i].command = malloc(INITIAL_CMD_SIZE);
417: events[i].command[0] = 0;
418: events[i].bytesAvl = INITIAL_CMD_SIZE;
419: }
420: }
421:
422: /*
423: * Throw away everything left in the old history array, and
424: * substitute the new one for the old one.
425: */
426:
427: for (i = 0; i < iPtr->numEvents; i++) {
428: if (iPtr->events[i].command != NULL) {
429: free(iPtr->events[i].command);
430: }
431: }
432: free((char *) iPtr->events);
433: iPtr->events = events;
434: if (count < iPtr->numEvents) {
435: iPtr->curEvent = count-1;
436: } else {
437: iPtr->curEvent = iPtr->numEvents-1;
438: }
439: iPtr->numEvents = count;
440: return TCL_OK;
441: } else if ((c == 'n') && (strncmp(argv[1], "nextid", length)) == 0) {
442: if (argc != 2) {
443: sprintf(iPtr->result, "wrong # args: should be \"%.50s nextid\"",
444: argv[0]);
445: return TCL_ERROR;
446: }
447: sprintf(iPtr->result, "%d", iPtr->curEventNum+1);
448: return TCL_OK;
449: } else if ((c == 'r') && (strncmp(argv[1], "redo", length)) == 0) {
450: if (argc > 3) {
451: sprintf(iPtr->result,
452: "too many args: should be \"%.50s redo [event]\"",
453: argv[0]);
454: return TCL_ERROR;
455: }
456: eventPtr = GetEvent(iPtr, argc==2 ? "-1" : argv[2]);
457: if (eventPtr == NULL) {
458: return TCL_ERROR;
459: }
460: RevCommand(iPtr, eventPtr->command);
461: return Tcl_Eval(interp, eventPtr->command, 0, (char **) NULL);
462: } else if ((c == 's') && (strncmp(argv[1], "substitute", length)) == 0) {
463: if ((argc > 5) || (argc < 4)) {
464: sprintf(iPtr->result, "wrong # args: should be \"%.50s substitute old new [event]\"",
465: argv[0]);
466: return TCL_ERROR;
467: }
468: eventPtr = GetEvent(iPtr, argc==4 ? "-1" : argv[4]);
469: if (eventPtr == NULL) {
470: return TCL_ERROR;
471: }
472: return SubsAndEval(iPtr, eventPtr->command, argv[2], argv[3]);
473: } else if ((c == 'w') && (strncmp(argv[1], "words", length)) == 0) {
474: char *words;
475:
476: if ((argc != 3) && (argc != 4)) {
477: sprintf(iPtr->result, "wrong # args: should be \"%.50s words num-num/pat [event]\"",
478: argv[0]);
479: return TCL_ERROR;
480: }
481: eventPtr = GetEvent(iPtr, argc==3 ? "-1" : argv[3]);
482: if (eventPtr == NULL) {
483: return TCL_ERROR;
484: }
485: words = GetWords(iPtr, eventPtr->command, argv[2]);
486: if (words == NULL) {
487: return TCL_ERROR;
488: }
489: RevResult(iPtr, words);
490: iPtr->result = words;
491: iPtr->dynamic = 1;
492: return TCL_OK;
493: }
494:
495: sprintf(iPtr->result, "bad \"%.50s\" option \"%.50s\": must be add, change, event, info, keep, nextid, redo, substitute, or words",
496: argv[0], argv[1]);
497: return TCL_ERROR;
498: }
499:
500: /*
501: *----------------------------------------------------------------------
502: *
503: * HistoryInit --
504: *
505: * Initialize history-related state in an interpreter.
506: *
507: * Results:
508: * None.
509: *
510: * Side effects:
511: * History info is initialized in iPtr.
512: *
513: *----------------------------------------------------------------------
514: */
515:
516: static void
517: HistoryInit(iPtr, numEvents)
518: register Interp *iPtr; /* Interpreter to initialize. */
519: int numEvents; /* Number of events to retain at
520: * any given time. */
521: {
522: int i;
523:
524: iPtr->numEvents = numEvents;
525: iPtr->events = (HistoryEvent *)
526: malloc((unsigned) (numEvents * sizeof(HistoryEvent)));
527: for (i = 0; i < numEvents; i++) {
528: iPtr->events[i].command = malloc(INITIAL_CMD_SIZE);
529: *iPtr->events[i].command = 0;
530: iPtr->events[i].bytesAvl = INITIAL_CMD_SIZE;
531: }
532: iPtr->curEvent = 0;
533: iPtr->curEventNum = 0;
534: Tcl_CreateCommand((Tcl_Interp *) iPtr, "history", Tcl_HistoryCmd,
535: (ClientData) NULL, (void (*)()) NULL);
536: }
537:
538: /*
539: *----------------------------------------------------------------------
540: *
541: * MakeSpace --
542: *
543: * Given a history event, make sure it has enough space for
544: * a string of a given length (enlarge the string area if
545: * necessary).
546: *
547: * Results:
548: * None.
549: *
550: * Side effects:
551: * More memory may get allocated.
552: *
553: *----------------------------------------------------------------------
554: */
555:
556: static void
557: MakeSpace(hPtr, size)
558: HistoryEvent *hPtr;
559: int size; /* # of bytes needed in hPtr. */
560: {
561: if (hPtr->bytesAvl < size) {
562: free(hPtr->command);
563: hPtr->command = malloc((unsigned) size);
564: hPtr->bytesAvl = size;
565: }
566: }
567:
568: /*
569: *----------------------------------------------------------------------
570: *
571: * InsertRev --
572: *
573: * Add a new revision to the list of those pending for iPtr.
574: * Do it in a way that keeps the revision list sorted in
575: * increasing order of firstIndex. Also, eliminate revisions
576: * that are subsets of other revisions.
577: *
578: * Results:
579: * None.
580: *
581: * Side effects:
582: * RevPtr is added to iPtr's revision list.
583: *
584: *----------------------------------------------------------------------
585: */
586:
587: static void
588: InsertRev(iPtr, revPtr)
589: Interp *iPtr; /* Interpreter to use. */
590: register HistoryRev *revPtr; /* Revision to add to iPtr's list. */
591: {
592: register HistoryRev *curPtr;
593: register HistoryRev *prevPtr;
594:
595: for (curPtr = iPtr->revPtr, prevPtr = NULL; curPtr != NULL;
596: prevPtr = curPtr, curPtr = curPtr->nextPtr) {
597: /*
598: * If this revision includes the new one (or vice versa) then
599: * just eliminate the one that is a subset of the other.
600: */
601:
602: if ((revPtr->firstIndex <= curPtr->firstIndex)
603: && (revPtr->lastIndex >= curPtr->firstIndex)) {
604: curPtr->firstIndex = revPtr->firstIndex;
605: curPtr->lastIndex = revPtr->lastIndex;
606: curPtr->newSize = revPtr->newSize;
607: free(curPtr->newBytes);
608: curPtr->newBytes = revPtr->newBytes;
609: free((char *) revPtr);
610: return;
611: }
612: if ((revPtr->firstIndex >= curPtr->firstIndex)
613: && (revPtr->lastIndex <= curPtr->lastIndex)) {
614: free(revPtr->newBytes);
615: free((char *) revPtr);
616: return;
617: }
618:
619: if (revPtr->firstIndex < curPtr->firstIndex) {
620: break;
621: }
622: }
623:
624: /*
625: * Insert revPtr just after prevPtr.
626: */
627:
628: if (prevPtr == NULL) {
629: revPtr->nextPtr = iPtr->revPtr;
630: iPtr->revPtr = revPtr;
631: } else {
632: revPtr->nextPtr = prevPtr->nextPtr;
633: prevPtr->nextPtr = revPtr;
634: }
635: }
636:
637: /*
638: *----------------------------------------------------------------------
639: *
640: * RevCommand --
641: *
642: * This procedure is invoked by the "history" command to record
643: * a command revision. See the comments at the beginning of the
644: * file for more information about revisions.
645: *
646: * Results:
647: * None.
648: *
649: * Side effects:
650: * Revision information is recorded.
651: *
652: *----------------------------------------------------------------------
653: */
654:
655: static void
656: RevCommand(iPtr, string)
657: register Interp *iPtr; /* Interpreter in which to perform the
658: * substitution. */
659: char *string; /* String to substitute. */
660: {
661: register HistoryRev *revPtr;
662:
663: if ((iPtr->evalFirst == NULL) || (iPtr->historyFirst == NULL)) {
664: return;
665: }
666: revPtr = (HistoryRev *) malloc(sizeof(HistoryRev));
667: revPtr->firstIndex = iPtr->evalFirst - iPtr->historyFirst;
668: revPtr->lastIndex = iPtr->evalLast - iPtr->historyFirst - 1;
669: revPtr->newSize = strlen(string);
670: revPtr->newBytes = malloc((unsigned) (revPtr->newSize+1));
671: strcpy(revPtr->newBytes, string);
672: InsertRev(iPtr, revPtr);
673: }
674:
675: /*
676: *----------------------------------------------------------------------
677: *
678: * RevResult --
679: *
680: * This procedure is invoked by the "history" command to record
681: * a result revision. See the comments at the beginning of the
682: * file for more information about revisions.
683: *
684: * Results:
685: * None.
686: *
687: * Side effects:
688: * Revision information is recorded.
689: *
690: *----------------------------------------------------------------------
691: */
692:
693: static void
694: RevResult(iPtr, string)
695: register Interp *iPtr; /* Interpreter in which to perform the
696: * substitution. */
697: char *string; /* String to substitute. */
698: {
699: register HistoryRev *revPtr;
700: char *evalFirst, *evalLast;
701: char *argv[2];
702:
703: if ((iPtr->evalFirst == NULL) || (iPtr->historyFirst == NULL)) {
704: return;
705: }
706:
707: /*
708: * Expand the replacement range to include the brackets that surround
709: * the command. If there aren't any brackets (i.e. this command was
710: * invoked at top-level) then don't do any revision. Also, if there
711: * are several commands in brackets, of which this is just one,
712: * then don't do any revision.
713: */
714:
715: evalFirst = iPtr->evalFirst;
716: evalLast = iPtr->evalLast;
717: while (1) {
718: if (evalFirst == iPtr->historyFirst) {
719: return;
720: }
721: evalFirst--;
722: if (*evalFirst == '[') {
723: break;
724: }
725: if (!isspace(*evalFirst)) {
726: return;
727: }
728: }
729: if (*evalLast != ']') {
730: return;
731: }
732:
733: revPtr = (HistoryRev *) malloc(sizeof(HistoryRev));
734: revPtr->firstIndex = evalFirst - iPtr->historyFirst;
735: revPtr->lastIndex = evalLast - iPtr->historyFirst;
736: argv[0] = string;
737: revPtr->newBytes = Tcl_Merge(1, argv);
738: revPtr->newSize = strlen(revPtr->newBytes);
739: InsertRev(iPtr, revPtr);
740: }
741:
742: /*
743: *----------------------------------------------------------------------
744: *
745: * DoRevs --
746: *
747: * This procedure is called to apply the history revisions that
748: * have been recorded in iPtr.
749: *
750: * Results:
751: * None.
752: *
753: * Side effects:
754: * The most recent entry in the history for iPtr may be modified.
755: *
756: *----------------------------------------------------------------------
757: */
758:
759: static void
760: DoRevs(iPtr)
761: register Interp *iPtr; /* Interpreter whose history is to
762: * be modified. */
763: {
764: register HistoryRev *revPtr;
765: register HistoryEvent *eventPtr;
766: char *newCommand, *p;
767: unsigned int size;
768: int bytesSeen, count;
769:
770: if (iPtr->revPtr == NULL) {
771: return;
772: }
773:
774: /*
775: * The revision is done in two passes. The first pass computes the
776: * amount of space needed for the revised event, and the second pass
777: * pieces together the new event and frees up the revisions.
778: */
779:
780: eventPtr = &iPtr->events[iPtr->curEvent];
781: size = strlen(eventPtr->command);
782: for (revPtr = iPtr->revPtr; revPtr != NULL; revPtr = revPtr->nextPtr) {
783: size -= revPtr->lastIndex + 1 - revPtr->firstIndex;
784: size += revPtr->newSize;
785: }
786:
787: newCommand = malloc(size);
788: p = newCommand;
789: bytesSeen = 0;
790: for (revPtr = iPtr->revPtr; revPtr != NULL; revPtr = revPtr->nextPtr) {
791: count = revPtr->firstIndex - bytesSeen;
792: if (count > 0) {
793: strncpy(p, eventPtr->command + bytesSeen, count);
794: p += count;
795: }
796: strncpy(p, revPtr->newBytes, revPtr->newSize);
797: p += revPtr->newSize;
798: bytesSeen = revPtr->lastIndex+1;
799: free(revPtr->newBytes);
800: free((char *) revPtr);
801: }
802: strcpy(p, eventPtr->command + bytesSeen);
803:
804: /*
805: * Replace the command in the event.
806: */
807:
808: free(eventPtr->command);
809: eventPtr->command = newCommand;
810: eventPtr->bytesAvl = size;
811: iPtr->revPtr = NULL;
812: }
813:
814: /*
815: *----------------------------------------------------------------------
816: *
817: * DisableRevs --
818: *
819: * Turn off history revision for this command.
820: *
821: * Results:
822: * None.
823: *
824: * Side effects:
825: * The state of iPtr is modified to discard any pending
826: * history revisions and prevent any future revisions
827: * from being logged for this command.
828: *
829: *----------------------------------------------------------------------
830: */
831:
832: static void
833: DisableRevs(iPtr)
834: register Interp *iPtr; /* Interpreter in which to disable revs. */
835: {
836: iPtr->historyFirst = NULL;
837: while (iPtr->revPtr != NULL) {
838: free(iPtr->revPtr->newBytes);
839: free((char *) iPtr->revPtr);
840: iPtr->revPtr = iPtr->revPtr->nextPtr;
841: }
842: }
843:
844: /*
845: *----------------------------------------------------------------------
846: *
847: * GetEvent --
848: *
849: * Given a textual description of an event (see the manual page
850: * for legal values) find the corresponding event and return its
851: * command string.
852: *
853: * Results:
854: * The return value is a pointer to the event named by "string".
855: * If no such event exists, then NULL is returned and an error
856: * message is left in iPtr.
857: *
858: * Side effects:
859: * None.
860: *
861: *----------------------------------------------------------------------
862: */
863:
864: static HistoryEvent *
865: GetEvent(iPtr, string)
866: register Interp *iPtr; /* Interpreter in which to look. */
867: char *string; /* Description of event. */
868: {
869: int eventNum, index;
870: char *end;
871: register HistoryEvent *eventPtr;
872: int length;
873:
874: /*
875: * First check for a numeric specification of an event.
876: */
877:
878: if (isdigit(*string) || (*string == '-')) {
879: eventNum = strtol(string, &end, 0);
880: if (*end != 0) {
881: sprintf(iPtr->result, "bad event number \"%.50s\"", string);
882: return NULL;
883: }
884: if (eventNum < 0) {
885: eventNum += iPtr->curEventNum;
886: }
887: if (eventNum > iPtr->curEventNum) {
888: sprintf(iPtr->result, "event \"%.50s\" hasn't occurred yet",
889: string);
890: return NULL;
891: }
892: if ((eventNum <= iPtr->curEventNum-iPtr->numEvents)
893: || (eventNum <= 0)) {
894: sprintf(iPtr->result, "event \"%.50s\" is too far in the past",
895: string);
896: return NULL;
897: }
898: index = iPtr->curEvent + (eventNum - iPtr->curEventNum);
899: if (index < 0) {
900: index += iPtr->numEvents;
901: }
902: return &iPtr->events[index];
903: }
904:
905: /*
906: * Next, check for an event that contains the string as a prefix or
907: * that matches the string in the sense of Tcl_StringMatch.
908: */
909:
910: length = strlen(string);
911: for (index = iPtr->curEvent - 1; ; index--) {
912: if (index < 0) {
913: index += iPtr->numEvents;
914: }
915: if (index == iPtr->curEvent) {
916: break;
917: }
918: eventPtr = &iPtr->events[index];
919: if ((strncmp(eventPtr->command, string, length) == 0)
920: || Tcl_StringMatch(eventPtr->command, string)) {
921: return eventPtr;
922: }
923: }
924:
925: sprintf(iPtr->result, "no event matches \"%.50s\"", string);
926: return NULL;
927: }
928:
929: /*
930: *----------------------------------------------------------------------
931: *
932: * SubsAndEval --
933: *
934: * Generate a new command by making a textual substitution in
935: * the "cmd" argument. Then execute the new command.
936: *
937: * Results:
938: * The return value is a standard Tcl error.
939: *
940: * Side effects:
941: * History gets revised if the substitution is occurring on
942: * a recorded command line. Also, the re-executed command
943: * may produce side-effects.
944: *
945: *----------------------------------------------------------------------
946: */
947:
948: static int
949: SubsAndEval(iPtr, cmd, old, new)
950: register Interp *iPtr; /* Interpreter in which to execute
951: * new command. */
952: char *cmd; /* Command in which to substitute. */
953: char *old; /* String to search for in command. */
954: char *new; /* Replacement string for "old". */
955: {
956: char *src, *dst, *newCmd;
957: int count, oldLength, newLength, length, result;
958:
959: /*
960: * Figure out how much space it will take to hold the
961: * substituted command (and complain if the old string
962: * doesn't appear in the original command).
963: */
964:
965: oldLength = strlen(old);
966: newLength = strlen(new);
967: src = cmd;
968: count = 0;
969: while (1) {
970: src = strstr(src, old);
971: if (src == NULL) {
972: break;
973: }
974: src += oldLength;
975: count++;
976: }
977: if (count == 0) {
978: sprintf(iPtr->result, "\"%.50s\" doesn't appear in event",
979: old);
980: return TCL_ERROR;
981: }
982: length = strlen(cmd) + count*(newLength - oldLength);
983:
984: /*
985: * Generate a substituted command.
986: */
987:
988: newCmd = malloc((unsigned) (length + 1));
989: dst = newCmd;
990: while (1) {
991: src = strstr(cmd, old);
992: if (src == NULL) {
993: strcpy(dst, cmd);
994: break;
995: }
996: strncpy(dst, cmd, src-cmd);
997: dst += src-cmd;
998: strcpy(dst, new);
999: dst += newLength;
1000: cmd = src + oldLength;
1001: }
1002:
1003: RevCommand(iPtr, newCmd);
1004: result = Tcl_Eval((Tcl_Interp *) iPtr, newCmd, 0, (char **) NULL);
1005: free(newCmd);
1006: return result;
1007: }
1008:
1009: /*
1010: *----------------------------------------------------------------------
1011: *
1012: * GetWords --
1013: *
1014: * Given a command string, return one or more words from the
1015: * command string.
1016: *
1017: * Results:
1018: * The return value is a pointer to a dynamically-allocated
1019: * string containing the words of command specified by "words".
1020: * If the word specifier has improper syntax then an error
1021: * message is placed in iPtr->result and NULL is returned.
1022: *
1023: * Side effects:
1024: * Memory is allocated. It is the caller's responsibilty to
1025: * free the returned string..
1026: *
1027: *----------------------------------------------------------------------
1028: */
1029:
1030: static char *
1031: GetWords(iPtr, command, words)
1032: register Interp *iPtr; /* Tcl interpreter in which to place
1033: * an error message if needed. */
1034: char *command; /* Command string. */
1035: char *words; /* Description of which words to extract
1036: * from the command. Either num[-num] or
1037: * a pattern. */
1038: {
1039: char *result;
1040: char *start, *end, *dst;
1041: register char *next;
1042: int first; /* First word desired. -1 means last word
1043: * only. */
1044: int last; /* Last word desired. -1 means use everything
1045: * up to the end. */
1046: int index; /* Index of current word. */
1047: char *pattern;
1048:
1049: /*
1050: * Figure out whether we're looking for a numerical range or for
1051: * a pattern.
1052: */
1053:
1054: pattern = NULL;
1055: first = 0;
1056: last = -1;
1057: if (*words == '$') {
1058: if (words[1] != '\0') {
1059: goto error;
1060: }
1061: first = -1;
1062: } else if (isdigit(*words)) {
1063: first = strtoul(words, &start, 0);
1064: if (*start == 0) {
1065: last = first;
1066: } else if (*start == '-') {
1067: start++;
1068: if (*start == '$') {
1069: start++;
1070: } else if (isdigit(*start)) {
1071: last = strtoul(start, &start, 0);
1072: } else {
1073: goto error;
1074: }
1075: if (*start != 0) {
1076: goto error;
1077: }
1078: }
1079: if ((first > last) && (last != -1)) {
1080: goto error;
1081: }
1082: } else {
1083: pattern = words;
1084: }
1085:
1086: /*
1087: * Scan through the words one at a time, copying those that are
1088: * relevant into the result string. Allocate a result area large
1089: * enough to hold all the words if necessary.
1090: */
1091:
1092: result = malloc((unsigned) (strlen(command) + 1));
1093: dst = result;
1094: for (next = command; isspace(*next); next++) {
1095: /* Empty loop body: just find start of first word. */
1096: }
1097: for (index = 0; *next != 0; index++) {
1098: start = next;
1099: end = TclWordEnd(next, 0);
1100: for (next = end; isspace(*next); next++) {
1101: /* Empty loop body: just find start of next word. */
1102: }
1103: if ((first > index) || ((first == -1) && (*next != 0))) {
1104: continue;
1105: }
1106: if ((last != -1) && (last < index)) {
1107: continue;
1108: }
1109: if (pattern != NULL) {
1110: int match;
1111: char savedChar = *end;
1112:
1113: *end = 0;
1114: match = Tcl_StringMatch(start, pattern);
1115: *end = savedChar;
1116: if (!match) {
1117: continue;
1118: }
1119: }
1120: if (dst != result) {
1121: *dst = ' ';
1122: dst++;
1123: }
1124: strncpy(dst, start, (end-start));
1125: dst += end-start;
1126: }
1127: *dst = 0;
1128:
1129: /*
1130: * Check for an out-of-range argument index.
1131: */
1132:
1133: if ((last >= index) || (first >= index)) {
1134: free(result);
1135: sprintf(iPtr->result,
1136: "word selector \"%.50s\" specified non-existent words",
1137: words);
1138: return NULL;
1139: }
1140: return result;
1141:
1142: error:
1143: sprintf(iPtr->result,
1144: "bad word selector \"%.50s\": should be num-num or pattern",
1145: words);
1146: return NULL;
1147: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.