| blob | 96a6c42aca96327d7cc6986b8ecc822264498c32 |
1 /* $NetBSD: v_txt.c,v 1.4 2014/01/26 21:43:45 christos Exp $ */
2 /*-
3 * Copyright (c) 1993, 1994
4 * The Regents of the University of California. All rights reserved.
5 * Copyright (c) 1992, 1993, 1994, 1995, 1996
6 * Keith Bostic. All rights reserved.
7 *
8 * See the LICENSE file for redistribution information.
9 */
13 #include <sys/cdefs.h>
14 #if 0
15 #ifndef lint
16 static const char sccsid[] = "Id: v_txt.c,v 10.108 2003/07/18 21:27:42 skimo Exp (Berkeley) Date: 2003/07/18 21:27:42 ";
18 #else
20 #endif
22 #include <sys/types.h>
23 #include <sys/queue.h>
24 #include <sys/stat.h>
25 #include <sys/time.h>
27 #include <bitstring.h>
28 #include <ctype.h>
29 #include <errno.h>
30 #include <limits.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <unistd.h>
59 /* Cursor character (space is hard to track on the screen). */
60 #if defined(DEBUG) && 0
61 #undef CH_CURSOR
63 #endif
65 /*
66 * v_tcmd --
67 * Fill a buffer from the terminal for vi.
68 *
69 * PUBLIC: int v_tcmd __P((SCR *, VICMD *, ARG_CHAR_T, u_int));
70 */
71 int
73 {
74 /* Normally, we end up where we started. */
78 /* Initialize the map. */
82 /* Move to the last line. */
86 /* Don't update the modeline for now. */
89 /* Set the input flags. */
97 /* Do the input thing. */
101 /* Reenable the modeline updates. */
104 /* Clean up the map. */
111 /* Set the cursor to the resulting position. */
116 }
118 /*
119 * txt_map_init
120 * Initialize the screen map for colon command-line input.
121 */
122 static int
124 {
130 /*
131 * Fake like the user is doing input on the last line of the
132 * screen. This makes all of the scrolling work correctly,
133 * and allows us the use of the vi text editing routines, not
134 * to mention practically infinite length ex commands.
135 *
136 * Save the current location.
137 */
145 /*
146 * If it's a small screen, TMAP may be small for the screen.
147 * Fix it, filling in fake lines as we go.
148 */
155 }
157 /* Build the fake entry. */
164 /* Reset the screen information. */
166 }
168 }
170 /*
171 * txt_map_end
172 * Reset the screen map for colon command-line input.
173 */
174 static int
176 {
182 /* Restore the screen information. */
187 /*
188 * If it's a small screen, TMAP may be wrong. Clear any
189 * lines that might have been overwritten.
190 */
195 }
200 /*
201 * The map may be wrong if the user entered more than one
202 * (logical) line. Fix it. If the user entered a whole
203 * screen, this will be slow, but we probably don't care.
204 */
210 }
212 /*
213 * Invalidate the cursor and the line size cache, the line never
214 * really existed. This fixes bugs where the user searches for
215 * the last line on the screen + 1 and the refresh routine thinks
216 * that's where we just were.
217 */
222 }
224 /*
225 * If doing input mapping on the colon command line, may need to unmap
226 * based on the command.
227 */
228 #define UNMAP_TST \
229 FL_ISSET(ec_flags, EC_MAPINPUT) && LF_ISSET(TXT_INFOLINE)
231 /*
232 * Internally, we maintain tp->lno and tp->cno, externally, everyone uses
233 * sp->lno and sp->cno. Make them consistent as necessary.
234 */
235 #define UPDATE_POSITION(sp, tp) { \
236 (sp)->lno = (tp)->lno; \
237 (sp)->cno = (tp)->cno; \
238 }
240 /*
241 * v_txt --
242 * Vi text input.
243 *
244 * PUBLIC: int v_txt __P((SCR *, VICMD *, MARK *,
245 * PUBLIC: const CHAR_T *, size_t, ARG_CHAR_T, db_recno_t, u_long, u_int32_t));
246 */
247 int
248 v_txt(SCR *sp, VICMD *vp, MARK *tm, const CHAR_T *lp, size_t len, ARG_CHAR_T prompt, db_recno_t ai_line, u_long rcount, u_int32_t flags)
251 /* To MARK. */
252 /* Input line. */
253 /* Input line length. */
254 /* Prompt to display. */
255 /* Line number to use for autoindent count. */
256 /* Replay count. */
257 /* TXT_* flags. */
258 {
277 u_int8_t is_flags;
292 /*
293 * Set the input flag, so tabs get displayed correctly
294 * and everyone knows that the text buffer is in use.
295 */
298 /*
299 * Get one TEXT structure with some initial buffer space, reusing
300 * the last one if it's big enough. (All TEXT bookkeeping fields
301 * default to 0 -- text_init() handles this.) If changing a line,
302 * copy it into the TEXT buffer.
303 */
310 }
322 }
324 /* Set default termination condition. */
327 /* Set the starting line, column. */
331 /*
332 * Set the insert and overwrite counts. If overwriting characters,
333 * do insertion afterward. If not overwriting characters, assume
334 * doing insertion. If change is to a mark, emphasize it with an
335 * CH_ENDMARK character.
336 */
346 }
348 /*
349 * Many of the special cases in text input are to handle autoindent
350 * support. Somebody decided that it would be a good idea if "^^D"
351 * and "0^D" deleted all of the autoindented characters. In an editor
352 * that takes single character input from the user, this beggars the
353 * imagination. Note also, "^^D" resets the next lines' autoindent,
354 * but "0^D" doesn't.
355 *
356 * We assume that autoindent only happens on empty lines, so insert
357 * and overwrite will be zero. If doing autoindent, figure out how
358 * much indentation we need and fill it in. Update input column and
359 * screen cursor as necessary.
360 */
366 /*
367 * The cc and S commands have a special feature -- leading
368 * <blank> characters are handled as autoindent characters.
369 * Beauty!
370 */
376 }
378 /* If getting a command buffer from the user, there may be a prompt. */
383 }
385 /*
386 * If appending after the end-of-line, add a space into the buffer
387 * and move the cursor right. This space is inserted, i.e. pushed
388 * along, and then deleted when the line is resolved. Assumes that
389 * the cursor is already positioned at the end of the line. This
390 * avoids the nastiness of having the cursor reside on a magical
391 * column, i.e. a column that doesn't really exist. The only down
392 * side is that we may wrap lines or scroll the screen before it's
393 * strictly necessary. Not a big deal.
394 */
400 }
402 /*
403 * Historic practice is that the wrapmargin value was a distance
404 * from the RIGHT-HAND margin, not the left. It's more useful to
405 * us as a distance from the left-hand margin, i.e. the same as
406 * the wraplen value. The wrapmargin option is historic practice.
407 * Nvi added the wraplen option so that it would be possible to
408 * edit files with consistent margins without knowing the number of
409 * columns in the window.
410 *
411 * XXX
412 * Setting margin causes a significant performance hit. Normally
413 * we don't update the screen if there are keys waiting, but we
414 * have to if margin is set, otherwise the screen routines don't
415 * know where the cursor is.
416 *
417 * !!!
418 * Abbreviated keys were affected by the wrapmargin option in the
419 * historic 4BSD vi. Mapped keys were usually, but sometimes not.
420 * See the comment in vi/v_text():set_txt_std for more information.
421 *
422 * !!!
423 * One more special case. If an inserted <blank> character causes
424 * wrapmargin to split the line, the next user entered character is
425 * discarded if it's a <space> character.
426 */
431 else
433 else
436 /* Initialize abbreviation checks. */
441 /*
442 * Set up the dot command. Dot commands are done by saving the actual
443 * characters and then reevaluating them so that things like wrapmargin
444 * can change between the insert and the replay.
445 *
446 * !!!
447 * Historically, vi did not remap or reabbreviate replayed input. (It
448 * did beep at you if you changed an abbreviation and then replayed the
449 * input. We're not that compatible.) We don't have to do anything to
450 * avoid remapping, as we're not getting characters from the terminal
451 * routines. Turn the abbreviation check off.
452 *
453 * XXX
454 * It would be nice if we could swallow backspaces and such, but it's
455 * not all that easy to do. What we can do is turn off the common
456 * error messages during the replay. Otherwise, when the user enters
457 * an illegal command, e.g., "Ia<erase><erase><erase><erase>b<escape>",
458 * and then does a '.', they get a list of error messages after command
459 * completion.
460 */
465 }
467 /* Other text input mode setup. */
475 /* Initialize input flags. */
478 /* Refresh the screen. */
483 /* If it's dot, just do it now. */
487 /* Get an event. */
492 /*
493 * If file completion overwrote part of the screen and nothing else has
494 * been displayed, clean up. We don't do this as part of the normal
495 * message resolution because we know the user is on the colon command
496 * line and there's no reason to enter explicit characters to continue.
497 */
508 }
510 /* Deal with all non-character events. */
519 /*
520 * !!!
521 * Historically, <interrupt> exited the user from text input
522 * mode or cancelled a colon command, and returned to command
523 * mode. It also beeped the terminal, but that seems a bit
524 * excessive.
525 */
532 /* <resize> interrupts the input mode. */
538 }
540 /*
541 * !!!
542 * If the first character of the input is a nul, replay the previous
543 * input. (Historically, it's okay to replay non-existent input.)
544 * This was not documented as far as I know, and is a great test of vi
545 * clones.
546 */
555 }
557 /*
558 * File name completion and colon command-line editing. We don't
559 * have enough meta characters, so we expect people to overload
560 * them. If the two characters are the same, then we do file name
561 * completion if the cursor is past the first column, and do colon
562 * command-line editing if it's not.
563 */
577 }
582 }
583 }
585 /* Abbreviation overflow check. See comment in txt_abbrev(). */
586 #define MAX_ABBREVIATION_EXPANSION 256
596 }
600 /* Check to see if the character fits into the replay buffers. */
605 }
611 }
613 /* Wrapmargin check for leading space. */
618 }
620 /* If quoted by someone else, simply insert the character. */
624 /*
625 * !!!
626 * If this character was quoted by a K_VLNEXT or a backslash, replace
627 * the placeholder (a carat or a backslash) with the new character.
628 * If it was quoted by a K_VLNEXT, we've already adjusted the cursor
629 * because it has to appear on top of the placeholder character. If
630 * it was quoted by a backslash, adjust the cursor now, the cursor
631 * doesn't appear on top of it. Historic practice in both cases.
632 *
633 * Skip tests for abbreviations; ":ab xa XA" followed by "ixa^V<space>"
634 * doesn't perform an abbreviation. Special case, ^V^J (not ^V^M) is
635 * the same as ^J, historically.
636 */
648 }
652 }
654 }
656 /*
657 * !!!
658 * Translate "<CH_HEX>[isxdigit()]*" to a character with a hex value:
659 * this test delimits the value by any non-hex character. Offset by
660 * one, we use 0 to mean that we've found <CH_HEX>.
661 */
666 }
671 /* Return in script windows and the command line. */
674 /*
675 * If this was a map, we may have not displayed
676 * the line. Display it, just in case.
677 *
678 * If a script window and not the colon line,
679 * push a <cr> so it gets executed.
680 */
687 /* Set term condition: if empty. */
690 /*
691 * Set term condition: if searching incrementally and
692 * the user entered a pattern, return a completed
693 * search, regardless if the entire pattern was found.
694 */
700 }
702 #define LINE_RESOLVE { \
703 /* \
704 * Handle abbreviations. If there was one, discard the \
705 * replay characters. \
707 if (abb == AB_INWORD && \
708 !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) { \
709 if (txt_abbrev(sp, tp, &evp->e_c, \
710 LF_ISSET(TXT_INFOLINE), &tmp, \
711 &ab_turnoff)) \
712 goto err; \
713 if (tmp) { \
714 if (LF_ISSET(TXT_RECORD)) \
715 rcol -= tmp + 1; \
716 goto resolve; \
717 } \
718 } \
719 if (abb != AB_NOTSET) \
720 abb = AB_NOTWORD; \
721 if (UNMAP_TST) \
722 txt_unmap(sp, tp, &ec_flags); \
723 /* \
724 * Delete any appended cursor. It's possible to get in \
725 * situations where TXT_APPENDEOL is set but tp->insert \
726 * is 0 when using the R command and all the characters \
727 * are tp->owrite characters. \
729 if (LF_ISSET(TXT_APPENDEOL) && tp->insert > 0) { \
730 --tp->len; \
731 --tp->insert; \
732 } \
733 }
734 LINE_RESOLVE;
736 /*
737 * Save the current line information for restoration in
738 * txt_backup(), and set the line final length.
739 */
744 /* Update the old line. */
748 /*
749 * Historic practice, when the autoindent edit option was set,
750 * was to delete <blank> characters following the inserted
751 * newline. This affected the 'R', 'c', and 's' commands; 'c'
752 * and 's' retained the insert characters only, 'R' moved the
753 * overwrite and insert characters into the next TEXT structure.
754 * We keep track of the number of characters erased for the 'R'
755 * command so that the final resolution of the line is correct.
756 */
772 }
774 /*
775 * !!!
776 * Create a new line and insert the new TEXT into the queue.
777 * DON'T insert until the old line has been updated, or the
778 * inserted line count in line.c:db_get() will be wrong.
779 */
785 /* Set up bookkeeping for the new line. */
790 /*
791 * Reset the autoindent line value. 0^D keeps the autoindent
792 * line from changing, ^D changes the level, even if there were
793 * no characters in the old line. Note, if using the current
794 * tp structure, use the cursor as the length, the autoindent
795 * characters may have been erased.
796 */
807 }
809 /* Reset the cursor. */
812 /*
813 * If we're here because wrapmargin was set and we've broken a
814 * line, there may be additional information (i.e. the start of
815 * a line) in the wmt structure.
816 */
820 #define WMTSPACE wmt.offset + wmt.owrite + wmt.insert
828 }
830 }
832 /* New lines are TXT_APPENDEOL. */
839 }
841 /* Swap old and new TEXT's, and update the new line. */
851 /* If we have a count, start replaying the input. */
861 /*
862 * Some commands (e.g. 'o') need a <newline> for each
863 * repetition.
864 */
868 /*
869 * The R command turns into the 'a' command after the
870 * first repetition.
871 */
876 }
878 }
880 /* Set term condition: if empty. */
883 /*
884 * Set term condition: if searching incrementally and the user
885 * entered a pattern, return a completed search, regardless if
886 * the entire pattern was found.
887 */
893 /*
894 * Clean up for the 'R' command, restoring overwrite
895 * characters, and making them into insert characters.
896 */
900 /*
901 * If there are any overwrite characters, copy down
902 * any insert characters, and decrement the length.
903 */
909 }
911 /*
912 * Optionally resolve the lines into the file. If not
913 * resolving the lines into the file, end the line with
914 * a nul. If the line is empty, then set the length to
915 * 0, the termination condition has already been set.
916 *
917 * XXX
918 * This is wrong, should pass back a length.
919 */
926 }
928 /*
929 * Set the return cursor position to rest on the last
930 * inserted character.
931 */
935 /* Update the last line. */
948 /*
949 * If in the first column or no characters to erase, ignore
950 * the ^D (this matches historic practice). If not doing
951 * autoindent or already inserted non-ai characters, it's a
952 * literal. The latter test is done in the switch, as the
953 * CARAT forms are N + 1, not N.
954 */
965 /* Save the ai string for later. */
992 }
995 /* If can erase over the prompt, return. */
999 }
1001 /*
1002 * If at the beginning of the line, try and drop back to a
1003 * previously inserted line.
1004 */
1011 }
1013 /* If nothing to erase, bell the user. */
1018 }
1020 /* Drop back one character. */
1023 /*
1024 * Historically, vi didn't replace the erased characters with
1025 * <blank>s, presumably because it's easier to fix a minor
1026 * typing mistake and continue on if the previous letters are
1027 * already there. This is a problem for incremental searching,
1028 * because the user can no longer tell where they are in the
1029 * colon command line because the cursor is at the last search
1030 * point in the screen. So, if incrementally searching, erase
1031 * the erased characters from the screen.
1032 */
1036 /*
1037 * Increment overwrite, decrement ai if deleted.
1038 *
1039 * !!!
1040 * Historic vi did not permit users to use erase characters
1041 * to delete autoindent characters. We do. Eat hot death,
1042 * POSIX.
1043 */
1048 /* Reset if we deleted an incremental search character. */
1053 /*
1054 * If at the beginning of the line, try and drop back to a
1055 * previously inserted line.
1056 */
1062 }
1064 /*
1065 * If at offset, nothing to erase so bell the user.
1066 */
1071 }
1073 /*
1074 * The first werase goes back to any autoindent column and the
1075 * second werase goes back to the offset.
1076 *
1077 * !!!
1078 * Historic vi did not permit users to use erase characters to
1079 * delete autoindent characters.
1080 */
1086 }
1088 /* Skip over trailing space characters. */
1092 }
1095 /*
1096 * There are three types of word erase found on UNIX systems.
1097 * They can be identified by how the string /a/b/c is treated
1098 * -- as 1, 3, or 6 words. Historic vi had two classes of
1099 * characters, and strings were delimited by them and
1100 * <blank>'s, so, 6 words. The historic tty interface used
1101 * <blank>'s to delimit strings, so, 1 word. The algorithm
1102 * offered in the 4.4BSD tty interface (as stty altwerase)
1103 * treats it as 3 words -- there are two classes of
1104 * characters, and strings are delimited by them and
1105 * <blank>'s. The difference is that the type of the first
1106 * erased character erased is ignored, which is exactly right
1107 * when erasing pathname components. The edit options
1108 * TXT_ALTWERASE and TXT_TTYWERASE specify the 4.4BSD tty
1109 * interface and the historic tty driver behavior,
1110 * respectively, and the default is the same as the historic
1111 * vi behavior.
1112 *
1113 * Overwrite erased characters if doing incremental search;
1114 * see comment above.
1115 */
1124 }
1133 }
1144 }
1145 }
1147 /* Reset if we deleted an incremental search character. */
1152 /*
1153 * !!!
1154 * If at the beginning of the line, try and drop back to a
1155 * previously inserted line. Historic vi did not permit
1156 * users to go back to previous lines.
1157 */
1163 }
1165 /* If at offset, nothing to erase so bell the user. */
1170 }
1172 /*
1173 * First kill goes back to any autoindent and second kill goes
1174 * back to the offset.
1175 *
1176 * !!!
1177 * Historic vi did not permit users to use erase characters to
1178 * delete autoindent characters.
1179 */
1185 }
1188 /*
1189 * Overwrite erased characters if doing incremental search;
1190 * see comment above.
1191 */
1196 else
1199 /* Reset if we deleted an incremental search character. */
1215 /*
1216 * !!!
1217 * Historic vi tried to make abbreviations after a backslash
1218 * escape work. If you did ":ab x y", and inserted "x\^H",
1219 * (assuming the erase character was ^H) you got "x^H", and
1220 * no abbreviation was done. If you inserted "x\z", however,
1221 * it tried to back up and do the abbreviation, i.e. replace
1222 * 'x' with 'y'. The problem was it got it wrong, and you
1223 * ended up with "zy\".
1224 *
1225 * This is really hard to do (you have to remember the
1226 * word/non-word state, for example), and doesn't make any
1227 * sense to me. Both backslash and the characters it
1228 * (usually) escapes will individually trigger the
1229 * abbreviation, so I don't see why the combination of them
1230 * wouldn't. I don't expect to get caught on this one,
1231 * particularly since it never worked right, but I've been
1232 * wrong before.
1233 *
1234 * Do the tests for abbreviations, so ":ab xa XA",
1235 * "ixa\<K_VERASE>" performs the abbreviation.
1236 */
1242 /*
1243 * Turn on the quote flag so that the underlying routines
1244 * quote the next character where it's possible. Turn off
1245 * the input mapbiting flag so that we don't remap the next
1246 * character.
1247 */
1251 /*
1252 * !!!
1253 * Skip the tests for abbreviations, so ":ab xa XA",
1254 * "ixa^V<space>" doesn't perform the abbreviation.
1255 */
1262 * Historically, vi eliminated nul's out of hand. If the
1263 * beautify option was set, it also deleted any unknown
1264 * ASCII value less than space (040) and the del character
1265 * (0177), except for tabs. Unknown is a key word here.
1266 * Most vi documentation claims that it deleted everything
1267 * but <tab>, <nl> and <ff>, as that's what the original
1268 * 4BSD documentation said. This is obviously wrong,
1269 * however, as <esc> would be included in that list. What
1270 * we do is eliminate any unquoted, iscntrl() character that
1271 * wasn't a replay and wasn't handled specially, except
1272 * <tab> or <ff>.
1273 */
1281 }
1284 * If entering a non-word character after a word, check for
1285 * abbreviations. If there was one, discard replay characters.
1286 * If entering a blank character, check for unmap commands,
1287 * as well.
1288 */
1299 }
1300 }
1303 }
1310 /*
1311 * If we're using K_VLNEXT to quote the next character, then
1312 * we want the cursor to position itself on the ^ placeholder
1313 * we're displaying, to match historic practice.
1314 */
1318 }
1320 /*
1321 * !!!
1322 * Translate "<CH_HEX>[isxdigit()]*" to a character with
1323 * a hex value: this test delimits the value by the max
1324 * number of hex bytes. Offset by one, we use 0 to mean
1325 * that we've found <CH_HEX>.
1326 */
1331 }
1333 /*
1334 * Check to see if we've crossed the margin.
1335 *
1336 * !!!
1337 * In the historic vi, the wrapmargin value was figured out
1338 * using the display widths of the characters, i.e. <tab>
1339 * characters were counted as two characters if the list edit
1340 * option is set, but as the tabstop edit option number of
1341 * characters otherwise. That's what the vs_column() function
1342 * gives us, so we use it.
1343 */
1355 }
1356 }
1357 }
1359 /*
1360 * If we've reached the end of the buffer, then we need to
1361 * switch into insert mode. This happens when there's a
1362 * change to a mark and the user puts in more characters than
1363 * the length of the motion.
1364 */
1372 }
1374 /* Step the quote state forward. */
1380 }
1382 }
1384 #ifdef DEBUG
1392 }
1393 #endif
1396 * 1: If we don't need to know where the cursor really is and we're
1397 * replaying text, keep going.
1398 */
1402 /*
1403 * 2: Reset the line. Don't bother unless we're about to wait on
1404 * a character or we need to know where the cursor really is.
1405 * We have to do this before showing matching characters so the
1406 * user can see what they're matching.
1407 */
1412 /*
1413 * 3: If there aren't keys waiting, display the matching character.
1414 * We have to do this before resolving any messages, otherwise
1415 * the error message from a missing match won't appear correctly.
1416 */
1421 }
1423 /*
1424 * 4: If there have been messages and we're not editing on the colon
1425 * command line or doing file name completion, resolve them.
1426 */
1432 /*
1433 * 5: Refresh the screen if we're about to wait on a character or we
1434 * need to know where the cursor really is.
1435 */
1440 }
1442 /* 6: Proceed with the incremental search. */
1446 /* 7: Next character... */
1454 /* If recording for playback, save it. */
1458 /*
1459 * If not working on the colon command line, set the final cursor
1460 * position.
1461 */
1465 }
1468 err:
1469 alloc_err:
1473 }
1475 /*
1476 * txt_abbrev --
1477 * Handle abbreviations.
1478 */
1479 static int
1481 {
1486 /* Check to make sure we're not at the start of an append. */
1491 /*
1492 * Find the start of the "word".
1493 *
1494 * !!!
1495 * We match historic practice, which, as far as I can tell, had an
1496 * off-by-one error. The way this worked was that when the inserted
1497 * text switched from a "word" character to a non-word character,
1498 * vi would check for possible abbreviations. It would then take the
1499 * type (i.e. word/non-word) of the character entered TWO characters
1500 * ago, and move backward in the text until reaching a character that
1501 * was not that type, or the beginning of the insert, the line, or
1502 * the file. For example, in the string "abc<space>", when the <space>
1503 * character triggered the abbreviation check, the type of the 'b'
1504 * character was used for moving through the string. Maybe there's a
1505 * reason for not using the first (i.e. 'c') character, but I can't
1506 * think of one.
1507 *
1508 * Terminate at the beginning of the insert or the character after the
1509 * offset character -- both can be tested for using tp->offset.
1510 */
1521 }
1522 else
1528 }
1530 /*
1531 * !!!
1532 * Historic vi exploded abbreviations on the command line. This has
1533 * obvious problems in that unabbreviating the string can be extremely
1534 * tricky, particularly if the string has, say, an embedded escape
1535 * character. Personally, I think it's a stunningly bad idea. Other
1536 * examples of problems this caused in historic vi are:
1537 * :ab foo bar
1538 * :ab foo baz
1539 * results in "bar" being abbreviated to "baz", which wasn't what the
1540 * user had in mind at all. Also, the commands:
1541 * :ab foo bar
1542 * :unab foo<space>
1543 * resulted in an error message that "bar" wasn't mapped. Finally,
1544 * since the string was already exploded by the time the unabbreviate
1545 * command got it, all it knew was that an abbreviation had occurred.
1546 * Cleverly, it checked the replacement string for its unabbreviation
1547 * match, which meant that the commands:
1548 * :ab foo1 bar
1549 * :ab foo2 bar
1550 * :unab foo2
1551 * unabbreviate "foo1", and the commands:
1552 * :ab foo bar
1553 * :ab bar baz
1554 * unabbreviate "foo"!
1555 *
1556 * Anyway, people neglected to first ask my opinion before they wrote
1557 * macros that depend on this stuff, so, we make this work as follows.
1558 * When checking for an abbreviation on the command line, if we get a
1559 * string which is <blank> terminated and which starts at the beginning
1560 * of the line, we check to see it is the abbreviate or unabbreviate
1561 * commands. If it is, turn abbreviations off and return as if no
1562 * abbreviation was found. Note also, minor trickiness, so that if
1563 * the user erases the line and starts another command, we turn the
1564 * abbreviations back on.
1565 *
1566 * This makes the layering look like a Nachos Supreme.
1567 */
1575 else
1578 }
1580 /* Check for any abbreviations. */
1584 /*
1585 * Push the abbreviation onto the tty stack. Historically, characters
1586 * resulting from an abbreviation expansion were themselves subject to
1587 * map expansions, O_SHOWMATCH matching etc. This means the expanded
1588 * characters will be re-tested for abbreviations. It's difficult to
1589 * know what historic practice in this case was, since abbreviations
1590 * were applied to :colon command lines, so entering abbreviations that
1591 * looped was tricky, although possible. In addition, obvious loops
1592 * didn't work as expected. (The command ':ab a b|ab b c|ab c a' will
1593 * silently only implement and/or display the last abbreviation.)
1594 *
1595 * This implementation doesn't recover well from such abbreviations.
1596 * The main input loop counts abbreviated characters, and, when it
1597 * reaches a limit, discards any abbreviated characters on the queue.
1598 * It's difficult to back up to the original position, as the replay
1599 * queue would have to be adjusted, and the line state when an initial
1600 * abbreviated character was received would have to be saved.
1601 */
1608 /*
1609 * If the size of the abbreviation is larger than or equal to the size
1610 * of the original text, move to the start of the replaced characters,
1611 * and add their length to the overwrite count.
1612 *
1613 * If the abbreviation is smaller than the original text, we have to
1614 * delete the additional overwrite characters and copy down any insert
1615 * characters.
1616 */
1626 }
1628 /*
1629 * We return the length of the abbreviated characters. This is so
1630 * the calling routine can replace the replay characters with the
1631 * abbreviation. This means that subsequent '.' commands will produce
1632 * the same text, regardless of intervening :[un]abbreviate commands.
1633 * This is historic practice.
1634 */
1637 }
1639 /*
1640 * txt_unmap --
1641 * Handle the unmap command.
1642 */
1643 static void
1645 {
1649 /* Find the beginning of this "word". */
1654 }
1658 }
1660 /*
1661 * !!!
1662 * Historic vi exploded input mappings on the command line. See the
1663 * txt_abbrev() routine for an explanation of the problems inherent
1664 * in this.
1665 *
1666 * We make this work as follows. If we get a string which is <blank>
1667 * terminated and which starts at the beginning of the line, we check
1668 * to see it is the unmap command. If it is, we return that the input
1669 * mapping should be turned off. Note also, minor trickiness, so that
1670 * if the user erases the line and starts another command, we go ahead
1671 * an turn mapping back on.
1672 */
1675 else
1677 }
1679 /*
1680 * txt_ai_resolve --
1681 * When a line is resolved by <esc>, review autoindent characters.
1682 */
1683 static void
1685 {
1686 u_long ts;
1693 /*
1694 * If the line is empty, has an offset, or no autoindent
1695 * characters, we're done.
1696 */
1700 /*
1701 * If the length is less than or equal to the autoindent
1702 * characters, delete them.
1703 */
1707 }
1709 /*
1710 * The autoindent characters plus any leading <blank> characters
1711 * in the line are resolved into the minimum number of characters.
1712 * Historic practice.
1713 */
1716 /* Figure out the last <blank> screen column. */
1726 }
1728 /*
1729 * If there are no spaces, or no tabs after spaces and less than
1730 * ts spaces, it's already minimal.
1731 * Keep analysing if expandtab is set.
1732 */
1737 /* Count up spaces/tabs needed to get to the target. */
1743 }
1746 /*
1747 * Figure out how many characters we're dropping -- if we're not
1748 * dropping any, it's already minimal, we're done.
1749 */
1755 /* Shift the rest of the characters down, adjust the counts. */
1761 /* Fill in space/tab characters. */
1767 }
1769 /*
1770 * v_txt_auto --
1771 * Handle autoindent. If aitp isn't NULL, use it, otherwise,
1772 * retrieve the line.
1773 *
1774 * PUBLIC: int v_txt_auto __P((SCR *, db_recno_t, TEXT *, size_t, TEXT *));
1775 */
1776 int
1778 {
1783 /*
1784 * If the ex append command is executed with an address of 0,
1785 * it's possible to get here with a line number of 0. Return
1786 * an indent of 0.
1787 */
1791 }
1797 /* Count whitespace characters. */
1802 /* Set count, check for no indentation. */
1806 /* Make sure the buffer's big enough. */
1809 /* Copy the buffer's current contents up. */
1814 /* Copy the indentation into the new buffer. */
1817 /* Set the autoindent count. */
1820 }
1822 /*
1823 * txt_backup --
1824 * Back up to the previously edited line.
1825 */
1828 {
1831 /* Get a handle on the previous TEXT structure. */
1837 }
1839 /* Bookkeeping. */
1842 /* Handle appending to the line. */
1851 /* Release the current TEXT. */
1855 /* Update the old line on the screen. */
1859 /* Return the new/current TEXT. */
1861 }
1863 /*
1864 * Text indentation is truly strange. ^T and ^D do movements to the next or
1865 * previous shiftwidth value, i.e. for a 1-based numbering, with shiftwidth=3,
1866 * ^T moves a cursor on the 7th, 8th or 9th column to the 10th column, and ^D
1867 * moves it back.
1868 *
1869 * !!!
1870 * The ^T and ^D characters in historical vi had special meaning only when they
1871 * were the first characters entered after entering text input mode. As normal
1872 * erase characters couldn't erase autoindent characters (^T in this case), it
1873 * meant that inserting text into previously existing text was strange -- ^T
1874 * only worked if it was the first keystroke(s), and then could only be erased
1875 * using ^D. This implementation treats ^T specially anywhere it occurs in the
1876 * input, and permits the standard erase characters to erase the characters it
1877 * inserts.
1878 *
1879 * !!!
1880 * A fun test is to try:
1881 * :se sw=4 ai list
1882 * i<CR>^Tx<CR>^Tx<CR>^Tx<CR>^Dx<CR>^Dx<CR>^Dx<esc>
1883 * Historic vi loses some of the '$' marks on the line ends, but otherwise gets
1884 * it right.
1885 *
1886 * XXX
1887 * Technically, txt_dent should be part of the screen interface, as it requires
1888 * knowledge of character sizes, including <space>s, on the screen. It's here
1889 * because it's a complicated little beast, and I didn't want to shove it down
1890 * into the screen. It's probable that KEY_LEN will call into the screen once
1891 * there are screens with different character representations.
1892 *
1893 * txt_dent --
1894 * Handle ^T indents, ^D outdents.
1895 *
1896 * If anything changes here, check the ex version to see if it needs similar
1897 * changes.
1898 */
1899 static int
1901 {
1902 ARG_CHAR_T ch;
1909 /*
1910 * Since we don't know what precedes the character(s) being inserted
1911 * (or deleted), the preceding whitespace characters must be resolved.
1912 * An example is a <tab>, which doesn't need a full shiftwidth number
1913 * of columns because it's preceded by <space>s. This is easy to get
1914 * if the user sets shiftwidth to a value less than tabstop (or worse,
1915 * something for which tabstop isn't a multiple) and then uses ^T to
1916 * indent, and ^D to outdent.
1917 *
1918 * Figure out the current and target screen columns. In the historic
1919 * vi, the autoindent column was NOT determined using display widths
1920 * of characters as was the wrapmargin column. For that reason, we
1921 * can't use the vs_column() function, but have to calculate it here.
1922 * This is slow, but it's normally only on the first few characters of
1923 * a line.
1924 */
1935 }
1937 /*
1938 * Back up over any previous <blank> characters, changing them into
1939 * overwrite characters (including any ai characters). Then figure
1940 * out the current screen column.
1941 */
1949 /*
1950 * If we didn't move up to or past the target, it's because there
1951 * weren't enough characters to delete, e.g. the first character
1952 * of the line was a tp->offset character, and the user entered
1953 * ^D to move to the beginning of a line. An example of this is:
1954 *
1955 * :set ai sw=4<cr>i<space>a<esc>i^T^D
1956 *
1957 * Otherwise, count up the total spaces/tabs needed to get from the
1958 * beginning of the line (or the last non-<blank> character) to the
1959 * target.
1960 */
1969 }
1971 }
1975 /*
1976 * Call txt_insch() to insert each character, so that we get the
1977 * correct effect when we add a <tab> to replace N <spaces>.
1978 */
1984 }
1986 /*
1987 * txt_fc --
1988 * File name completion.
1989 */
1990 static int
1992 {
1995 CHAR_T s_ch;
1996 EXCMD cmd;
2006 /*
2007 * Find the beginning of this "word" -- if we're at the beginning
2008 * of the line, it's a special case.
2009 */
2019 }
2023 }
2025 /*
2026 * Get enough space for a wildcard character.
2027 *
2028 * XXX
2029 * This won't work for "foo\", since the \ will escape the expansion
2030 * character. I'm not sure if that's a bug or not...
2031 */
2039 /* Build an ex command, and call the ex expansion routines. */
2044 }
2056 /* If something changed, do the exchange. */
2061 /* If haven't done a directory test, do it now. */
2068 }
2070 /* If nothing changed, period, ring the bell. */
2079 /* Find the length of the shortest match. */
2087 }
2089 }
2091 /* Overwrite the expanded text first. */
2095 /* If lost text, make the remaining old text overwrite characters. */
2099 }
2101 /* Overwrite any overwrite characters next. */
2105 /* Shift remaining text up, and move the cursor to the end. */
2118 }
2120 /* If a single match and it's a directory, retry it. */
2138 }
2140 }
2142 /*
2143 * txt_fc_col --
2144 * Display file names for file name completion.
2145 */
2146 static int
2148 {
2160 /* Trim any directory prefix common to all of the files. */
2169 prefix)) {
2172 }
2173 }
2175 /*
2176 * Figure out the column width for the longest name. Output is done on
2177 * 6 character "tab" boundaries for no particular reason. (Since we
2178 * don't output tab characters, we ignore the terminal's tab settings.)
2179 * Ignore the user's tab setting because we have no idea how reasonable
2180 * it is.
2181 */
2187 }
2190 /*
2191 * Writing to the bottom line of the screen is always turned off when
2192 * SC_TINPUT_INFO is set. Turn it back on, we know what we're doing.
2193 */
2200 #define CHK_INTR \
2201 if (F_ISSET(gp, G_INTERRUPTED)) \
2202 goto intr;
2204 /* If the largest file name is too large, just print them. */
2213 }
2216 CHK_INTR;
2218 /* Figure out the number of columns. */
2227 /* Display the files in sorted order. */
2236 CHK_INTR;
2241 CHK_INTR;
2242 }
2244 CHK_INTR;
2245 }
2247 CHK_INTR;
2248 }
2253 }
2258 }
2260 /*
2261 * txt_emark --
2262 * Set the end mark on the line.
2263 */
2264 static int
2266 {
2267 CHAR_T ch;
2274 /*
2275 * The end mark may not be the same size as the current character.
2276 * Don't let the line shift.
2277 */
2281 else
2284 /*
2285 * If the line got longer, well, it's weird, but it's easy. If
2286 * it's the same length, it's easy. If it got shorter, we have
2287 * to fix it up.
2288 */
2302 else
2306 }
2309 }
2311 /*
2312 * txt_err --
2313 * Handle an error during input processing.
2314 */
2315 static void
2317 {
2318 db_recno_t lno;
2320 /*
2321 * The problem with input processing is that the cursor is at an
2322 * indeterminate position since some input may have been lost due
2323 * to a malloc error. So, try to go back to the place from which
2324 * the cursor started, knowing that it may no longer be available.
2325 *
2326 * We depend on at least one line number being set in the text
2327 * chain.
2328 */
2335 /* Redraw the screen, just in case. */
2337 }
2339 /*
2340 * txt_hex --
2341 * Let the user insert any character value they want.
2342 *
2343 * !!!
2344 * This is an extension. The pattern "^X[0-9a-fA-F]*" is a way
2345 * for the user to specify a character value which their keyboard
2346 * may not be able to enter.
2347 */
2348 static int
2350 {
2351 CHAR_T savec;
2356 /*
2357 * Null-terminate the string. Since nul isn't a legal hex value,
2358 * this should be okay, and lets us use a local routine, which
2359 * presumably understands the character set, to convert the value.
2360 */
2364 /* Find the previous CH_HEX character. */
2369 }
2370 /* Not on this line? Shouldn't happen. */
2373 }
2375 /* If length of 0, then it wasn't a hex value. */
2379 /* Get the value. */
2385 }
2387 /* Restore the original character. */
2390 /* Adjust the bookkeeping. */
2395 /* Copy down any overwrite characters. */
2400 /* Copy down any insert characters. */
2407 }
2409 /*
2410 * txt_insch --
2411 *
2412 * !!!
2413 * Historic vi did a special screen optimization for tab characters. As an
2414 * example, for the keystrokes "iabcd<esc>0C<tab>", the tab overwrote the
2415 * rest of the string when it was displayed.
2416 *
2417 * Because early versions of this implementation redisplayed the entire line
2418 * on each keystroke, the "bcd" was pushed to the right as it ignored that
2419 * the user had "promised" to change the rest of the characters. However,
2420 * the historic vi implementation had an even worse bug: given the keystrokes
2421 * "iabcd<esc>0R<tab><esc>", the "bcd" disappears, and magically reappears
2422 * on the second <esc> key.
2423 *
2424 * POSIX 1003.2 requires (will require) that this be fixed, specifying that
2425 * vi overwrite characters the user has committed to changing, on the basis
2426 * of the screen space they require, but that it not overwrite other characters.
2427 */
2428 static int
2430 {
2432 CHAR_T savech;
2436 /*
2437 * The 'R' command does one-for-one replacement, because there's
2438 * no way to know how many characters the user intends to replace.
2439 */
2445 }
2449 /*
2450 * If the old or new characters are tabs, then the length of the
2451 * display depends on the character position in the display. We
2452 * don't even try to handle this here, just ask the screen.
2453 */
2462 /*
2463 * Eat overwrite characters until we run out of them or we've
2464 * handled the length of the new character. If we only eat
2465 * part of an overwrite character, break it into its component
2466 * elements and display the remaining components.
2467 */
2474 else
2480 }
2497 else
2504 }
2505 }
2507 /*
2508 * If had to erase several characters, we adjust the total
2509 * count, and if there are any characters left, shift them
2510 * into position.
2511 */
2516 /* If we had enough overwrite characters, we're done. */
2520 }
2521 }
2523 /* Check to see if the character fits into the input buffer. */
2530 else
2533 }
2536 }
2538 /*
2539 * txt_isrch --
2540 * Do an incremental search.
2541 */
2542 static int
2544 {
2545 MARK start;
2546 db_recno_t lno;
2547 u_int sf;
2549 /* If it's a one-line screen, we don't do incrementals. */
2553 }
2555 /*
2556 * If the user erases back to the beginning of the buffer, there's
2557 * nothing to search for. Reset the cursor to the starting point.
2558 */
2562 }
2564 /*
2565 * If it's an RE quote character, and not quoted, ignore it until
2566 * we get another character.
2567 */
2572 /*
2573 * If it's a magic shell character, and not quoted, reset the cursor
2574 * to the starting point.
2575 */
2580 /*
2581 * If we see the search pattern termination character, then quit doing
2582 * an incremental search. There may be more, e.g., ":/foo/;/bar/",
2583 * and we can't handle that incrementally. Also, reset the cursor to
2584 * the original location, the ex search routines don't know anything
2585 * about incremental searches.
2586 */
2592 }
2594 /*
2595 * Remember the input line and discard the special input map,
2596 * but don't overwrite the input line on the screen.
2597 */
2604 /*
2605 * Specify a starting point and search. If we find a match, move to
2606 * it and refresh the screen. If we didn't find the match, then we
2607 * beep the screen. When searching from the original cursor position,
2608 * we have to move the cursor, otherwise, we don't want to move the
2609 * cursor in case the text at the current position continues to match.
2610 */
2617 }
2633 /* Reinstantiate the special input map. */
2639 /* Reset the line number of the input line. */
2642 /*
2643 * If the colon command-line moved, i.e. the screen scrolled,
2644 * refresh the input line.
2645 *
2646 * XXX
2647 * We shouldn't be calling vs_line, here -- we need dirty bits
2648 * on entries in the SMAP array.
2649 */
2654 }
2656 }
2658 /*
2659 * txt_resolve --
2660 * Resolve the input text chain into the file.
2661 */
2662 static int
2664 {
2666 db_recno_t lno;
2669 /*
2670 * The first line replaces a current line, and all subsequent lines
2671 * are appended into the file. Resolve autoindented characters for
2672 * each line before committing it. If the latter causes the line to
2673 * change, we have to redisplay it, otherwise the information cached
2674 * about the line will be wrong.
2675 */
2680 else
2689 else
2694 }
2696 /*
2697 * Clear the input flag, the look-aside buffer is no longer valid.
2698 * Has to be done as part of text resolution, or upon return we'll
2699 * be looking at incorrect data.
2700 */
2704 }
2706 /*
2707 * txt_showmatch --
2708 * Show a character match.
2709 *
2710 * !!!
2711 * Historic vi tried to display matches even in the :colon command line.
2712 * I think not.
2713 */
2714 static int
2716 {
2717 VCS cs;
2718 MARK m;
2721 /*
2722 * Do a refresh first, in case we haven't done one in awhile,
2723 * so the user can see what we're complaining about.
2724 */
2729 /*
2730 * We don't display the match if it's not on the screen. Find
2731 * out what the first character on the screen is.
2732 */
2736 /* Initialize the getc() interface. */
2743 /* Search for the match. */
2752 }
2754 }
2759 }
2761 /* If the match is on the screen, move to it. */
2769 /* Wait for timeout or character arrival. */
2772 }
2774 /*
2775 * txt_margin --
2776 * Handle margin wrap.
2777 */
2778 static int
2780 {
2784 /* Find the nearest previous blank. */
2788 }
2790 /*
2791 * If reach the start of the line, there's nowhere to break.
2792 *
2793 * !!!
2794 * Historic vi belled each time a character was entered after
2795 * crossing the margin until a space was entered which could
2796 * be used to break the line. I don't as it tends to wake the
2797 * cats.
2798 */
2802 }
2803 }
2805 /*
2806 * Store saved information about the rest of the line in the
2807 * wrapmargin TEXT structure.
2808 *
2809 * !!!
2810 * The offset field holds the length of the current characters
2811 * that the user entered, but which are getting split to the new
2812 * line -- it's going to be used to set the cursor value when we
2813 * move to the new line.
2814 */
2820 /* Correct current bookkeeping information. */
2828 }
2831 /*
2832 * !!!
2833 * Delete any trailing whitespace from the current line.
2834 */
2842 }
2845 }
2847 /*
2848 * txt_Rresolve --
2849 * Resolve the input line for the 'R' command.
2850 */
2851 static void
2853 {
2858 /*
2859 * Check to make sure that the cursor hasn't moved beyond
2860 * the end of the line.
2861 */
2865 /*
2866 * Calculate how many characters the user has entered,
2867 * plus the blanks erased by <carriage-return>/<newline>s.
2868 */
2873 }
2875 /*
2876 * If the user has entered less characters than the original line
2877 * was long, restore any overwriteable characters to the original
2878 * characters. These characters are entered as "insert characters",
2879 * because they're after the cursor and we don't want to lose them.
2880 * (This is okay because the R command has no insert characters.)
2881 * We set owrite to 0 so that the insert characters don't get copied
2882 * to somewhere else, which means that the line and the length have
2883 * to be adjusted here as well.
2884 *
2885 * We have to retrieve the original line because the original pinned
2886 * page has long since been discarded. If it doesn't exist, that's
2887 * okay, the user just extended the file.
2888 */
2898 }
2899 }
2901 /*
2902 * txt_nomorech --
2903 * No more characters message.
2904 */
2905 static void
2907 {
2909 }