![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex.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 / vi|
Return to ex.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* ex.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains the code for reading ex commands. */
12:
13: #include "config.h"
14: #include "ctype.h"
15: #include "vi.h"
16:
17: /* This data type is used to describe the possible argument combinations */
18: typedef short ARGT;
19: #define FROM 1 /* allow a linespec */
20: #define TO 2 /* allow a second linespec */
21: #define BANG 4 /* allow a ! after the command name */
22: #define EXTRA 8 /* allow extra args after command name */
23: #define XFILE 16 /* expand wildcards in extra part */
24: #define NOSPC 32 /* no spaces allowed in the extra part */
25: #define DFLALL 64 /* default file range is 1,$ */
26: #define DFLNONE 128 /* no default file range */
27: #define NODFL 256 /* do not default to the current file name */
28: #define EXRCOK 512 /* can be in a .exrc file */
29: #define NL 1024 /* if mode!=MODE_EX, then write a newline first */
30: #define PLUS 2048 /* allow a line number, as in ":e +32 foo" */
31: #define ZERO 4096 /* allow 0 to be given as a line number */
32: #define NOBAR 8192 /* treat following '|' chars as normal */
33: #define FILES (XFILE + EXTRA) /* multiple extra files allowed */
34: #define WORD1 (EXTRA + NOSPC) /* one extra word allowed */
35: #define FILE1 (FILES + NOSPC) /* 1 file allowed, defaults to current file */
36: #define NAMEDF (FILE1 + NODFL) /* 1 file allowed, defaults to "" */
37: #define NAMEDFS (FILES + NODFL) /* multiple files allowed, default is "" */
38: #define RANGE (FROM + TO) /* range of linespecs allowed */
39: #define NONE 0 /* no args allowed at all */
40:
41: /* This array maps ex command names to command codes. The order in which
42: * command names are listed below is significant -- ambiguous abbreviations
43: * are always resolved to be the first possible match. (e.g. "r" is taken
44: * to mean "read", not "rewind", because "read" comes before "rewind")
45: */
46: static struct
47: {
48: char *name; /* name of the command */
49: CMD code; /* enum code of the command */
50: void (*fn)();/* function which executes the command */
51: ARGT argt; /* command line arguments permitted/needed/used */
52: }
53: cmdnames[] =
54: { /* cmd name cmd code function arguments */
55: {"append", CMD_APPEND, cmd_append, FROM+ZERO+BANG },
56: #ifdef DEBUG
57: {"bug", CMD_DEBUG, cmd_debug, RANGE+BANG+EXTRA+NL},
58: #endif
59: {"change", CMD_CHANGE, cmd_append, RANGE+BANG },
60: {"delete", CMD_DELETE, cmd_delete, RANGE+WORD1 },
61: {"edit", CMD_EDIT, cmd_edit, BANG+FILE1+PLUS },
62: {"file", CMD_FILE, cmd_file, NAMEDF },
63: {"global", CMD_GLOBAL, cmd_global, RANGE+BANG+EXTRA+DFLALL+NOBAR},
64: {"insert", CMD_INSERT, cmd_append, FROM+BANG },
65: {"join", CMD_INSERT, cmd_join, RANGE+BANG },
66: {"k", CMD_MARK, cmd_mark, FROM+WORD1 },
67: {"list", CMD_LIST, cmd_print, RANGE+NL },
68: {"move", CMD_MOVE, cmd_move, RANGE+EXTRA },
69: {"next", CMD_NEXT, cmd_next, BANG+NAMEDFS },
70: {"Next", CMD_PREVIOUS, cmd_next, BANG },
71: {"print", CMD_PRINT, cmd_print, RANGE+NL },
72: {"quit", CMD_QUIT, cmd_xit, BANG },
73: {"read", CMD_READ, cmd_read, FROM+ZERO+NAMEDF},
74: {"substitute", CMD_SUBSTITUTE, cmd_substitute, RANGE+EXTRA },
75: {"to", CMD_COPY, cmd_move, RANGE+EXTRA },
76: {"undo", CMD_UNDO, cmd_undo, NONE },
77: {"vglobal", CMD_VGLOBAL, cmd_global, RANGE+EXTRA+DFLALL+NOBAR},
78: {"write", CMD_WRITE, cmd_write, RANGE+BANG+FILE1+DFLALL},
79: {"xit", CMD_XIT, cmd_xit, BANG+NL },
80: {"yank", CMD_YANK, cmd_delete, RANGE+WORD1 },
81:
82: {"!", CMD_BANG, cmd_shell, EXRCOK+RANGE+NAMEDFS+DFLNONE+NL+NOBAR},
83: {"#", CMD_NUMBER, cmd_print, RANGE+NL },
84: {"<", CMD_SHIFTL, cmd_shift, RANGE },
85: {">", CMD_SHIFTR, cmd_shift, RANGE },
86: {"=", CMD_EQUAL, cmd_file, RANGE },
87: {"&", CMD_SUBAGAIN, cmd_substitute, RANGE },
88: #ifndef NO_AT
89: {"@", CMD_AT, cmd_at, EXTRA },
90: #endif
91:
92: #ifndef NO_ABBR
93: {"abbreviate", CMD_ABBR, cmd_map, EXRCOK+BANG+EXTRA},
94: #endif
95: {"args", CMD_ARGS, cmd_args, EXRCOK+NAMEDFS },
96: #ifndef NO_ERRLIST
97: {"cc", CMD_CC, cmd_make, BANG+FILES },
98: #endif
99: {"cd", CMD_CD, cmd_cd, EXRCOK+BANG+NAMEDF},
100: {"copy", CMD_COPY, cmd_move, RANGE+EXTRA },
101: #ifndef NO_DIGRAPH
102: {"digraph", CMD_DIGRAPH, cmd_digraph, EXRCOK+BANG+EXTRA},
103: #endif
104: #ifndef NO_ERRLIST
105: {"errlist", CMD_ERRLIST, cmd_errlist, BANG+NAMEDF },
106: #endif
107: {"ex", CMD_EDIT, cmd_edit, BANG+FILE1 },
108: {"mark", CMD_MARK, cmd_mark, FROM+WORD1 },
109: #ifndef NO_MKEXRC
110: {"mkexrc", CMD_MKEXRC, cmd_mkexrc, NAMEDF },
111: #endif
112: {"number", CMD_NUMBER, cmd_print, RANGE+NL },
113: {"put", CMD_PUT, cmd_put, FROM+ZERO+WORD1 },
114: {"set", CMD_SET, cmd_set, EXRCOK+EXTRA },
115: {"shell", CMD_SHELL, cmd_shell, NL },
116: {"source", CMD_SOURCE, cmd_source, EXRCOK+NAMEDF },
117: #ifdef SIGTSTP
118: {"stop", CMD_STOP, cmd_suspend, NONE },
119: #endif
120: {"tag", CMD_TAG, cmd_tag, BANG+WORD1 },
121: {"version", CMD_VERSION, cmd_version, EXRCOK+NONE },
122: {"visual", CMD_VISUAL, cmd_edit, BANG+NAMEDF },
123: {"wq", CMD_WQUIT, cmd_xit, NL },
124:
125: #ifdef DEBUG
126: {"debug", CMD_DEBUG, cmd_debug, RANGE+BANG+EXTRA+NL},
127: {"validate", CMD_VALIDATE, cmd_validate, BANG+NL },
128: #endif
129: {"chdir", CMD_CD, cmd_cd, EXRCOK+BANG+NAMEDF},
130: #ifndef NO_COLOR
131: {"color", CMD_COLOR, cmd_color, EXRCOK+EXTRA },
132: #endif
133: #ifndef NO_ERRLIST
134: {"make", CMD_MAKE, cmd_make, BANG+NAMEDFS },
135: #endif
136: {"map", CMD_MAP, cmd_map, EXRCOK+BANG+EXTRA},
137: {"previous", CMD_PREVIOUS, cmd_next, BANG },
138: {"rewind", CMD_REWIND, cmd_next, BANG },
139: #ifdef SIGTSTP
140: {"suspend", CMD_SUSPEND, cmd_suspend, NONE },
141: #endif
142: {"unmap", CMD_UNMAP, cmd_map, EXRCOK+BANG+EXTRA},
143: #ifndef NO_ABBR
144: {"unabbreviate",CMD_UNABBR, cmd_map, EXRCOK+WORD1 },
145: #endif
146:
147: {(char *)0}
148: };
149:
150:
151: /* This function parses a search pattern - given a pointer to a / or ?,
152: * it replaces the ending / or ? with a \0, and returns a pointer to the
153: * stuff that came after the pattern.
154: */
155: char *parseptrn(ptrn)
156: REG char *ptrn;
157: {
158: REG char *scan;
159:
160: for (scan = ptrn + 1;
161: *scan && *scan != *ptrn;
162: scan++)
163: {
164: /* allow backslashed versions of / and ? in the pattern */
165: if (*scan == '\\' && scan[1] != '\0')
166: {
167: scan++;
168: }
169: }
170: if (*scan)
171: {
172: *scan++ = '\0';
173: }
174:
175: return scan;
176: }
177:
178:
179: /* This function parses a line specifier for ex commands */
180: char *linespec(s, markptr)
181: REG char *s; /* start of the line specifier */
182: MARK *markptr; /* where to store the mark's value */
183: {
184: long num;
185: REG char *t;
186:
187: /* parse each ;-delimited clause of this linespec */
188: do
189: {
190: /* skip an initial ';', if any */
191: if (*s == ';')
192: {
193: s++;
194: }
195:
196: /* skip leading spaces */
197: while (isspace(*s))
198: {
199: s++;
200: }
201:
202: /* dot means current position */
203: if (*s == '.')
204: {
205: s++;
206: *markptr = cursor;
207: }
208: /* '$' means the last line */
209: else if (*s == '$')
210: {
211: s++;
212: *markptr = MARK_LAST;
213: }
214: /* digit means an absolute line number */
215: else if (isdigit(*s))
216: {
217: for (num = 0; isdigit(*s); s++)
218: {
219: num = num * 10 + *s - '0';
220: }
221: *markptr = MARK_AT_LINE(num);
222: }
223: /* appostrophe means go to a set mark */
224: else if (*s == '\'')
225: {
226: s++;
227: *markptr = m_tomark(cursor, 1L, (int)*s);
228: s++;
229: }
230: /* slash means do a search */
231: else if (*s == '/' || *s == '?')
232: {
233: /* put a '\0' at the end of the search pattern */
234: t = parseptrn(s);
235:
236: /* search for the pattern */
237: *markptr &= ~(BLKSIZE - 1);
238: if (*s == '/')
239: {
240: pfetch(markline(*markptr));
241: if (plen > 0)
242: *markptr += plen - 1;
243: *markptr = m_fsrch(*markptr, s);
244: }
245: else
246: {
247: *markptr = m_bsrch(*markptr, s);
248: }
249:
250: /* adjust command string pointer */
251: s = t;
252: }
253:
254: /* if linespec was faulty, quit now */
255: if (!*markptr)
256: {
257: return s;
258: }
259:
260: /* maybe add an offset */
261: t = s;
262: if (*t == '-' || *t == '+')
263: {
264: s++;
265: for (num = 0; isdigit(*s); s++)
266: {
267: num = num * 10 + *s - '0';
268: }
269: if (num == 0)
270: {
271: num = 1;
272: }
273: *markptr = m_updnto(*markptr, num, *t);
274: }
275: } while (*s == ';' || *s == '+' || *s == '-');
276:
277: /* protect against invalid line numbers */
278: num = markline(*markptr);
279: if (num < 1L || num > nlines)
280: {
281: msg("Invalid line number -- must be from 1 to %ld", nlines);
282: *markptr = MARK_UNSET;
283: }
284:
285: return s;
286: }
287:
288:
289:
290: /* This function reads an ex command and executes it. */
291: void ex()
292: {
293: char cmdbuf[150];
294: REG int cmdlen;
295: static long oldline;
296:
297: significant = FALSE;
298: oldline = markline(cursor);
299:
300: while (mode == MODE_EX)
301: {
302: /* read a line */
303: #ifdef CRUNCH
304: cmdlen = vgets(':', cmdbuf, sizeof(cmdbuf));
305: #else
306: cmdlen = vgets(*o_prompt ? ':' : '\0', cmdbuf, sizeof(cmdbuf));
307: #endif
308: if (cmdlen < 0)
309: {
310: return;
311: }
312:
313: /* if empty line, assume ".+1" */
314: if (cmdlen == 0)
315: {
316: strcpy(cmdbuf, ".+1");
317: qaddch('\r');
318: clrtoeol();
319: }
320: else
321: {
322: addch('\n');
323: }
324: refresh();
325:
326: /* parse & execute the command */
327: doexcmd(cmdbuf);
328:
329: /* handle autoprint */
330: if (significant || markline(cursor) != oldline)
331: {
332: significant = FALSE;
333: oldline = markline(cursor);
334: if (*o_autoprint && mode == MODE_EX)
335: {
336: cmd_print(cursor, cursor, CMD_PRINT, FALSE, "");
337: }
338: }
339: }
340: }
341:
342: void doexcmd(cmdbuf)
343: char *cmdbuf; /* string containing an ex command */
344: {
345: REG char *scan; /* used to scan thru cmdbuf */
346: MARK frommark; /* first linespec */
347: MARK tomark; /* second linespec */
348: REG int cmdlen; /* length of the command name given */
349: CMD cmd; /* what command is this? */
350: ARGT argt; /* argument types for this command */
351: short forceit; /* bang version of a command? */
352: REG int cmdidx; /* index of command */
353: REG char *build; /* used while copying filenames */
354: int iswild; /* boolean: filenames use wildcards? */
355: int isdfl; /* using default line ranges? */
356: int didsub; /* did we substitute file names for % or # */
357:
358: /* ex commands can't be undone via the shift-U command */
359: U_line = 0L;
360:
361: /* permit extra colons at the start of the line */
362: for (; *cmdbuf == ':'; cmdbuf++)
363: {
364: }
365:
366: /* ignore command lines that start with a double-quote */
367: if (*cmdbuf == '"')
368: {
369: return;
370: }
371: scan = cmdbuf;
372:
373: /* parse the line specifier */
374: if (nlines < 1)
375: {
376: /* no file, so don't allow addresses */
377: }
378: else if (*scan == '%')
379: {
380: /* '%' means all lines */
381: frommark = MARK_FIRST;
382: tomark = MARK_LAST;
383: scan++;
384: }
385: else if (*scan == '0')
386: {
387: scan++;
388: frommark = tomark = (*scan ? MARK_UNSET : MARK_FIRST);
389: }
390: else
391: {
392: frommark = cursor;
393: scan = linespec(scan, &frommark);
394: tomark = frommark;
395: if (frommark && *scan == ',')
396: {
397: scan++;
398: scan = linespec(scan, &tomark);
399: }
400: if (!tomark)
401: {
402: /* faulty line spec -- fault already described */
403: return;
404: }
405: if (frommark > tomark)
406: {
407: msg("first address exceeds the second");
408: return;
409: }
410: }
411: isdfl = (scan == cmdbuf);
412:
413: /* skip whitespace */
414: while (isspace(*scan))
415: {
416: scan++;
417: }
418:
419: /* if no command, then just move the cursor to the mark */
420: if (!*scan)
421: {
422: if (tomark != MARK_UNSET)
423: cursor = tomark;
424: return;
425: }
426:
427: /* figure out how long the command name is */
428: if (!isalpha(*scan))
429: {
430: cmdlen = 1;
431: }
432: else
433: {
434: for (cmdlen = 1;
435: isalpha(scan[cmdlen]);
436: cmdlen++)
437: {
438: }
439: }
440:
441: /* lookup the command code */
442: for (cmdidx = 0;
443: cmdnames[cmdidx].name && strncmp(scan, cmdnames[cmdidx].name, cmdlen);
444: cmdidx++)
445: {
446: }
447: argt = cmdnames[cmdidx].argt;
448: cmd = cmdnames[cmdidx].code;
449: if (cmd == CMD_NULL)
450: {
451: msg("Unknown command \"%.*s\"", cmdlen, scan);
452: return;
453: }
454:
455: /* !!! if the command doesn't have NOBAR set, then replace | with \0 */
456:
457: /* if the command ended with a bang, set the forceit flag */
458: scan += cmdlen;
459: if ((argt & BANG) && *scan == '!')
460: {
461: scan++;
462: forceit = 1;
463: }
464: else
465: {
466: forceit = 0;
467: }
468:
469: /* skip any more whitespace, to leave scan pointing to arguments */
470: while (isspace(*scan))
471: {
472: scan++;
473: }
474:
475: /* a couple of special cases for filenames */
476: if (argt & XFILE)
477: {
478: /* if names were given, process them */
479: if (*scan)
480: {
481: for (build = tmpblk.c, iswild = didsub = FALSE; *scan; scan++)
482: {
483: switch (*scan)
484: {
485: case '\\':
486: if (scan[1] == '\\' || scan[1] == '%' || scan[1] == '#')
487: {
488: *build++ = *++scan;
489: }
490: else
491: {
492: *build++ = '\\';
493: }
494: break;
495:
496: case '%':
497: if (!*origname)
498: {
499: msg("No filename to substitute for %%");
500: return;
501: }
502: strcpy(build, origname);
503: while (*build)
504: {
505: build++;
506: }
507: didsub = TRUE;
508: break;
509:
510: case '#':
511: if (!*prevorig)
512: {
513: msg("No filename to substitute for #");
514: return;
515: }
516: strcpy(build, prevorig);
517: while (*build)
518: {
519: build++;
520: }
521: didsub = TRUE;
522: break;
523:
524: case '*':
525: case '?':
526: #if !(MSDOS || TOS)
527: case '[':
528: case '`':
529: case '{': /* } */
530: case '$':
531: case '~':
532: #endif
533: *build++ = *scan;
534: iswild = TRUE;
535: break;
536:
537: default:
538: *build++ = *scan;
539: }
540: }
541: *build = '\0';
542:
543: if (cmd == CMD_BANG
544: || cmd == CMD_READ && tmpblk.c[0] == '!'
545: || cmd == CMD_WRITE && tmpblk.c[0] == '!')
546: {
547: if (didsub)
548: {
549: if (mode != MODE_EX)
550: {
551: addch('\n');
552: }
553: addstr(tmpblk.c);
554: addch('\n');
555: exrefresh();
556: }
557: }
558: else
559: {
560: if (iswild && tmpblk.c[0] != '>')
561: {
562: scan = wildcard(tmpblk.c);
563: }
564: }
565: }
566: else /* no names given, maybe assume origname */
567: {
568: if (!(argt & NODFL))
569: {
570: strcpy(tmpblk.c, origname);
571: }
572: else
573: {
574: *tmpblk.c = '\0';
575: }
576: }
577:
578: scan = tmpblk.c;
579: }
580:
581: /* bad arguments? */
582: if (!(argt & EXRCOK) && nlines < 1L)
583: {
584: msg("Can't use the \"%s\" command in a %s file", cmdnames[cmdidx].name, EXRC);
585: return;
586: }
587: if (!(argt & (ZERO | EXRCOK)) && frommark == MARK_UNSET)
588: {
589: msg("Can't use address 0 with \"%s\" command.", cmdnames[cmdidx].name);
590: return;
591: }
592: if (!(argt & FROM) && frommark != cursor && nlines >= 1L)
593: {
594: msg("Can't use address with \"%s\" command.", cmdnames[cmdidx].name);
595: return;
596: }
597: if (!(argt & TO) && tomark != frommark && nlines >= 1L)
598: {
599: msg("Can't use a range with \"%s\" command.", cmdnames[cmdidx].name);
600: return;
601: }
602: if (!(argt & EXTRA) && *scan)
603: {
604: msg("Extra characters after \"%s\" command.", cmdnames[cmdidx].name);
605: return;
606: }
607: if ((argt & NOSPC) && !(cmd == CMD_READ && (forceit || *scan == '!')))
608: {
609: build = scan;
610: #ifndef CRUNCH
611: if ((argt & PLUS) && *build == '+')
612: {
613: while (*build && !isspace(*build))
614: {
615: build++;
616: }
617: while (*build && isspace(*build))
618: {
619: build++;
620: }
621: }
622: #endif /* not CRUNCH */
623: for (; *build; build++)
624: {
625: if (isspace(*build))
626: {
627: msg("Too many %s to \"%s\" command.",
628: (argt & XFILE) ? "filenames" : "arguments",
629: cmdnames[cmdidx].name);
630: return;
631: }
632: }
633: }
634:
635: /* some commands have special default ranges */
636: if (isdfl && (argt & DFLALL))
637: {
638: frommark = MARK_FIRST;
639: tomark = MARK_LAST;
640: }
641: else if (isdfl && (argt & DFLNONE))
642: {
643: frommark = tomark = 0L;
644: }
645:
646: /* write a newline if called from visual mode */
647: if ((argt & NL) && mode != MODE_EX && !exwrote)
648: {
649: addch('\n');
650: exrefresh();
651: }
652:
653: /* act on the command */
654: (*cmdnames[cmdidx].fn)(frommark, tomark, cmd, forceit, scan);
655: }
656:
657:
658: /* This function executes EX commands from a file. It returns 1 normally, or
659: * 0 if the file could not be opened for reading.
660: */
661: int doexrc(filename)
662: char *filename; /* name of a ".exrc" file */
663: {
664: int fd; /* file descriptor */
665: int len; /* length of the ".exrc" file */
666:
667: #ifdef CRUNCH
668: /* small address space - we need to conserve space */
669:
670: /* !!! kludge: we use U_text as the buffer. This has the side-effect
671: * of interfering with the shift-U visual command. Disable shift-U.
672: */
673: U_line = 0L;
674: #else
675: # if TINYSTACK
676: /* small stack - we need to conserve space */
677:
678: /* !!! kludge: we use U_text as the buffer. This has the side-effect
679: * of interfering with the shift-U visual command. Disable shift-U.
680: */
681: U_line = 0L;
682: # else
683: /* This is how we would *like* to do it -- with a large buffer on the
684: * stack, so we can handle large .exrc files and also recursion.
685: */
686: char U_text[4096];
687: # endif
688: #endif
689:
690: /* open the file, read it, and close */
691: fd = open(filename, O_RDONLY);
692: if (fd < 0)
693: {
694: return 0;
695: }
696: len = tread(fd, U_text, sizeof U_text);
697: close(fd);
698:
699: /* execute the string */
700: exstring(U_text, len, ctrl('V'));
701:
702: return 1;
703: }
704:
705: /* This function executes EX commands from a string. The commands may be
706: * separated by newlines or by | characters. It also handles quoting.
707: * Each individual command is limited to 132 bytes, but the total string
708: * may be longer.
709: */
710: void exstring(buf, len, qchar)
711: char *buf; /* the commands to execute */
712: int len; /* the length of the string */
713: int qchar; /* the quote character -- ^V for file, or \ for kbd */
714: {
715: char single[133]; /* a single command */
716: char *src, *dest;
717: int i;
718:
719: /* find & do each command */
720: for (src = buf; src < &buf[len]; src++)
721: {
722: /* Copy a single command into single[]. Convert any quoted |
723: * into a normal |, and stop at a newline or unquoted |.
724: */
725: for (dest = single, i = 0;
726: i < 132 && src < &buf[len] && *src != '\n' && *src != '|';
727: src++, i++)
728: {
729: if (src[0] == qchar && src[1] == '|')
730: {
731: src++;
732: }
733: *dest++ = *src;
734: }
735: *dest = '\0';
736:
737: /* do it */
738: doexcmd(single);
739: }
740: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.