![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to input.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 root 1: /* input.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 16820 SW Tallac Way
6: * Beaverton, OR 97006
7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
8: */
9:
10:
11: /* This file contains the input() function, which implements vi's INPUT mode.
12: * It also contains the code that supports digraphs.
13: */
14:
15: #include <ctype.h>
16: #include "config.h"
17: #include "vi.h"
18:
19:
20: #ifndef NO_DIGRAPH
21: static struct _DIG
22: {
23: struct _DIG *next;
24: char key1;
25: char key2;
26: char dig;
27: char save;
28: } *digs;
29:
30: char digraph(key1, key2)
31: char key1; /* the underlying character */
32: char key2; /* the second character */
33: {
34: int newkey;
35: REG struct _DIG *dp;
36:
37: /* if digraphs are disabled, then just return the new char */
38: if (!*o_digraph)
39: {
40: return key2;
41: }
42:
43: /* remember the new key, so we can return it if this isn't a digraph */
44: newkey = key2;
45:
46: /* sort key1 and key2, so that their original order won't matter */
47: if (key1 > key2)
48: {
49: key2 = key1;
50: key1 = newkey;
51: }
52:
53: /* scan through the digraph chart */
54: for (dp = digs;
55: dp && (dp->key1 != key1 || dp->key2 != key2);
56: dp = dp->next)
57: {
58: }
59:
60: /* if this combination isn't in there, just use the new key */
61: if (!dp)
62: {
63: return newkey;
64: }
65:
66: /* else use the digraph key */
67: return dp->dig;
68: }
69:
70: /* this function lists or defines digraphs */
71: void do_digraph(bang, extra)
72: int bang;
73: char extra[];
74: {
75: int dig;
76: REG struct _DIG *dp;
77: struct _DIG *prev;
78: static int user_defined = FALSE; /* boolean: are all later digraphs user-defined? */
79:
80: /* if "extra" is NULL, then we've reached the end of the built-ins */
81: if (!extra)
82: {
83: user_defined = TRUE;
84: return;
85: }
86:
87: /* if no args, then display the existing digraphs */
88: if (*extra < ' ')
89: {
90: for (dp = digs; dp; dp = dp->next)
91: {
92: if (dp->save || bang)
93: {
94: addstr("digraph ");
95: addch(dp->key1);
96: addch(dp->key2);
97: addch(' ');
98: addch(dp->dig);
99: addch('\n');
100: exrefresh();
101: }
102: }
103: return;
104: }
105:
106: /* make sure we have at least two characters */
107: if (!extra[1])
108: {
109: msg("Digraphs must be composed of two characters");
110: return;
111: }
112:
113: /* sort key1 and key2, so that their original order won't matter */
114: if (extra[0] > extra[1])
115: {
116: dig = extra[0];
117: extra[0] = extra[1];
118: extra[1] = dig;
119: }
120:
121: /* locate the new digraph character */
122: for (dig = 2; extra[dig] == ' ' || extra[dig] == '\t'; dig++)
123: {
124: }
125: dig = extra[dig];
126: if (!bang && dig)
127: {
128: dig |= 0x80;
129: }
130:
131: /* search for the digraph */
132: for (prev = (struct _DIG *)0, dp = digs;
133: dp && (dp->key1 != extra[0] || dp->key2 != extra[1]);
134: prev = dp, dp = dp->next)
135: {
136: }
137:
138: /* deleting the digraph? */
139: if (!dig)
140: {
141: if (!dp)
142: {
143: #ifndef CRUNCH
144: msg("%c%c not a digraph", extra[0], extra[1]);
145: #endif
146: return;
147: }
148: if (prev)
149: prev->next = dp->next;
150: else
151: digs = dp->next;
152: free(dp);
153: return;
154: }
155:
156: /* if necessary, create a new digraph struct for the new digraph */
157: if (dig && !dp)
158: {
159: dp = (struct _DIG *)malloc(sizeof *dp);
160: if (!dp)
161: {
162: msg("Out of space in the digraph table");
163: return;
164: }
165: if (prev)
166: prev->next = dp;
167: else
168: digs = dp;
169: dp->next = (struct _DIG *)0;
170: }
171:
172: /* assign it the new digraph value */
173: dp->key1 = extra[0];
174: dp->key2 = extra[1];
175: dp->dig = dig;
176: dp->save = user_defined;
177: }
178:
179: # ifndef NO_MKEXRC
180: void savedigs(fd)
181: int fd;
182: {
183: static char buf[] = "digraph! XX Y\n";
184: REG struct _DIG *dp;
185:
186: for (dp = digs; dp; dp = dp->next)
187: {
188: if (dp->save)
189: {
190: buf[9] = dp->key1;
191: buf[10] = dp->key2;
192: buf[12] = dp->dig;
193: write(fd, buf, (unsigned)14);
194: }
195: }
196: }
197: # endif
198: #endif
199:
200:
201: #ifndef NO_ABBR
202: static struct _AB
203: {
204: struct _AB *next;
205: char *large; /* the expanded form */
206: char small[1]; /* the abbreviated form (appended to struct) */
207: }
208: *abbrev;
209:
210: /* This functions lists or defines abbreviations */
211: void do_abbr(extra)
212: char *extra;
213: {
214: int smlen; /* length of the small form */
215: int lrg; /* index of the start of the large form */
216: REG struct _AB *ab; /* used to move through the abbrev list */
217: struct _AB *prev;
218:
219: /* no arguments? */
220: if (!*extra)
221: {
222: /* list all current abbreviations */
223: for (ab = abbrev; ab; ab = ab->next)
224: {
225: qaddstr("abbr ");
226: qaddstr(ab->small);
227: qaddch(' ');
228: qaddstr(ab->large);
229: addch('\n');
230: exrefresh();
231: }
232: return;
233: }
234:
235: /* else one or more arguments. Parse the first & look up in abbrev[] */
236: for (smlen = 0; extra[smlen] && isalnum(extra[smlen]); smlen++)
237: {
238: }
239: for (prev = (struct _AB *)0, ab = abbrev; ab; prev = ab, ab = ab->next)
240: {
241: if (!strncmp(extra, ab->small, smlen) && !ab->small[smlen])
242: {
243: break;
244: }
245: }
246:
247: /* locate the start of the large form, if any */
248: for (lrg = smlen; extra[lrg] && isascii(extra[lrg]) && isspace(extra[lrg]); lrg++)
249: {
250: }
251:
252: /* only one arg? */
253: if (!extra[lrg])
254: {
255: /* trying to undo an abbreviation which doesn't exist? */
256: if (!ab)
257: {
258: #ifndef CRUNCH
259: msg("\"%s\" not an abbreviation", extra);
260: #endif
261: return;
262: }
263:
264: /* undo the abbreviation */
265: if (prev)
266: prev->next = ab->next;
267: else
268: abbrev = ab->next;
269: free(ab->large);
270: free(ab);
271:
272: return;
273: }
274:
275: /* multiple args - [re]define an abbreviation */
276: if (ab)
277: {
278: /* redefining - free the old large form */
279: free(ab->large);
280: }
281: else
282: {
283: /* adding a new definition - make a new struct */
284: ab = (struct _AB *)malloc((unsigned)(smlen + sizeof *ab));
285: #ifndef CRUNCH
286: if (!ab)
287: {
288: msg("Out of memory -- Sorry");
289: return;
290: }
291: #endif
292: strncpy(ab->small, extra, smlen);
293: ab->small[smlen] = '\0';
294: ab->next = (struct _AB *)0;
295: if (prev)
296: prev->next = ab;
297: else
298: abbrev = ab;
299: }
300:
301: /* store the new form */
302: ab->large = (char *)malloc((unsigned)(strlen(&extra[lrg]) + 1));
303: strcpy(ab->large, &extra[lrg]);
304: }
305:
306:
307: # ifndef NO_MKEXRC
308: /* This function is called from cmd_mkexrc() to save the abbreviations */
309: void saveabbr(fd)
310: int fd; /* fd to which the :abbr commands should be written */
311: {
312: REG struct _AB *ab;
313:
314: for (ab = abbrev; ab; ab = ab->next)
315: {
316: twrite(fd, "abbr ", 5);
317: twrite(fd, ab->small, strlen(ab->small));
318: twrite(fd, " ", 1);
319: twrite(fd, ab->large, strlen(ab->large));
320: twrite(fd, "\n", 1);
321: }
322: }
323: # endif
324:
325: /* This function should be called before each char is inserted. If the next
326: * char is non-alphanumeric and we're at the end of a word, then that word
327: * is checked against the abbrev[] array and expanded, if appropriate. Upon
328: * returning from this function, the new char still must be inserted.
329: */
330: static MARK expandabbr(m, ch)
331: MARK m; /* the cursor position */
332: int ch; /* the character to insert */
333: {
334: char *word; /* where the word starts */
335: int len; /* length of the word */
336: REG struct _AB *ab;
337:
338: /* if no abbreviations are in effect, or ch is aphanumeric, then
339: * don't do anything
340: */
341: if (!abbrev || !isascii(ch) || isalnum(ch))
342: {
343: return m;
344: }
345:
346: /* see where the preceding word starts */
347: pfetch(markline(m));
348: for (word = ptext + markidx(m), len = 0;
349: --word >= ptext && (!isascii(*word) || isalnum(*word));
350: len++)
351: {
352: }
353: word++;
354:
355: /* if zero-length, then it isn't a word, really -- so nothing */
356: if (len == 0)
357: {
358: return m;
359: }
360:
361: /* look it up in the abbrev list */
362: for (ab = abbrev; ab; ab = ab->next)
363: {
364: if (!strncmp(ab->small, word, len) && !ab->small[len])
365: {
366: break;
367: }
368: }
369:
370: /* not an abbreviation? then do nothing */
371: if (!ab)
372: {
373: return m;
374: }
375:
376: /* else replace the small form with the large form */
377: add(m, ab->large);
378: delete(m - len, m);
379:
380: /* return with the cursor after the end of the large form */
381: return m - len + strlen(ab->large);
382: }
383: #endif
384:
385:
386: /* This function allows the user to replace an existing (possibly zero-length)
387: * chunk of text with typed-in text. It returns the MARK of the last character
388: * that the user typed in.
389: */
390: MARK input(from, to, when)
391: MARK from; /* where to start inserting text */
392: MARK to; /* extent of text to delete */
393: int when; /* either WHEN_VIINP or WHEN_VIREP */
394: {
395: char key[2]; /* key char followed by '\0' char */
396: char *build; /* used in building a newline+indent string */
397: char *scan; /* used while looking at the indent chars of a line */
398: MARK m; /* some place in the text */
399: #ifndef NO_EXTENSIONS
400: int quit = FALSE; /* boolean: are we exiting after this? */
401: #endif
402:
403: #ifdef DEBUG
404: /* if "from" and "to" are reversed, complain */
405: if (from > to)
406: {
407: msg("ERROR: input(%ld:%d, %ld:%d)",
408: markline(from), markidx(from),
409: markline(to), markidx(to));
410: return MARK_UNSET;
411: }
412: #endif
413:
414: key[1] = 0;
415:
416: /* if we're replacing text with new text, save the old stuff */
417: /* (Alas, there is no easy way to save text for replace mode) */
418: if (from != to)
419: {
420: cut(from, to);
421: }
422:
423: ChangeText
424: {
425: /* if doing a dot command, then reuse the previous text */
426: if (doingdot)
427: {
428: /* delete the text that's there now */
429: if (from != to)
430: {
431: delete(from, to);
432: }
433:
434: /* insert the previous text */
435: cutname('.');
436: cursor = paste(from, FALSE, TRUE) + 1L;
437: }
438: else /* interactive version */
439: {
440: /* if doing a change within the line... */
441: if (from != to && markline(from) == markline(to))
442: {
443: /* mark the end of the text with a "$" */
444: change(to - 1, to, "$");
445: }
446: else
447: {
448: /* delete the old text right off */
449: if (from != to)
450: {
451: delete(from, to);
452: }
453: to = from;
454: }
455:
456: /* handle autoindent of the first line, maybe */
457: cursor = from;
458: if (*o_autoindent && markline(cursor) > 1L && markidx(cursor) == 0)
459: {
460: /* Only autoindent blank lines. */
461: pfetch(markline(cursor));
462: if (plen == 0)
463: {
464: /* Okay, we really want to autoindent */
465: pfetch(markline(cursor) - 1L);
466: for (scan = ptext, build = tmpblk.c;
467: *scan == ' ' || *scan == '\t';
468: )
469: {
470: *build++ = *scan++;
471: }
472: if (build > tmpblk.c)
473: {
474: *build = '\0';
475: add(cursor, tmpblk.c);
476: cursor += (build - tmpblk.c);
477: }
478: }
479: }
480:
481: /* repeatedly add characters from the user */
482: for (;;)
483: {
484: /* Get a character */
485: redraw(cursor, TRUE);
486: #ifdef DEBUG
487: msg("cursor=%ld.%d, to=%ld.%d",
488: markline(cursor), markidx(cursor),
489: markline(to), markidx(to));
490: #endif
491: key[0] = getkey(when);
492:
493: /* if whitespace & wrapmargin is set & we're
494: * past the warpmargin, then change the
495: * whitespace character into a newline
496: */
497: if ((*key == ' ' || *key == '\t')
498: && *o_wrapmargin != 0)
499: {
500: pfetch(markline(cursor));
501: if (idx2col(cursor, ptext, TRUE) > COLS - (*o_wrapmargin & 0xff))
502: {
503: *key = '\n';
504: }
505: }
506:
507: /* process it */
508: switch (*key)
509: {
510: #ifndef NO_EXTENSIONS
511: case 0: /* special movement mapped keys */
512: *key = getkey(0);
513: switch (*key)
514: {
515: case 'h': m = m_left(cursor, 0L); break;
516: case 'j':
517: case 'k': m = m_updnto(cursor, 0L, *key); break;
518: case 'l': m = cursor + 1; break;
519: case 'b': m = m_bword(cursor, 0L); break;
520: case 'w': m = m_fword(cursor, 0L); break;
521: case '^': m = m_front(cursor, 0L); break;
522: case '$': m = m_rear(cursor, 0L); break;
523: case ctrl('B'):
524: case ctrl('F'):
525: m = m_scroll(cursor, 0L, *key); break;
526: case 'x': m = v_xchar(cursor, 0L); break;
527: case 'i': m = to = from = cursor; break;
528: default: m = MARK_UNSET; break;
529: }
530: /* adjust the moved cursor */
531: m = adjmove(cursor, m, (*key == 'j' || *key == 'k' ? 0x20 : 0));
532: if (*key == '$' || (*key == 'l' && m <= cursor))
533: {
534: m++;
535: }
536: /* if the cursor is reasonable, use it */
537: if (m == MARK_UNSET)
538: {
539: beep();
540: }
541: else
542: {
543: if (to > cursor)
544: {
545: delete(cursor, to);
546: redraw(cursor, TRUE);
547: }
548: from = to = cursor = m;
549: }
550: break;
551:
552: case ctrl('Z'):
553: if (getkey(0) == ctrl('Z'))
554: {
555: quit = TRUE;
556: goto BreakBreak;
557: }
558: break;
559: #endif
560:
561: case ctrl('['):
562: #ifndef NO_ABBR
563: cursor = expandabbr(cursor, ctrl('['));
564: #endif
565: goto BreakBreak;
566:
567: case ctrl('U'):
568: if (markline(cursor) == markline(from))
569: {
570: cursor = from;
571: }
572: else
573: {
574: cursor &= ~(BLKSIZE - 1);
575: }
576: break;
577:
578: case ctrl('D'):
579: case ctrl('T'):
580: if (to > cursor)
581: {
582: delete(cursor, to);
583: }
584: mark[27] = cursor;
585: cmd_shift(cursor, cursor, *key == ctrl('D') ? CMD_SHIFTL : CMD_SHIFTR, TRUE, "");
586: if (mark[27])
587: {
588: cursor = mark[27];
589: }
590: else
591: {
592: cursor = m_front(cursor, 0L);
593: }
594: to = cursor;
595: break;
596:
597: case '\b':
598: if (cursor <= from)
599: {
600: beep();
601: }
602: else if (markidx(cursor) == 0)
603: {
604: cursor -= BLKSIZE;
605: pfetch(markline(cursor));
606: cursor += plen;
607: }
608: else
609: {
610: cursor--;
611: }
612: break;
613:
614: case ctrl('W'):
615: m = m_bword(cursor, 1L);
616: if (markline(m) == markline(cursor) && m >= from)
617: {
618: cursor = m;
619: if (from > cursor)
620: {
621: from = cursor;
622: }
623: }
624: else
625: {
626: beep();
627: }
628: break;
629:
630: case '\n':
631: #if OSK
632: case '\l':
633: #else
634: case '\r':
635: #endif
636: #ifndef NO_ABBR
637: cursor = expandabbr(cursor, '\n');
638: #endif
639: build = tmpblk.c;
640: *build++ = '\n';
641: if (*o_autoindent)
642: {
643: /* figure out indent for next line */
644: pfetch(markline(cursor));
645: for (scan = ptext; *scan == ' ' || *scan == '\t'; )
646: {
647: *build++ = *scan++;
648: }
649:
650: /* remove indent from this line, if blank */
651: if (!*scan && plen > 0)
652: {
653: to = cursor &= ~(BLKSIZE - 1);
654: delete(cursor, cursor + plen);
655: }
656: }
657: *build = 0;
658: if (cursor >= to && when != WHEN_VIREP)
659: {
660: add(cursor, tmpblk.c);
661: }
662: else
663: {
664: change(cursor, to, tmpblk.c);
665: }
666: redraw(cursor, TRUE);
667: to = cursor = (cursor & ~(BLKSIZE - 1))
668: + BLKSIZE
669: + (int)(build - tmpblk.c) - 1;
670: break;
671:
672: case ctrl('A'):
673: case ctrl('P'):
674: if (cursor < to)
675: {
676: delete(cursor, to);
677: }
678: if (*key == ctrl('A'))
679: {
680: cutname('.');
681: }
682: to = cursor = paste(cursor, FALSE, TRUE) + 1L;
683: break;
684:
685: case ctrl('V'):
686: if (cursor >= to && when != WHEN_VIREP)
687: {
688: add(cursor, "^");
689: }
690: else
691: {
692: change(cursor, to, "^");
693: to = cursor + 1;
694: }
695: redraw(cursor, TRUE);
696: *key = getkey(0);
697: if (*key == '\n')
698: {
699: /* '\n' too hard to handle */
700: #if OSK
701: *key = '\l';
702: #else
703: *key = '\r';
704: #endif
705: }
706: change(cursor, cursor + 1, key);
707: cursor++;
708: if (cursor > to)
709: {
710: to = cursor;
711: }
712: break;
713:
714: case ctrl('L'):
715: case ctrl('R'):
716: redraw(MARK_UNSET, FALSE);
717: break;
718:
719: default:
720: if (cursor >= to && when != WHEN_VIREP)
721: {
722: #ifndef NO_ABBR
723: cursor = expandabbr(cursor, *key);
724: #endif
725: add(cursor, key);
726: cursor++;
727: to = cursor;
728: }
729: else
730: {
731: pfetch(markline(cursor));
732: if (markidx(cursor) == plen)
733: {
734: #ifndef NO_ABBR
735: cursor = expandabbr(cursor, *key);
736: #endif
737: add(cursor, key);
738: }
739: else
740: {
741: #ifndef NO_DIGRAPH
742: *key = digraph(ptext[markidx(cursor)], *key);
743: #endif
744: #ifndef NO_ABBR
745: cursor = expandabbr(cursor, *key);
746: #endif
747: change(cursor, cursor + 1, key);
748: }
749: cursor++;
750: }
751: #ifndef NO_SHOWMATCH
752: /* show matching "({[" if neceesary */
753: if (*o_showmatch && strchr(")}]", *key))
754: {
755: m = m_match(cursor - 1, 0L);
756: if (markline(m) >= topline
757: && markline(m) <= botline)
758: {
759: redraw(m, TRUE);
760: refresh();
761: sleep(1);
762: }
763: }
764: #endif
765: } /* end switch(*key) */
766: } /* end for(;;) */
767: BreakBreak:;
768:
769: /* delete any excess characters */
770: if (cursor < to)
771: {
772: delete(cursor, to);
773: }
774:
775: } /* end if doingdot else */
776:
777: } /* end ChangeText */
778:
779: /* put the new text into a cut buffer for possible reuse */
780: if (!doingdot)
781: {
782: blksync();
783: cutname('.');
784: cut(from, cursor);
785: }
786:
787: /* move to last char that we inputted, unless it was newline */
788: if (markidx(cursor) != 0)
789: {
790: cursor--;
791: }
792: redraw(cursor, FALSE);
793:
794: #ifndef NO_EXTENSIONS
795: if (quit)
796: {
797: refresh();
798: cursor = v_xit(cursor, 0L, 'Z');
799: }
800: #endif
801:
802: rptlines = 0L;
803: return cursor;
804: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.