| blob | ba363007cadf93e41ec1eb66fdd24f541239863e |
1 /* $NetBSD: v_txt.c,v 1.3 2013/11/25 22:43:46 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 #ifndef lint
14 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 ";
17 #include <sys/types.h>
18 #include <sys/queue.h>
19 #include <sys/stat.h>
20 #include <sys/time.h>
22 #include <bitstring.h>
23 #include <ctype.h>
24 #include <errno.h>
25 #include <limits.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
54 /* Cursor character (space is hard to track on the screen). */
55 #if defined(DEBUG) && 0
56 #undef CH_CURSOR
58 #endif
60 /*
61 * v_tcmd --
62 * Fill a buffer from the terminal for vi.
63 *
64 * PUBLIC: int v_tcmd __P((SCR *, VICMD *, ARG_CHAR_T, u_int));
65 */
66 int
68 {
69 /* Normally, we end up where we started. */
73 /* Initialize the map. */
77 /* Move to the last line. */
81 /* Don't update the modeline for now. */
84 /* Set the input flags. */
92 /* Do the input thing. */
96 /* Reenable the modeline updates. */
99 /* Clean up the map. */
106 /* Set the cursor to the resulting position. */
111 }
113 /*
114 * txt_map_init
115 * Initialize the screen map for colon command-line input.
116 */
117 static int
119 {
125 /*
126 * Fake like the user is doing input on the last line of the
127 * screen. This makes all of the scrolling work correctly,
128 * and allows us the use of the vi text editing routines, not
129 * to mention practically infinite length ex commands.
130 *
131 * Save the current location.
132 */
140 /*
141 * If it's a small screen, TMAP may be small for the screen.
142 * Fix it, filling in fake lines as we go.
143 */
150 }
152 /* Build the fake entry. */
159 /* Reset the screen information. */
161 }
163 }
165 /*
166 * txt_map_end
167 * Reset the screen map for colon command-line input.
168 */
169 static int
171 {
177 /* Restore the screen information. */
182 /*
183 * If it's a small screen, TMAP may be wrong. Clear any
184 * lines that might have been overwritten.
185 */
190 }
195 /*
196 * The map may be wrong if the user entered more than one
197 * (logical) line. Fix it. If the user entered a whole
198 * screen, this will be slow, but we probably don't care.
199 */
205 }
207 /*
208 * Invalidate the cursor and the line size cache, the line never
209 * really existed. This fixes bugs where the user searches for
210 * the last line on the screen + 1 and the refresh routine thinks
211 * that's where we just were.
212 */
217 }
219 /*
220 * If doing input mapping on the colon command line, may need to unmap
221 * based on the command.
222 */
223 #define UNMAP_TST \
224 FL_ISSET(ec_flags, EC_MAPINPUT) && LF_ISSET(TXT_INFOLINE)
226 /*
227 * Internally, we maintain tp->lno and tp->cno, externally, everyone uses
228 * sp->lno and sp->cno. Make them consistent as necessary.
229 */
230 #define UPDATE_POSITION(sp, tp) { \
231 (sp)->lno = (tp)->lno; \
232 (sp)->cno = (tp)->cno; \
233 }
235 /*
236 * v_txt --
237 * Vi text input.
238 *
239 * PUBLIC: int v_txt __P((SCR *, VICMD *, MARK *,
240 * PUBLIC: const CHAR_T *, size_t, ARG_CHAR_T, db_recno_t, u_long, u_int32_t));
241 */
242 int
243 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)
246 /* To MARK. */
247 /* Input line. */
248 /* Input line length. */
249 /* Prompt to display. */
250 /* Line number to use for autoindent count. */
251 /* Replay count. */
252 /* TXT_* flags. */
253 {
272 u_int8_t is_flags;
287 /*
288 * Set the input flag, so tabs get displayed correctly
289 * and everyone knows that the text buffer is in use.
290 */
293 /*
294 * Get one TEXT structure with some initial buffer space, reusing
295 * the last one if it's big enough. (All TEXT bookkeeping fields
296 * default to 0 -- text_init() handles this.) If changing a line,
297 * copy it into the TEXT buffer.
298 */
305 }
317 }
319 /* Set default termination condition. */
322 /* Set the starting line, column. */
326 /*
327 * Set the insert and overwrite counts. If overwriting characters,
328 * do insertion afterward. If not overwriting characters, assume
329 * doing insertion. If change is to a mark, emphasize it with an
330 * CH_ENDMARK character.
331 */
341 }
343 /*
344 * Many of the special cases in text input are to handle autoindent
345 * support. Somebody decided that it would be a good idea if "^^D"
346 * and "0^D" deleted all of the autoindented characters. In an editor
347 * that takes single character input from the user, this beggars the
348 * imagination. Note also, "^^D" resets the next lines' autoindent,
349 * but "0^D" doesn't.
350 *
351 * We assume that autoindent only happens on empty lines, so insert
352 * and overwrite will be zero. If doing autoindent, figure out how
353 * much indentation we need and fill it in. Update input column and
354 * screen cursor as necessary.
355 */
361 /*
362 * The cc and S commands have a special feature -- leading
363 * <blank> characters are handled as autoindent characters.
364 * Beauty!
365 */
371 }
373 /* If getting a command buffer from the user, there may be a prompt. */
378 }
380 /*
381 * If appending after the end-of-line, add a space into the buffer
382 * and move the cursor right. This space is inserted, i.e. pushed
383 * along, and then deleted when the line is resolved. Assumes that
384 * the cursor is already positioned at the end of the line. This
385 * avoids the nastiness of having the cursor reside on a magical
386 * column, i.e. a column that doesn't really exist. The only down
387 * side is that we may wrap lines or scroll the screen before it's
388 * strictly necessary. Not a big deal.
389 */
395 }
397 /*
398 * Historic practice is that the wrapmargin value was a distance
399 * from the RIGHT-HAND margin, not the left. It's more useful to
400 * us as a distance from the left-hand margin, i.e. the same as
401 * the wraplen value. The wrapmargin option is historic practice.
402 * Nvi added the wraplen option so that it would be possible to
403 * edit files with consistent margins without knowing the number of
404 * columns in the window.
405 *
406 * XXX
407 * Setting margin causes a significant performance hit. Normally
408 * we don't update the screen if there are keys waiting, but we
409 * have to if margin is set, otherwise the screen routines don't
410 * know where the cursor is.
411 *
412 * !!!
413 * Abbreviated keys were affected by the wrapmargin option in the
414 * historic 4BSD vi. Mapped keys were usually, but sometimes not.
415 * See the comment in vi/v_text():set_txt_std for more information.
416 *
417 * !!!
418 * One more special case. If an inserted <blank> character causes
419 * wrapmargin to split the line, the next user entered character is
420 * discarded if it's a <space> character.
421 */
426 else
428 else
431 /* Initialize abbreviation checks. */
436 /*
437 * Set up the dot command. Dot commands are done by saving the actual
438 * characters and then reevaluating them so that things like wrapmargin
439 * can change between the insert and the replay.
440 *
441 * !!!
442 * Historically, vi did not remap or reabbreviate replayed input. (It
443 * did beep at you if you changed an abbreviation and then replayed the
444 * input. We're not that compatible.) We don't have to do anything to
445 * avoid remapping, as we're not getting characters from the terminal
446 * routines. Turn the abbreviation check off.
447 *
448 * XXX
449 * It would be nice if we could swallow backspaces and such, but it's
450 * not all that easy to do. What we can do is turn off the common
451 * error messages during the replay. Otherwise, when the user enters
452 * an illegal command, e.g., "Ia<erase><erase><erase><erase>b<escape>",
453 * and then does a '.', they get a list of error messages after command
454 * completion.
455 */
460 }
462 /* Other text input mode setup. */
470 /* Initialize input flags. */
473 /* Refresh the screen. */
478 /* If it's dot, just do it now. */
482 /* Get an event. */
487 /*
488 * If file completion overwrote part of the screen and nothing else has
489 * been displayed, clean up. We don't do this as part of the normal
490 * message resolution because we know the user is on the colon command
491 * line and there's no reason to enter explicit characters to continue.
492 */
503 }
505 /* Deal with all non-character events. */
514 /*
515 * !!!
516 * Historically, <interrupt> exited the user from text input
517 * mode or cancelled a colon command, and returned to command
518 * mode. It also beeped the terminal, but that seems a bit
519 * excessive.
520 */
527 /* <resize> interrupts the input mode. */
533 }
535 /*
536 * !!!
537 * If the first character of the input is a nul, replay the previous
538 * input. (Historically, it's okay to replay non-existent input.)
539 * This was not documented as far as I know, and is a great test of vi
540 * clones.
541 */
550 }
552 /*
553 * File name completion and colon command-line editing. We don't
554 * have enough meta characters, so we expect people to overload
555 * them. If the two characters are the same, then we do file name
556 * completion if the cursor is past the first column, and do colon
557 * command-line editing if it's not.
558 */
572 }
577 }
578 }
580 /* Abbreviation overflow check. See comment in txt_abbrev(). */
581 #define MAX_ABBREVIATION_EXPANSION 256
591 }
595 /* Check to see if the character fits into the replay buffers. */
600 }
606 }
608 /* Wrapmargin check for leading space. */
613 }
615 /* If quoted by someone else, simply insert the character. */
619 /*
620 * !!!
621 * If this character was quoted by a K_VLNEXT or a backslash, replace
622 * the placeholder (a carat or a backslash) with the new character.
623 * If it was quoted by a K_VLNEXT, we've already adjusted the cursor
624 * because it has to appear on top of the placeholder character. If
625 * it was quoted by a backslash, adjust the cursor now, the cursor
626 * doesn't appear on top of it. Historic practice in both cases.
627 *
628 * Skip tests for abbreviations; ":ab xa XA" followed by "ixa^V<space>"
629 * doesn't perform an abbreviation. Special case, ^V^J (not ^V^M) is
630 * the same as ^J, historically.
631 */
643 }
647 }
649 }
651 /*
652 * !!!
653 * Translate "<CH_HEX>[isxdigit()]*" to a character with a hex value:
654 * this test delimits the value by any non-hex character. Offset by
655 * one, we use 0 to mean that we've found <CH_HEX>.
656 */
661 }
666 /* Return in script windows and the command line. */
669 /*
670 * If this was a map, we may have not displayed
671 * the line. Display it, just in case.
672 *
673 * If a script window and not the colon line,
674 * push a <cr> so it gets executed.
675 */
682 /* Set term condition: if empty. */
685 /*
686 * Set term condition: if searching incrementally and
687 * the user entered a pattern, return a completed
688 * search, regardless if the entire pattern was found.
689 */
695 }
697 #define LINE_RESOLVE { \
698 /* \
699 * Handle abbreviations. If there was one, discard the \
700 * replay characters. \
702 if (abb == AB_INWORD && \
703 !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) { \
704 if (txt_abbrev(sp, tp, &evp->e_c, \
705 LF_ISSET(TXT_INFOLINE), &tmp, \
706 &ab_turnoff)) \
707 goto err; \
708 if (tmp) { \
709 if (LF_ISSET(TXT_RECORD)) \
710 rcol -= tmp + 1; \
711 goto resolve; \
712 } \
713 } \
714 if (abb != AB_NOTSET) \
715 abb = AB_NOTWORD; \
716 if (UNMAP_TST) \
717 txt_unmap(sp, tp, &ec_flags); \
718 /* \
719 * Delete any appended cursor. It's possible to get in \
720 * situations where TXT_APPENDEOL is set but tp->insert \
721 * is 0 when using the R command and all the characters \
722 * are tp->owrite characters. \
724 if (LF_ISSET(TXT_APPENDEOL) && tp->insert > 0) { \
725 --tp->len; \
726 --tp->insert; \
727 } \
728 }
729 LINE_RESOLVE;
731 /*
732 * Save the current line information for restoration in
733 * txt_backup(), and set the line final length.
734 */
739 /* Update the old line. */
743 /*
744 * Historic practice, when the autoindent edit option was set,
745 * was to delete <blank> characters following the inserted
746 * newline. This affected the 'R', 'c', and 's' commands; 'c'
747 * and 's' retained the insert characters only, 'R' moved the
748 * overwrite and insert characters into the next TEXT structure.
749 * We keep track of the number of characters erased for the 'R'
750 * command so that the final resolution of the line is correct.
751 */
767 }
769 /*
770 * !!!
771 * Create a new line and insert the new TEXT into the queue.
772 * DON'T insert until the old line has been updated, or the
773 * inserted line count in line.c:db_get() will be wrong.
774 */
780 /* Set up bookkeeping for the new line. */
785 /*
786 * Reset the autoindent line value. 0^D keeps the autoindent
787 * line from changing, ^D changes the level, even if there were
788 * no characters in the old line. Note, if using the current
789 * tp structure, use the cursor as the length, the autoindent
790 * characters may have been erased.
791 */
802 }
804 /* Reset the cursor. */
807 /*
808 * If we're here because wrapmargin was set and we've broken a
809 * line, there may be additional information (i.e. the start of
810 * a line) in the wmt structure.
811 */
815 #define WMTSPACE wmt.offset + wmt.owrite + wmt.insert
823 }
825 }
827 /* New lines are TXT_APPENDEOL. */
834 }
836 /* Swap old and new TEXT's, and update the new line. */
846 /* If we have a count, start replaying the input. */
856 /*
857 * Some commands (e.g. 'o') need a <newline> for each
858 * repetition.
859 */
863 /*
864 * The R command turns into the 'a' command after the
865 * first repetition.
866 */
871 }
873 }
875 /* Set term condition: if empty. */
878 /*
879 * Set term condition: if searching incrementally and the user
880 * entered a pattern, return a completed search, regardless if
881 * the entire pattern was found.
882 */
888 /*
889 * Clean up for the 'R' command, restoring overwrite
890 * characters, and making them into insert characters.
891 */
895 /*
896 * If there are any overwrite characters, copy down
897 * any insert characters, and decrement the length.
898 */
904 }
906 /*
907 * Optionally resolve the lines into the file. If not
908 * resolving the lines into the file, end the line with
909 * a nul. If the line is empty, then set the length to
910 * 0, the termination condition has already been set.
911 *
912 * XXX
913 * This is wrong, should pass back a length.
914 */
921 }
923 /*
924 * Set the return cursor position to rest on the last
925 * inserted character.
926 */
930 /* Update the last line. */
943 /*
944 * If in the first column or no characters to erase, ignore
945 * the ^D (this matches historic practice). If not doing
946 * autoindent or already inserted non-ai characters, it's a
947 * literal. The latter test is done in the switch, as the
948 * CARAT forms are N + 1, not N.
949 */
960 /* Save the ai string for later. */
987 }
990 /* If can erase over the prompt, return. */
994 }
996 /*
997 * If at the beginning of the line, try and drop back to a
998 * previously inserted line.
999 */
1006 }
1008 /* If nothing to erase, bell the user. */
1013 }
1015 /* Drop back one character. */
1018 /*
1019 * Historically, vi didn't replace the erased characters with
1020 * <blank>s, presumably because it's easier to fix a minor
1021 * typing mistake and continue on if the previous letters are
1022 * already there. This is a problem for incremental searching,
1023 * because the user can no longer tell where they are in the
1024 * colon command line because the cursor is at the last search
1025 * point in the screen. So, if incrementally searching, erase
1026 * the erased characters from the screen.
1027 */
1031 /*
1032 * Increment overwrite, decrement ai if deleted.
1033 *
1034 * !!!
1035 * Historic vi did not permit users to use erase characters
1036 * to delete autoindent characters. We do. Eat hot death,
1037 * POSIX.
1038 */
1043 /* Reset if we deleted an incremental search character. */
1048 /*
1049 * If at the beginning of the line, try and drop back to a
1050 * previously inserted line.
1051 */
1057 }
1059 /*
1060 * If at offset, nothing to erase so bell the user.
1061 */
1066 }
1068 /*
1069 * The first werase goes back to any autoindent column and the
1070 * second werase goes back to the offset.
1071 *
1072 * !!!
1073 * Historic vi did not permit users to use erase characters to
1074 * delete autoindent characters.
1075 */
1081 }
1083 /* Skip over trailing space characters. */
1087 }
1090 /*
1091 * There are three types of word erase found on UNIX systems.
1092 * They can be identified by how the string /a/b/c is treated
1093 * -- as 1, 3, or 6 words. Historic vi had two classes of
1094 * characters, and strings were delimited by them and
1095 * <blank>'s, so, 6 words. The historic tty interface used
1096 * <blank>'s to delimit strings, so, 1 word. The algorithm
1097 * offered in the 4.4BSD tty interface (as stty altwerase)
1098 * treats it as 3 words -- there are two classes of
1099 * characters, and strings are delimited by them and
1100 * <blank>'s. The difference is that the type of the first
1101 * erased character erased is ignored, which is exactly right
1102 * when erasing pathname components. The edit options
1103 * TXT_ALTWERASE and TXT_TTYWERASE specify the 4.4BSD tty
1104 * interface and the historic tty driver behavior,
1105 * respectively, and the default is the same as the historic
1106 * vi behavior.
1107 *
1108 * Overwrite erased characters if doing incremental search;
1109 * see comment above.
1110 */
1119 }
1128 }
1139 }
1140 }
1142 /* Reset if we deleted an incremental search character. */
1147 /*
1148 * !!!
1149 * If at the beginning of the line, try and drop back to a
1150 * previously inserted line. Historic vi did not permit
1151 * users to go back to previous lines.
1152 */
1158 }
1160 /* If at offset, nothing to erase so bell the user. */
1165 }
1167 /*
1168 * First kill goes back to any autoindent and second kill goes
1169 * back to the offset.
1170 *
1171 * !!!
1172 * Historic vi did not permit users to use erase characters to
1173 * delete autoindent characters.
1174 */
1180 }
1183 /*
1184 * Overwrite erased characters if doing incremental search;
1185 * see comment above.
1186 */
1191 else
1194 /* Reset if we deleted an incremental search character. */
1210 /*
1211 * !!!
1212 * Historic vi tried to make abbreviations after a backslash
1213 * escape work. If you did ":ab x y", and inserted "x\^H",
1214 * (assuming the erase character was ^H) you got "x^H", and
1215 * no abbreviation was done. If you inserted "x\z", however,
1216 * it tried to back up and do the abbreviation, i.e. replace
1217 * 'x' with 'y'. The problem was it got it wrong, and you
1218 * ended up with "zy\".
1219 *
1220 * This is really hard to do (you have to remember the
1221 * word/non-word state, for example), and doesn't make any
1222 * sense to me. Both backslash and the characters it
1223 * (usually) escapes will individually trigger the
1224 * abbreviation, so I don't see why the combination of them
1225 * wouldn't. I don't expect to get caught on this one,
1226 * particularly since it never worked right, but I've been
1227 * wrong before.
1228 *
1229 * Do the tests for abbreviations, so ":ab xa XA",
1230 * "ixa\<K_VERASE>" performs the abbreviation.
1231 */
1237 /*
1238 * Turn on the quote flag so that the underlying routines
1239 * quote the next character where it's possible. Turn off
1240 * the input mapbiting flag so that we don't remap the next
1241 * character.
1242 */
1246 /*
1247 * !!!
1248 * Skip the tests for abbreviations, so ":ab xa XA",
1249 * "ixa^V<space>" doesn't perform the abbreviation.
1250 */
1257 * Historically, vi eliminated nul's out of hand. If the
1258 * beautify option was set, it also deleted any unknown
1259 * ASCII value less than space (040) and the del character
1260 * (0177), except for tabs. Unknown is a key word here.
1261 * Most vi documentation claims that it deleted everything
1262 * but <tab>, <nl> and <ff>, as that's what the original
1263 * 4BSD documentation said. This is obviously wrong,
1264 * however, as <esc> would be included in that list. What
1265 * we do is eliminate any unquoted, iscntrl() character that
1266 * wasn't a replay and wasn't handled specially, except
1267 * <tab> or <ff>.
1268 */
1276 }
1279 * If entering a non-word character after a word, check for
1280 * abbreviations. If there was one, discard replay characters.
1281 * If entering a blank character, check for unmap commands,
1282 * as well.
1283 */
1294 }
1295 }
1298 }
1305 /*
1306 * If we're using K_VLNEXT to quote the next character, then
1307 * we want the cursor to position itself on the ^ placeholder
1308 * we're displaying, to match historic practice.
1309 */
1313 }
1315 /*
1316 * !!!
1317 * Translate "<CH_HEX>[isxdigit()]*" to a character with
1318 * a hex value: this test delimits the value by the max
1319 * number of hex bytes. Offset by one, we use 0 to mean
1320 * that we've found <CH_HEX>.
1321 */
1326 }
1328 /*
1329 * Check to see if we've crossed the margin.
1330 *
1331 * !!!
1332 * In the historic vi, the wrapmargin value was figured out
1333 * using the display widths of the characters, i.e. <tab>
1334 * characters were counted as two characters if the list edit
1335 * option is set, but as the tabstop edit option number of
1336 * characters otherwise. That's what the vs_column() function
1337 * gives us, so we use it.
1338 */
1350 }
1351 }
1352 }
1354 /*
1355 * If we've reached the end of the buffer, then we need to
1356 * switch into insert mode. This happens when there's a
1357 * change to a mark and the user puts in more characters than
1358 * the length of the motion.
1359 */
1367 }
1369 /* Step the quote state forward. */
1375 }
1377 }
1379 #ifdef DEBUG
1387 }
1388 #endif
1391 * 1: If we don't need to know where the cursor really is and we're
1392 * replaying text, keep going.
1393 */
1397 /*
1398 * 2: Reset the line. Don't bother unless we're about to wait on
1399 * a character or we need to know where the cursor really is.
1400 * We have to do this before showing matching characters so the
1401 * user can see what they're matching.
1402 */
1407 /*
1408 * 3: If there aren't keys waiting, display the matching character.
1409 * We have to do this before resolving any messages, otherwise
1410 * the error message from a missing match won't appear correctly.
1411 */
1416 }
1418 /*
1419 * 4: If there have been messages and we're not editing on the colon
1420 * command line or doing file name completion, resolve them.
1421 */
1427 /*
1428 * 5: Refresh the screen if we're about to wait on a character or we
1429 * need to know where the cursor really is.
1430 */
1435 }
1437 /* 6: Proceed with the incremental search. */
1441 /* 7: Next character... */
1449 /* If recording for playback, save it. */
1453 /*
1454 * If not working on the colon command line, set the final cursor
1455 * position.
1456 */
1460 }
1463 err:
1464 alloc_err:
1468 }
1470 /*
1471 * txt_abbrev --
1472 * Handle abbreviations.
1473 */
1474 static int
1476 {
1481 /* Check to make sure we're not at the start of an append. */
1486 /*
1487 * Find the start of the "word".
1488 *
1489 * !!!
1490 * We match historic practice, which, as far as I can tell, had an
1491 * off-by-one error. The way this worked was that when the inserted
1492 * text switched from a "word" character to a non-word character,
1493 * vi would check for possible abbreviations. It would then take the
1494 * type (i.e. word/non-word) of the character entered TWO characters
1495 * ago, and move backward in the text until reaching a character that
1496 * was not that type, or the beginning of the insert, the line, or
1497 * the file. For example, in the string "abc<space>", when the <space>
1498 * character triggered the abbreviation check, the type of the 'b'
1499 * character was used for moving through the string. Maybe there's a
1500 * reason for not using the first (i.e. 'c') character, but I can't
1501 * think of one.
1502 *
1503 * Terminate at the beginning of the insert or the character after the
1504 * offset character -- both can be tested for using tp->offset.
1505 */
1516 }
1517 else
1523 }
1525 /*
1526 * !!!
1527 * Historic vi exploded abbreviations on the command line. This has
1528 * obvious problems in that unabbreviating the string can be extremely
1529 * tricky, particularly if the string has, say, an embedded escape
1530 * character. Personally, I think it's a stunningly bad idea. Other
1531 * examples of problems this caused in historic vi are:
1532 * :ab foo bar
1533 * :ab foo baz
1534 * results in "bar" being abbreviated to "baz", which wasn't what the
1535 * user had in mind at all. Also, the commands:
1536 * :ab foo bar
1537 * :unab foo<space>
1538 * resulted in an error message that "bar" wasn't mapped. Finally,
1539 * since the string was already exploded by the time the unabbreviate
1540 * command got it, all it knew was that an abbreviation had occurred.
1541 * Cleverly, it checked the replacement string for its unabbreviation
1542 * match, which meant that the commands:
1543 * :ab foo1 bar
1544 * :ab foo2 bar
1545 * :unab foo2
1546 * unabbreviate "foo1", and the commands:
1547 * :ab foo bar
1548 * :ab bar baz
1549 * unabbreviate "foo"!
1550 *
1551 * Anyway, people neglected to first ask my opinion before they wrote
1552 * macros that depend on this stuff, so, we make this work as follows.
1553 * When checking for an abbreviation on the command line, if we get a
1554 * string which is <blank> terminated and which starts at the beginning
1555 * of the line, we check to see it is the abbreviate or unabbreviate
1556 * commands. If it is, turn abbreviations off and return as if no
1557 * abbreviation was found. Note also, minor trickiness, so that if
1558 * the user erases the line and starts another command, we turn the
1559 * abbreviations back on.
1560 *
1561 * This makes the layering look like a Nachos Supreme.
1562 */
1570 else
1573 }
1575 /* Check for any abbreviations. */
1579 /*
1580 * Push the abbreviation onto the tty stack. Historically, characters
1581 * resulting from an abbreviation expansion were themselves subject to
1582 * map expansions, O_SHOWMATCH matching etc. This means the expanded
1583 * characters will be re-tested for abbreviations. It's difficult to
1584 * know what historic practice in this case was, since abbreviations
1585 * were applied to :colon command lines, so entering abbreviations that
1586 * looped was tricky, although possible. In addition, obvious loops
1587 * didn't work as expected. (The command ':ab a b|ab b c|ab c a' will
1588 * silently only implement and/or display the last abbreviation.)
1589 *
1590 * This implementation doesn't recover well from such abbreviations.
1591 * The main input loop counts abbreviated characters, and, when it
1592 * reaches a limit, discards any abbreviated characters on the queue.
1593 * It's difficult to back up to the original position, as the replay
1594 * queue would have to be adjusted, and the line state when an initial
1595 * abbreviated character was received would have to be saved.
1596 */
1603 /*
1604 * If the size of the abbreviation is larger than or equal to the size
1605 * of the original text, move to the start of the replaced characters,
1606 * and add their length to the overwrite count.
1607 *
1608 * If the abbreviation is smaller than the original text, we have to
1609 * delete the additional overwrite characters and copy down any insert
1610 * characters.
1611 */
1621 }
1623 /*
1624 * We return the length of the abbreviated characters. This is so
1625 * the calling routine can replace the replay characters with the
1626 * abbreviation. This means that subsequent '.' commands will produce
1627 * the same text, regardless of intervening :[un]abbreviate commands.
1628 * This is historic practice.
1629 */
1632 }
1634 /*
1635 * txt_unmap --
1636 * Handle the unmap command.
1637 */
1638 static void
1640 {
1644 /* Find the beginning of this "word". */
1649 }
1653 }
1655 /*
1656 * !!!
1657 * Historic vi exploded input mappings on the command line. See the
1658 * txt_abbrev() routine for an explanation of the problems inherent
1659 * in this.
1660 *
1661 * We make this work as follows. If we get a string which is <blank>
1662 * terminated and which starts at the beginning of the line, we check
1663 * to see it is the unmap command. If it is, we return that the input
1664 * mapping should be turned off. Note also, minor trickiness, so that
1665 * if the user erases the line and starts another command, we go ahead
1666 * an turn mapping back on.
1667 */
1670 else
1672 }
1674 /*
1675 * txt_ai_resolve --
1676 * When a line is resolved by <esc>, review autoindent characters.
1677 */
1678 static void
1680 {
1681 u_long ts;
1688 /*
1689 * If the line is empty, has an offset, or no autoindent
1690 * characters, we're done.
1691 */
1695 /*
1696 * If the length is less than or equal to the autoindent
1697 * characters, delete them.
1698 */
1702 }
1704 /*
1705 * The autoindent characters plus any leading <blank> characters
1706 * in the line are resolved into the minimum number of characters.
1707 * Historic practice.
1708 */
1711 /* Figure out the last <blank> screen column. */
1721 }
1723 /*
1724 * If there are no spaces, or no tabs after spaces and less than
1725 * ts spaces, it's already minimal.
1726 * Keep analysing if expandtab is set.
1727 */
1732 /* Count up spaces/tabs needed to get to the target. */
1738 }
1741 /*
1742 * Figure out how many characters we're dropping -- if we're not
1743 * dropping any, it's already minimal, we're done.
1744 */
1750 /* Shift the rest of the characters down, adjust the counts. */
1756 /* Fill in space/tab characters. */
1762 }
1764 /*
1765 * v_txt_auto --
1766 * Handle autoindent. If aitp isn't NULL, use it, otherwise,
1767 * retrieve the line.
1768 *
1769 * PUBLIC: int v_txt_auto __P((SCR *, db_recno_t, TEXT *, size_t, TEXT *));
1770 */
1771 int
1773 {
1778 /*
1779 * If the ex append command is executed with an address of 0,
1780 * it's possible to get here with a line number of 0. Return
1781 * an indent of 0.
1782 */
1786 }
1792 /* Count whitespace characters. */
1797 /* Set count, check for no indentation. */
1801 /* Make sure the buffer's big enough. */
1804 /* Copy the buffer's current contents up. */
1809 /* Copy the indentation into the new buffer. */
1812 /* Set the autoindent count. */
1815 }
1817 /*
1818 * txt_backup --
1819 * Back up to the previously edited line.
1820 */
1823 {
1826 /* Get a handle on the previous TEXT structure. */
1832 }
1834 /* Bookkeeping. */
1837 /* Handle appending to the line. */
1846 /* Release the current TEXT. */
1850 /* Update the old line on the screen. */
1854 /* Return the new/current TEXT. */
1856 }
1858 /*
1859 * Text indentation is truly strange. ^T and ^D do movements to the next or
1860 * previous shiftwidth value, i.e. for a 1-based numbering, with shiftwidth=3,
1861 * ^T moves a cursor on the 7th, 8th or 9th column to the 10th column, and ^D
1862 * moves it back.
1863 *
1864 * !!!
1865 * The ^T and ^D characters in historical vi had special meaning only when they
1866 * were the first characters entered after entering text input mode. As normal
1867 * erase characters couldn't erase autoindent characters (^T in this case), it
1868 * meant that inserting text into previously existing text was strange -- ^T
1869 * only worked if it was the first keystroke(s), and then could only be erased
1870 * using ^D. This implementation treats ^T specially anywhere it occurs in the
1871 * input, and permits the standard erase characters to erase the characters it
1872 * inserts.
1873 *
1874 * !!!
1875 * A fun test is to try:
1876 * :se sw=4 ai list
1877 * i<CR>^Tx<CR>^Tx<CR>^Tx<CR>^Dx<CR>^Dx<CR>^Dx<esc>
1878 * Historic vi loses some of the '$' marks on the line ends, but otherwise gets
1879 * it right.
1880 *
1881 * XXX
1882 * Technically, txt_dent should be part of the screen interface, as it requires
1883 * knowledge of character sizes, including <space>s, on the screen. It's here
1884 * because it's a complicated little beast, and I didn't want to shove it down
1885 * into the screen. It's probable that KEY_LEN will call into the screen once
1886 * there are screens with different character representations.
1887 *
1888 * txt_dent --
1889 * Handle ^T indents, ^D outdents.
1890 *
1891 * If anything changes here, check the ex version to see if it needs similar
1892 * changes.
1893 */
1894 static int
1896 {
1897 ARG_CHAR_T ch;
1904 /*
1905 * Since we don't know what precedes the character(s) being inserted
1906 * (or deleted), the preceding whitespace characters must be resolved.
1907 * An example is a <tab>, which doesn't need a full shiftwidth number
1908 * of columns because it's preceded by <space>s. This is easy to get
1909 * if the user sets shiftwidth to a value less than tabstop (or worse,
1910 * something for which tabstop isn't a multiple) and then uses ^T to
1911 * indent, and ^D to outdent.
1912 *
1913 * Figure out the current and target screen columns. In the historic
1914 * vi, the autoindent column was NOT determined using display widths
1915 * of characters as was the wrapmargin column. For that reason, we
1916 * can't use the vs_column() function, but have to calculate it here.
1917 * This is slow, but it's normally only on the first few characters of
1918 * a line.
1919 */
1930 }
1932 /*
1933 * Back up over any previous <blank> characters, changing them into
1934 * overwrite characters (including any ai characters). Then figure
1935 * out the current screen column.
1936 */
1944 /*
1945 * If we didn't move up to or past the target, it's because there
1946 * weren't enough characters to delete, e.g. the first character
1947 * of the line was a tp->offset character, and the user entered
1948 * ^D to move to the beginning of a line. An example of this is:
1949 *
1950 * :set ai sw=4<cr>i<space>a<esc>i^T^D
1951 *
1952 * Otherwise, count up the total spaces/tabs needed to get from the
1953 * beginning of the line (or the last non-<blank> character) to the
1954 * target.
1955 */
1964 }
1966 }
1970 /*
1971 * Call txt_insch() to insert each character, so that we get the
1972 * correct effect when we add a <tab> to replace N <spaces>.
1973 */
1979 }
1981 /*
1982 * txt_fc --
1983 * File name completion.
1984 */
1985 static int
1987 {
1990 CHAR_T s_ch;
1991 EXCMD cmd;
2001 /*
2002 * Find the beginning of this "word" -- if we're at the beginning
2003 * of the line, it's a special case.
2004 */
2014 }
2018 }
2020 /*
2021 * Get enough space for a wildcard character.
2022 *
2023 * XXX
2024 * This won't work for "foo\", since the \ will escape the expansion
2025 * character. I'm not sure if that's a bug or not...
2026 */
2034 /* Build an ex command, and call the ex expansion routines. */
2039 }
2051 /* If something changed, do the exchange. */
2056 /* If haven't done a directory test, do it now. */
2063 }
2065 /* If nothing changed, period, ring the bell. */
2074 /* Find the length of the shortest match. */
2082 }
2084 }
2086 /* Overwrite the expanded text first. */
2090 /* If lost text, make the remaining old text overwrite characters. */
2094 }
2096 /* Overwrite any overwrite characters next. */
2100 /* Shift remaining text up, and move the cursor to the end. */
2113 }
2115 /* If a single match and it's a directory, retry it. */
2133 }
2135 }
2137 /*
2138 * txt_fc_col --
2139 * Display file names for file name completion.
2140 */
2141 static int
2143 {
2155 /* Trim any directory prefix common to all of the files. */
2164 prefix)) {
2167 }
2168 }
2170 /*
2171 * Figure out the column width for the longest name. Output is done on
2172 * 6 character "tab" boundaries for no particular reason. (Since we
2173 * don't output tab characters, we ignore the terminal's tab settings.)
2174 * Ignore the user's tab setting because we have no idea how reasonable
2175 * it is.
2176 */
2182 }
2185 /*
2186 * Writing to the bottom line of the screen is always turned off when
2187 * SC_TINPUT_INFO is set. Turn it back on, we know what we're doing.
2188 */
2195 #define CHK_INTR \
2196 if (F_ISSET(gp, G_INTERRUPTED)) \
2197 goto intr;
2199 /* If the largest file name is too large, just print them. */
2208 }
2211 CHK_INTR;
2213 /* Figure out the number of columns. */
2222 /* Display the files in sorted order. */
2231 CHK_INTR;
2236 CHK_INTR;
2237 }
2239 CHK_INTR;
2240 }
2242 CHK_INTR;
2243 }
2248 }
2253 }
2255 /*
2256 * txt_emark --
2257 * Set the end mark on the line.
2258 */
2259 static int
2261 {
2262 CHAR_T ch;
2269 /*
2270 * The end mark may not be the same size as the current character.
2271 * Don't let the line shift.
2272 */
2276 else
2279 /*
2280 * If the line got longer, well, it's weird, but it's easy. If
2281 * it's the same length, it's easy. If it got shorter, we have
2282 * to fix it up.
2283 */
2297 else
2301 }
2304 }
2306 /*
2307 * txt_err --
2308 * Handle an error during input processing.
2309 */
2310 static void
2312 {
2313 db_recno_t lno;
2315 /*
2316 * The problem with input processing is that the cursor is at an
2317 * indeterminate position since some input may have been lost due
2318 * to a malloc error. So, try to go back to the place from which
2319 * the cursor started, knowing that it may no longer be available.
2320 *
2321 * We depend on at least one line number being set in the text
2322 * chain.
2323 */
2330 /* Redraw the screen, just in case. */
2332 }
2334 /*
2335 * txt_hex --
2336 * Let the user insert any character value they want.
2337 *
2338 * !!!
2339 * This is an extension. The pattern "^X[0-9a-fA-F]*" is a way
2340 * for the user to specify a character value which their keyboard
2341 * may not be able to enter.
2342 */
2343 static int
2345 {
2346 CHAR_T savec;
2351 /*
2352 * Null-terminate the string. Since nul isn't a legal hex value,
2353 * this should be okay, and lets us use a local routine, which
2354 * presumably understands the character set, to convert the value.
2355 */
2359 /* Find the previous CH_HEX character. */
2364 }
2365 /* Not on this line? Shouldn't happen. */
2368 }
2370 /* If length of 0, then it wasn't a hex value. */
2374 /* Get the value. */
2380 }
2382 /* Restore the original character. */
2385 /* Adjust the bookkeeping. */
2390 /* Copy down any overwrite characters. */
2395 /* Copy down any insert characters. */
2402 }
2404 /*
2405 * txt_insch --
2406 *
2407 * !!!
2408 * Historic vi did a special screen optimization for tab characters. As an
2409 * example, for the keystrokes "iabcd<esc>0C<tab>", the tab overwrote the
2410 * rest of the string when it was displayed.
2411 *
2412 * Because early versions of this implementation redisplayed the entire line
2413 * on each keystroke, the "bcd" was pushed to the right as it ignored that
2414 * the user had "promised" to change the rest of the characters. However,
2415 * the historic vi implementation had an even worse bug: given the keystrokes
2416 * "iabcd<esc>0R<tab><esc>", the "bcd" disappears, and magically reappears
2417 * on the second <esc> key.
2418 *
2419 * POSIX 1003.2 requires (will require) that this be fixed, specifying that
2420 * vi overwrite characters the user has committed to changing, on the basis
2421 * of the screen space they require, but that it not overwrite other characters.
2422 */
2423 static int
2425 {
2427 CHAR_T savech;
2431 /*
2432 * The 'R' command does one-for-one replacement, because there's
2433 * no way to know how many characters the user intends to replace.
2434 */
2440 }
2444 /*
2445 * If the old or new characters are tabs, then the length of the
2446 * display depends on the character position in the display. We
2447 * don't even try to handle this here, just ask the screen.
2448 */
2457 /*
2458 * Eat overwrite characters until we run out of them or we've
2459 * handled the length of the new character. If we only eat
2460 * part of an overwrite character, break it into its component
2461 * elements and display the remaining components.
2462 */
2469 else
2475 }
2492 else
2499 }
2500 }
2502 /*
2503 * If had to erase several characters, we adjust the total
2504 * count, and if there are any characters left, shift them
2505 * into position.
2506 */
2511 /* If we had enough overwrite characters, we're done. */
2515 }
2516 }
2518 /* Check to see if the character fits into the input buffer. */
2525 else
2528 }
2531 }
2533 /*
2534 * txt_isrch --
2535 * Do an incremental search.
2536 */
2537 static int
2539 {
2540 MARK start;
2541 db_recno_t lno;
2542 u_int sf;
2544 /* If it's a one-line screen, we don't do incrementals. */
2548 }
2550 /*
2551 * If the user erases back to the beginning of the buffer, there's
2552 * nothing to search for. Reset the cursor to the starting point.
2553 */
2557 }
2559 /*
2560 * If it's an RE quote character, and not quoted, ignore it until
2561 * we get another character.
2562 */
2567 /*
2568 * If it's a magic shell character, and not quoted, reset the cursor
2569 * to the starting point.
2570 */
2575 /*
2576 * If we see the search pattern termination character, then quit doing
2577 * an incremental search. There may be more, e.g., ":/foo/;/bar/",
2578 * and we can't handle that incrementally. Also, reset the cursor to
2579 * the original location, the ex search routines don't know anything
2580 * about incremental searches.
2581 */
2587 }
2589 /*
2590 * Remember the input line and discard the special input map,
2591 * but don't overwrite the input line on the screen.
2592 */
2599 /*
2600 * Specify a starting point and search. If we find a match, move to
2601 * it and refresh the screen. If we didn't find the match, then we
2602 * beep the screen. When searching from the original cursor position,
2603 * we have to move the cursor, otherwise, we don't want to move the
2604 * cursor in case the text at the current position continues to match.
2605 */
2612 }
2628 /* Reinstantiate the special input map. */
2634 /* Reset the line number of the input line. */
2637 /*
2638 * If the colon command-line moved, i.e. the screen scrolled,
2639 * refresh the input line.
2640 *
2641 * XXX
2642 * We shouldn't be calling vs_line, here -- we need dirty bits
2643 * on entries in the SMAP array.
2644 */
2649 }
2651 }
2653 /*
2654 * txt_resolve --
2655 * Resolve the input text chain into the file.
2656 */
2657 static int
2659 {
2661 db_recno_t lno;
2664 /*
2665 * The first line replaces a current line, and all subsequent lines
2666 * are appended into the file. Resolve autoindented characters for
2667 * each line before committing it. If the latter causes the line to
2668 * change, we have to redisplay it, otherwise the information cached
2669 * about the line will be wrong.
2670 */
2675 else
2684 else
2689 }
2691 /*
2692 * Clear the input flag, the look-aside buffer is no longer valid.
2693 * Has to be done as part of text resolution, or upon return we'll
2694 * be looking at incorrect data.
2695 */
2699 }
2701 /*
2702 * txt_showmatch --
2703 * Show a character match.
2704 *
2705 * !!!
2706 * Historic vi tried to display matches even in the :colon command line.
2707 * I think not.
2708 */
2709 static int
2711 {
2712 VCS cs;
2713 MARK m;
2716 /*
2717 * Do a refresh first, in case we haven't done one in awhile,
2718 * so the user can see what we're complaining about.
2719 */
2724 /*
2725 * We don't display the match if it's not on the screen. Find
2726 * out what the first character on the screen is.
2727 */
2731 /* Initialize the getc() interface. */
2738 /* Search for the match. */
2747 }
2749 }
2754 }
2756 /* If the match is on the screen, move to it. */
2764 /* Wait for timeout or character arrival. */
2767 }
2769 /*
2770 * txt_margin --
2771 * Handle margin wrap.
2772 */
2773 static int
2775 {
2779 /* Find the nearest previous blank. */
2783 }
2785 /*
2786 * If reach the start of the line, there's nowhere to break.
2787 *
2788 * !!!
2789 * Historic vi belled each time a character was entered after
2790 * crossing the margin until a space was entered which could
2791 * be used to break the line. I don't as it tends to wake the
2792 * cats.
2793 */
2797 }
2798 }
2800 /*
2801 * Store saved information about the rest of the line in the
2802 * wrapmargin TEXT structure.
2803 *
2804 * !!!
2805 * The offset field holds the length of the current characters
2806 * that the user entered, but which are getting split to the new
2807 * line -- it's going to be used to set the cursor value when we
2808 * move to the new line.
2809 */
2815 /* Correct current bookkeeping information. */
2823 }
2826 /*
2827 * !!!
2828 * Delete any trailing whitespace from the current line.
2829 */
2837 }
2840 }
2842 /*
2843 * txt_Rresolve --
2844 * Resolve the input line for the 'R' command.
2845 */
2846 static void
2848 {
2853 /*
2854 * Check to make sure that the cursor hasn't moved beyond
2855 * the end of the line.
2856 */
2860 /*
2861 * Calculate how many characters the user has entered,
2862 * plus the blanks erased by <carriage-return>/<newline>s.
2863 */
2868 }
2870 /*
2871 * If the user has entered less characters than the original line
2872 * was long, restore any overwriteable characters to the original
2873 * characters. These characters are entered as "insert characters",
2874 * because they're after the cursor and we don't want to lose them.
2875 * (This is okay because the R command has no insert characters.)
2876 * We set owrite to 0 so that the insert characters don't get copied
2877 * to somewhere else, which means that the line and the length have
2878 * to be adjusted here as well.
2879 *
2880 * We have to retrieve the original line because the original pinned
2881 * page has long since been discarded. If it doesn't exist, that's
2882 * okay, the user just extended the file.
2883 */
2893 }
2894 }
2896 /*
2897 * txt_nomorech --
2898 * No more characters message.
2899 */
2900 static void
2902 {
2904 }