source: MondoRescue/branches/3.3/mindi-busybox/editors/ed.c@ 3748

Last change on this file since 3748 was 3621, checked in by Bruno Cornec, 9 years ago

New 3?3 banch for incorporation of latest busybox 1.25. Changing minor version to handle potential incompatibilities.
File size: 19.3 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Copyright (c) 2002 by David I. Bell
4 * Permission is granted to use, distribute, or modify this source,
5 * provided that this copyright notice remains intact.
6 *
7 * The "ed" built-in command (much simplified)
8 */
9
10//config:config ED
11//config: bool "ed"
12//config: default y
13//config: help
14//config: The original 1970's Unix text editor, from the days of teletypes.
15//config: Small, simple, evil. Part of SUSv3. If you're not already using
16//config: this, you don't need it.
17
18//kbuild:lib-$(CONFIG_ED) += ed.o
19
20//applet:IF_ED(APPLET(ed, BB_DIR_BIN, BB_SUID_DROP))
21
22//usage:#define ed_trivial_usage ""
23//usage:#define ed_full_usage ""
24
25#include "libbb.h"
26#include "common_bufsiz.h"
27
28typedef struct LINE {
29 struct LINE *next;
30 struct LINE *prev;
31 int len;
32 char data[1];
33} LINE;
34
35
36#define searchString bb_common_bufsiz1
37
38enum {
39 USERSIZE = COMMON_BUFSIZE > 1024 ? 1024
40 : COMMON_BUFSIZE - 1, /* max line length typed in by user */
41 INITBUF_SIZE = 1024, /* initial buffer size */
42};
43
44struct globals {
45 int curNum;
46 int lastNum;
47 int bufUsed;
48 int bufSize;
49 LINE *curLine;
50 char *bufBase;
51 char *bufPtr;
52 char *fileName;
53 LINE lines;
54 smallint dirty;
55 int marks[26];
56};
57#define G (*ptr_to_globals)
58#define curLine (G.curLine )
59#define bufBase (G.bufBase )
60#define bufPtr (G.bufPtr )
61#define fileName (G.fileName )
62#define curNum (G.curNum )
63#define lastNum (G.lastNum )
64#define bufUsed (G.bufUsed )
65#define bufSize (G.bufSize )
66#define dirty (G.dirty )
67#define lines (G.lines )
68#define marks (G.marks )
69#define INIT_G() do { \
70 setup_common_bufsiz(); \
71 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
72} while (0)
73
74
75static void doCommands(void);
76static void subCommand(const char *cmd, int num1, int num2);
77static int getNum(const char **retcp, smallint *retHaveNum, int *retNum);
78static int setCurNum(int num);
79static void addLines(int num);
80static int insertLine(int num, const char *data, int len);
81static void deleteLines(int num1, int num2);
82static int printLines(int num1, int num2, int expandFlag);
83static int writeLines(const char *file, int num1, int num2);
84static int readLines(const char *file, int num);
85static int searchLines(const char *str, int num1, int num2);
86static LINE *findLine(int num);
87static int findString(const LINE *lp, const char * str, int len, int offset);
88
89
90static int bad_nums(int num1, int num2, const char *for_what)
91{
92 if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) {
93 bb_error_msg("bad line range for %s", for_what);
94 return 1;
95 }
96 return 0;
97}
98
99
100static char *skip_blank(const char *cp)
101{
102 while (isblank(*cp))
103 cp++;
104 return (char *)cp;
105}
106
107
108int ed_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
109int ed_main(int argc UNUSED_PARAM, char **argv)
110{
111 INIT_G();
112
113 bufSize = INITBUF_SIZE;
114 bufBase = xmalloc(bufSize);
115 bufPtr = bufBase;
116 lines.next = &lines;
117 lines.prev = &lines;
118
119 if (argv[1]) {
120 fileName = xstrdup(argv[1]);
121 if (!readLines(fileName, 1)) {
122 return EXIT_SUCCESS;
123 }
124 if (lastNum)
125 setCurNum(1);
126 dirty = FALSE;
127 }
128
129 doCommands();
130 return EXIT_SUCCESS;
131}
132
133/*
134 * Read commands until we are told to stop.
135 */
136static void doCommands(void)
137{
138 const char *cp;
139 char *endbuf, buf[USERSIZE];
140 int len, num1, num2;
141 smallint have1, have2;
142
143 while (TRUE) {
144 /* Returns:
145 * -1 on read errors or EOF, or on bare Ctrl-D.
146 * 0 on ctrl-C,
147 * >0 length of input string, including terminating '\n'
148 */
149 len = read_line_input(NULL, ": ", buf, sizeof(buf), /*timeout*/ -1);
150 if (len <= 0)
151 return;
152 endbuf = &buf[len - 1];
153 while ((endbuf > buf) && isblank(endbuf[-1]))
154 endbuf--;
155 *endbuf = '\0';
156
157 cp = skip_blank(buf);
158 have1 = FALSE;
159 have2 = FALSE;
160
161 if ((curNum == 0) && (lastNum > 0)) {
162 curNum = 1;
163 curLine = lines.next;
164 }
165
166 if (!getNum(&cp, &have1, &num1))
167 continue;
168
169 cp = skip_blank(cp);
170
171 if (*cp == ',') {
172 cp++;
173 if (!getNum(&cp, &have2, &num2))
174 continue;
175 if (!have1)
176 num1 = 1;
177 if (!have2)
178 num2 = lastNum;
179 have1 = TRUE;
180 have2 = TRUE;
181 }
182 if (!have1)
183 num1 = curNum;
184 if (!have2)
185 num2 = num1;
186
187 switch (*cp++) {
188 case 'a':
189 addLines(num1 + 1);
190 break;
191
192 case 'c':
193 deleteLines(num1, num2);
194 addLines(num1);
195 break;
196
197 case 'd':
198 deleteLines(num1, num2);
199 break;
200
201 case 'f':
202 if (*cp && !isblank(*cp)) {
203 bb_error_msg("bad file command");
204 break;
205 }
206 cp = skip_blank(cp);
207 if (*cp == '\0') {
208 if (fileName)
209 printf("\"%s\"\n", fileName);
210 else
211 puts("No file name");
212 break;
213 }
214 free(fileName);
215 fileName = xstrdup(cp);
216 break;
217
218 case 'i':
219 addLines(num1);
220 break;
221
222 case 'k':
223 cp = skip_blank(cp);
224 if ((*cp < 'a') || (*cp > 'z') || cp[1]) {
225 bb_error_msg("bad mark name");
226 break;
227 }
228 marks[*cp - 'a'] = num2;
229 break;
230
231 case 'l':
232 printLines(num1, num2, TRUE);
233 break;
234
235 case 'p':
236 printLines(num1, num2, FALSE);
237 break;
238
239 case 'q':
240 cp = skip_blank(cp);
241 if (have1 || *cp) {
242 bb_error_msg("bad quit command");
243 break;
244 }
245 if (!dirty)
246 return;
247 len = read_line_input(NULL, "Really quit? ", buf, 16, /*timeout*/ -1);
248 /* read error/EOF - no way to continue */
249 if (len < 0)
250 return;
251 cp = skip_blank(buf);
252 if ((*cp | 0x20) == 'y') /* Y or y */
253 return;
254 break;
255
256 case 'r':
257 if (*cp && !isblank(*cp)) {
258 bb_error_msg("bad read command");
259 break;
260 }
261 cp = skip_blank(cp);
262 if (*cp == '\0') {
263 bb_error_msg("no file name");
264 break;
265 }
266 if (!have1)
267 num1 = lastNum;
268 if (readLines(cp, num1 + 1))
269 break;
270 if (fileName == NULL)
271 fileName = xstrdup(cp);
272 break;
273
274 case 's':
275 subCommand(cp, num1, num2);
276 break;
277
278 case 'w':
279 if (*cp && !isblank(*cp)) {
280 bb_error_msg("bad write command");
281 break;
282 }
283 cp = skip_blank(cp);
284 if (!have1) {
285 num1 = 1;
286 num2 = lastNum;
287 }
288 if (*cp == '\0')
289 cp = fileName;
290 if (cp == NULL) {
291 bb_error_msg("no file name specified");
292 break;
293 }
294 writeLines(cp, num1, num2);
295 break;
296
297 case 'z':
298 switch (*cp) {
299 case '-':
300 printLines(curNum - 21, curNum, FALSE);
301 break;
302 case '.':
303 printLines(curNum - 11, curNum + 10, FALSE);
304 break;
305 default:
306 printLines(curNum, curNum + 21, FALSE);
307 break;
308 }
309 break;
310
311 case '.':
312 if (have1) {
313 bb_error_msg("no arguments allowed");
314 break;
315 }
316 printLines(curNum, curNum, FALSE);
317 break;
318
319 case '-':
320 if (setCurNum(curNum - 1))
321 printLines(curNum, curNum, FALSE);
322 break;
323
324 case '=':
325 printf("%d\n", num1);
326 break;
327 case '\0':
328 if (have1) {
329 printLines(num2, num2, FALSE);
330 break;
331 }
332 if (setCurNum(curNum + 1))
333 printLines(curNum, curNum, FALSE);
334 break;
335
336 default:
337 bb_error_msg("unimplemented command");
338 break;
339 }
340 }
341}
342
343
344/*
345 * Do the substitute command.
346 * The current line is set to the last substitution done.
347 */
348static void subCommand(const char *cmd, int num1, int num2)
349{
350 char *cp, *oldStr, *newStr, buf[USERSIZE];
351 int delim, oldLen, newLen, deltaLen, offset;
352 LINE *lp, *nlp;
353 int globalFlag, printFlag, didSub, needPrint;
354
355 if (bad_nums(num1, num2, "substitute"))
356 return;
357
358 globalFlag = FALSE;
359 printFlag = FALSE;
360 didSub = FALSE;
361 needPrint = FALSE;
362
363 /*
364 * Copy the command so we can modify it.
365 */
366 strcpy(buf, cmd);
367 cp = buf;
368
369 if (isblank(*cp) || (*cp == '\0')) {
370 bb_error_msg("bad delimiter for substitute");
371 return;
372 }
373
374 delim = *cp++;
375 oldStr = cp;
376
377 cp = strchr(cp, delim);
378 if (cp == NULL) {
379 bb_error_msg("missing 2nd delimiter for substitute");
380 return;
381 }
382
383 *cp++ = '\0';
384
385 newStr = cp;
386 cp = strchr(cp, delim);
387
388 if (cp)
389 *cp++ = '\0';
390 else
391 cp = (char*)"";
392
393 while (*cp) switch (*cp++) {
394 case 'g':
395 globalFlag = TRUE;
396 break;
397 case 'p':
398 printFlag = TRUE;
399 break;
400 default:
401 bb_error_msg("unknown option for substitute");
402 return;
403 }
404
405 if (*oldStr == '\0') {
406 if (searchString[0] == '\0') {
407 bb_error_msg("no previous search string");
408 return;
409 }
410 oldStr = searchString;
411 }
412
413 if (oldStr != searchString)
414 strcpy(searchString, oldStr);
415
416 lp = findLine(num1);
417 if (lp == NULL)
418 return;
419
420 oldLen = strlen(oldStr);
421 newLen = strlen(newStr);
422 deltaLen = newLen - oldLen;
423 offset = 0;
424 nlp = NULL;
425
426 while (num1 <= num2) {
427 offset = findString(lp, oldStr, oldLen, offset);
428
429 if (offset < 0) {
430 if (needPrint) {
431 printLines(num1, num1, FALSE);
432 needPrint = FALSE;
433 }
434 offset = 0;
435 lp = lp->next;
436 num1++;
437 continue;
438 }
439
440 needPrint = printFlag;
441 didSub = TRUE;
442 dirty = TRUE;
443
444 /*
445 * If the replacement string is the same size or shorter
446 * than the old string, then the substitution is easy.
447 */
448 if (deltaLen <= 0) {
449 memcpy(&lp->data[offset], newStr, newLen);
450 if (deltaLen) {
451 memcpy(&lp->data[offset + newLen],
452 &lp->data[offset + oldLen],
453 lp->len - offset - oldLen);
454
455 lp->len += deltaLen;
456 }
457 offset += newLen;
458 if (globalFlag)
459 continue;
460 if (needPrint) {
461 printLines(num1, num1, FALSE);
462 needPrint = FALSE;
463 }
464 lp = lp->next;
465 num1++;
466 continue;
467 }
468
469 /*
470 * The new string is larger, so allocate a new line
471 * structure and use that. Link it in place of
472 * the old line structure.
473 */
474 nlp = xmalloc(sizeof(LINE) + lp->len + deltaLen);
475
476 nlp->len = lp->len + deltaLen;
477
478 memcpy(nlp->data, lp->data, offset);
479 memcpy(&nlp->data[offset], newStr, newLen);
480 memcpy(&nlp->data[offset + newLen],
481 &lp->data[offset + oldLen],
482 lp->len - offset - oldLen);
483
484 nlp->next = lp->next;
485 nlp->prev = lp->prev;
486 nlp->prev->next = nlp;
487 nlp->next->prev = nlp;
488
489 if (curLine == lp)
490 curLine = nlp;
491
492 free(lp);
493 lp = nlp;
494
495 offset += newLen;
496
497 if (globalFlag)
498 continue;
499
500 if (needPrint) {
501 printLines(num1, num1, FALSE);
502 needPrint = FALSE;
503 }
504
505 lp = lp->next;
506 num1++;
507 }
508
509 if (!didSub)
510 bb_error_msg("no substitutions found for \"%s\"", oldStr);
511}
512
513
514/*
515 * Search a line for the specified string starting at the specified
516 * offset in the line. Returns the offset of the found string, or -1.
517 */
518static int findString(const LINE *lp, const char *str, int len, int offset)
519{
520 int left;
521 const char *cp, *ncp;
522
523 cp = &lp->data[offset];
524 left = lp->len - offset;
525
526 while (left >= len) {
527 ncp = memchr(cp, *str, left);
528 if (ncp == NULL)
529 return -1;
530 left -= (ncp - cp);
531 if (left < len)
532 return -1;
533 cp = ncp;
534 if (memcmp(cp, str, len) == 0)
535 return (cp - lp->data);
536 cp++;
537 left--;
538 }
539
540 return -1;
541}
542
543
544/*
545 * Add lines which are typed in by the user.
546 * The lines are inserted just before the specified line number.
547 * The lines are terminated by a line containing a single dot (ugly!),
548 * or by an end of file.
549 */
550static void addLines(int num)
551{
552 int len;
553 char buf[USERSIZE + 1];
554
555 while (1) {
556 /* Returns:
557 * -1 on read errors or EOF, or on bare Ctrl-D.
558 * 0 on ctrl-C,
559 * >0 length of input string, including terminating '\n'
560 */
561 len = read_line_input(NULL, "", buf, sizeof(buf), /*timeout*/ -1);
562 if (len <= 0) {
563 /* Previously, ctrl-C was exiting to shell.
564 * Now we exit to ed prompt. Is in important? */
565 return;
566 }
567 if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0'))
568 return;
569 if (!insertLine(num++, buf, len))
570 return;
571 }
572}
573
574
575/*
576 * Parse a line number argument if it is present. This is a sum
577 * or difference of numbers, '.', '$', 'x, or a search string.
578 * Returns TRUE if successful (whether or not there was a number).
579 * Returns FALSE if there was a parsing error, with a message output.
580 * Whether there was a number is returned indirectly, as is the number.
581 * The character pointer which stopped the scan is also returned.
582 */
583static int getNum(const char **retcp, smallint *retHaveNum, int *retNum)
584{
585 const char *cp;
586 char *endStr, str[USERSIZE];
587 int value, num;
588 smallint haveNum, minus;
589
590 cp = *retcp;
591 value = 0;
592 haveNum = FALSE;
593 minus = 0;
594
595 while (TRUE) {
596 cp = skip_blank(cp);
597
598 switch (*cp) {
599 case '.':
600 haveNum = TRUE;
601 num = curNum;
602 cp++;
603 break;
604
605 case '$':
606 haveNum = TRUE;
607 num = lastNum;
608 cp++;
609 break;
610
611 case '\'':
612 cp++;
613 if ((*cp < 'a') || (*cp > 'z')) {
614 bb_error_msg("bad mark name");
615 return FALSE;
616 }
617 haveNum = TRUE;
618 num = marks[*cp++ - 'a'];
619 break;
620
621 case '/':
622 strcpy(str, ++cp);
623 endStr = strchr(str, '/');
624 if (endStr) {
625 *endStr++ = '\0';
626 cp += (endStr - str);
627 } else
628 cp = "";
629 num = searchLines(str, curNum, lastNum);
630 if (num == 0)
631 return FALSE;
632 haveNum = TRUE;
633 break;
634
635 default:
636 if (!isdigit(*cp)) {
637 *retcp = cp;
638 *retHaveNum = haveNum;
639 *retNum = value;
640 return TRUE;
641 }
642 num = 0;
643 while (isdigit(*cp))
644 num = num * 10 + *cp++ - '0';
645 haveNum = TRUE;
646 break;
647 }
648
649 value += (minus ? -num : num);
650
651 cp = skip_blank(cp);
652
653 switch (*cp) {
654 case '-':
655 minus = 1;
656 cp++;
657 break;
658
659 case '+':
660 minus = 0;
661 cp++;
662 break;
663
664 default:
665 *retcp = cp;
666 *retHaveNum = haveNum;
667 *retNum = value;
668 return TRUE;
669 }
670 }
671}
672
673
674/*
675 * Read lines from a file at the specified line number.
676 * Returns TRUE if the file was successfully read.
677 */
678static int readLines(const char *file, int num)
679{
680 int fd, cc;
681 int len, lineCount, charCount;
682 char *cp;
683
684 if ((num < 1) || (num > lastNum + 1)) {
685 bb_error_msg("bad line for read");
686 return FALSE;
687 }
688
689 fd = open(file, 0);
690 if (fd < 0) {
691 bb_simple_perror_msg(file);
692 return FALSE;
693 }
694
695 bufPtr = bufBase;
696 bufUsed = 0;
697 lineCount = 0;
698 charCount = 0;
699 cc = 0;
700
701 printf("\"%s\", ", file);
702 fflush_all();
703
704 do {
705 cp = memchr(bufPtr, '\n', bufUsed);
706
707 if (cp) {
708 len = (cp - bufPtr) + 1;
709 if (!insertLine(num, bufPtr, len)) {
710 close(fd);
711 return FALSE;
712 }
713 bufPtr += len;
714 bufUsed -= len;
715 charCount += len;
716 lineCount++;
717 num++;
718 continue;
719 }
720
721 if (bufPtr != bufBase) {
722 memcpy(bufBase, bufPtr, bufUsed);
723 bufPtr = bufBase + bufUsed;
724 }
725
726 if (bufUsed >= bufSize) {
727 len = (bufSize * 3) / 2;
728 cp = xrealloc(bufBase, len);
729 bufBase = cp;
730 bufPtr = bufBase + bufUsed;
731 bufSize = len;
732 }
733
734 cc = safe_read(fd, bufPtr, bufSize - bufUsed);
735 bufUsed += cc;
736 bufPtr = bufBase;
737 } while (cc > 0);
738
739 if (cc < 0) {
740 bb_simple_perror_msg(file);
741 close(fd);
742 return FALSE;
743 }
744
745 if (bufUsed) {
746 if (!insertLine(num, bufPtr, bufUsed)) {
747 close(fd);
748 return -1;
749 }
750 lineCount++;
751 charCount += bufUsed;
752 }
753
754 close(fd);
755
756 printf("%d lines%s, %d chars\n", lineCount,
757 (bufUsed ? " (incomplete)" : ""), charCount);
758
759 return TRUE;
760}
761
762
763/*
764 * Write the specified lines out to the specified file.
765 * Returns TRUE if successful, or FALSE on an error with a message output.
766 */
767static int writeLines(const char *file, int num1, int num2)
768{
769 LINE *lp;
770 int fd, lineCount, charCount;
771
772 if (bad_nums(num1, num2, "write"))
773 return FALSE;
774
775 lineCount = 0;
776 charCount = 0;
777
778 fd = creat(file, 0666);
779 if (fd < 0) {
780 bb_simple_perror_msg(file);
781 return FALSE;
782 }
783
784 printf("\"%s\", ", file);
785 fflush_all();
786
787 lp = findLine(num1);
788 if (lp == NULL) {
789 close(fd);
790 return FALSE;
791 }
792
793 while (num1++ <= num2) {
794 if (full_write(fd, lp->data, lp->len) != lp->len) {
795 bb_simple_perror_msg(file);
796 close(fd);
797 return FALSE;
798 }
799 charCount += lp->len;
800 lineCount++;
801 lp = lp->next;
802 }
803
804 if (close(fd) < 0) {
805 bb_simple_perror_msg(file);
806 return FALSE;
807 }
808
809 printf("%d lines, %d chars\n", lineCount, charCount);
810 return TRUE;
811}
812
813
814/*
815 * Print lines in a specified range.
816 * The last line printed becomes the current line.
817 * If expandFlag is TRUE, then the line is printed specially to
818 * show magic characters.
819 */
820static int printLines(int num1, int num2, int expandFlag)
821{
822 const LINE *lp;
823 const char *cp;
824 int ch, count;
825
826 if (bad_nums(num1, num2, "print"))
827 return FALSE;
828
829 lp = findLine(num1);
830 if (lp == NULL)
831 return FALSE;
832
833 while (num1 <= num2) {
834 if (!expandFlag) {
835 write(STDOUT_FILENO, lp->data, lp->len);
836 setCurNum(num1++);
837 lp = lp->next;
838 continue;
839 }
840
841 /*
842 * Show control characters and characters with the
843 * high bit set specially.
844 */
845 cp = lp->data;
846 count = lp->len;
847
848 if ((count > 0) && (cp[count - 1] == '\n'))
849 count--;
850
851 while (count-- > 0) {
852 ch = (unsigned char) *cp++;
853 fputc_printable(ch | PRINTABLE_META, stdout);
854 }
855
856 fputs("$\n", stdout);
857
858 setCurNum(num1++);
859 lp = lp->next;
860 }
861
862 return TRUE;
863}
864
865
866/*
867 * Insert a new line with the specified text.
868 * The line is inserted so as to become the specified line,
869 * thus pushing any existing and further lines down one.
870 * The inserted line is also set to become the current line.
871 * Returns TRUE if successful.
872 */
873static int insertLine(int num, const char *data, int len)
874{
875 LINE *newLp, *lp;
876
877 if ((num < 1) || (num > lastNum + 1)) {
878 bb_error_msg("inserting at bad line number");
879 return FALSE;
880 }
881
882 newLp = xmalloc(sizeof(LINE) + len - 1);
883
884 memcpy(newLp->data, data, len);
885 newLp->len = len;
886
887 if (num > lastNum)
888 lp = &lines;
889 else {
890 lp = findLine(num);
891 if (lp == NULL) {
892 free((char *) newLp);
893 return FALSE;
894 }
895 }
896
897 newLp->next = lp;
898 newLp->prev = lp->prev;
899 lp->prev->next = newLp;
900 lp->prev = newLp;
901
902 lastNum++;
903 dirty = TRUE;
904 return setCurNum(num);
905}
906
907
908/*
909 * Delete lines from the given range.
910 */
911static void deleteLines(int num1, int num2)
912{
913 LINE *lp, *nlp, *plp;
914 int count;
915
916 if (bad_nums(num1, num2, "delete"))
917 return;
918
919 lp = findLine(num1);
920 if (lp == NULL)
921 return;
922
923 if ((curNum >= num1) && (curNum <= num2)) {
924 if (num2 < lastNum)
925 setCurNum(num2 + 1);
926 else if (num1 > 1)
927 setCurNum(num1 - 1);
928 else
929 curNum = 0;
930 }
931
932 count = num2 - num1 + 1;
933 if (curNum > num2)
934 curNum -= count;
935 lastNum -= count;
936
937 while (count-- > 0) {
938 nlp = lp->next;
939 plp = lp->prev;
940 plp->next = nlp;
941 nlp->prev = plp;
942 free(lp);
943 lp = nlp;
944 }
945
946 dirty = TRUE;
947}
948
949
950/*
951 * Search for a line which contains the specified string.
952 * If the string is "", then the previously searched for string
953 * is used. The currently searched for string is saved for future use.
954 * Returns the line number which matches, or 0 if there was no match
955 * with an error printed.
956 */
957static NOINLINE int searchLines(const char *str, int num1, int num2)
958{
959 const LINE *lp;
960 int len;
961
962 if (bad_nums(num1, num2, "search"))
963 return 0;
964
965 if (*str == '\0') {
966 if (searchString[0] == '\0') {
967 bb_error_msg("no previous search string");
968 return 0;
969 }
970 str = searchString;
971 }
972
973 if (str != searchString)
974 strcpy(searchString, str);
975
976 len = strlen(str);
977
978 lp = findLine(num1);
979 if (lp == NULL)
980 return 0;
981
982 while (num1 <= num2) {
983 if (findString(lp, str, len, 0) >= 0)
984 return num1;
985 num1++;
986 lp = lp->next;
987 }
988
989 bb_error_msg("can't find string \"%s\"", str);
990 return 0;
991}
992
993
994/*
995 * Return a pointer to the specified line number.
996 */
997static LINE *findLine(int num)
998{
999 LINE *lp;
1000 int lnum;
1001
1002 if ((num < 1) || (num > lastNum)) {
1003 bb_error_msg("line number %d does not exist", num);
1004 return NULL;
1005 }
1006
1007 if (curNum <= 0) {
1008 curNum = 1;
1009 curLine = lines.next;
1010 }
1011
1012 if (num == curNum)
1013 return curLine;
1014
1015 lp = curLine;
1016 lnum = curNum;
1017 if (num < (curNum / 2)) {
1018 lp = lines.next;
1019 lnum = 1;
1020 } else if (num > ((curNum + lastNum) / 2)) {
1021 lp = lines.prev;
1022 lnum = lastNum;
1023 }
1024
1025 while (lnum < num) {
1026 lp = lp->next;
1027 lnum++;
1028 }
1029
1030 while (lnum > num) {
1031 lp = lp->prev;
1032 lnum--;
1033 }
1034 return lp;
1035}
1036
1037
1038/*
1039 * Set the current line number.
1040 * Returns TRUE if successful.
1041 */
1042static int setCurNum(int num)
1043{
1044 LINE *lp;
1045
1046 lp = findLine(num);
1047 if (lp == NULL)
1048 return FALSE;
1049 curNum = num;
1050 curLine = lp;
1051 return TRUE;
1052}
Note: See TracBrowser for help on using the repository browser.