/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- line_map
- history
- invalidate_map
- prune_map
- add_map
- line_pos
- add_hist
- del_hist
- replace_line
- retrieve_line
- retrieve_screen_line
- redisplay
- normalize_display
- fix_cursor
- fix_pos
- beep
- set_position
- do_command
- generic_init
- main
1 /*
2 * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
3 *
4 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
5 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
6 *
7 * Permission is hereby granted to use or copy this program
8 * for any purpose, provided the above notices are retained on all copies.
9 * Permission to modify the code and to distribute modified code is granted,
10 * provided the above notices are retained, and a notice that the code was
11 * modified is included with the above copyright notice.
12 *
13 * Author: Hans-J. Boehm (boehm@parc.xerox.com)
14 */
15 /*
16 * A really simple-minded text editor based on cords.
17 * Things it does right:
18 * No size bounds.
19 * Inbounded undo.
20 * Shouldn't crash no matter what file you invoke it on (e.g. /vmunix)
21 * (Make sure /vmunix is not writable before you try this.)
22 * Scrolls horizontally.
23 * Things it does wrong:
24 * It doesn't handle tabs reasonably (use "expand" first).
25 * The command set is MUCH too small.
26 * The redisplay algorithm doesn't let curses do the scrolling.
27 * The rule for moving the window over the file is suboptimal.
28 */
29 /* Boehm, February 6, 1995 12:27 pm PST */
30
31 /* Boehm, May 19, 1994 2:20 pm PDT */
32 #include <stdio.h>
33 #include "gc.h"
34 #include "cord.h"
35
36 #ifdef THINK_C
37 #define MACINTOSH
38 #include <ctype.h>
39 #endif
40
41 #if defined(__BORLANDC__) && !defined(WIN32)
42 /* If this is DOS or win16, we'll fail anyway. */
43 /* Might as well assume win32. */
44 # define WIN32
45 #endif
46
47 #if defined(WIN32)
48 # include <windows.h>
49 # include "de_win.h"
50 #elif defined(MACINTOSH)
51 # include <console.h>
52 /* curses emulation. */
53 # define initscr()
54 # define endwin()
55 # define nonl()
56 # define noecho() csetmode(C_NOECHO, stdout)
57 # define cbreak() csetmode(C_CBREAK, stdout)
58 # define refresh()
59 # define addch(c) putchar(c)
60 # define standout() cinverse(1, stdout)
61 # define standend() cinverse(0, stdout)
62 # define move(line,col) cgotoxy(col + 1, line + 1, stdout)
63 # define clrtoeol() ccleol(stdout)
64 # define de_error(s) { fprintf(stderr, s); getchar(); }
65 # define LINES 25
66 # define COLS 80
67 #else
68 # include <curses.h>
69 # define de_error(s) { fprintf(stderr, s); sleep(2); }
70 #endif
71 #include "de_cmds.h"
72
73 /* List of line number to position mappings, in descending order. */
74 /* There may be holes. */
75 typedef struct LineMapRep {
76 int line;
77 size_t pos;
78 struct LineMapRep * previous;
79 } * line_map;
80
81 /* List of file versions, one per edit operation */
82 typedef struct HistoryRep {
83 CORD file_contents;
84 struct HistoryRep * previous;
85 line_map map; /* Invalid for first record "now" */
86 } * history;
87
88 history now = 0;
89 CORD current; /* == now -> file_contents. */
90 size_t current_len; /* Current file length. */
91 line_map current_map = 0; /* Current line no. to pos. map */
92 size_t current_map_size = 0; /* Number of current_map entries. */
93 /* Not always accurate, but reset */
94 /* by prune_map. */
95 # define MAX_MAP_SIZE 3000
96
97 /* Current display position */
98 int dis_line = 0;
99 int dis_col = 0;
100
101 # define ALL -1
102 # define NONE - 2
103 int need_redisplay = 0; /* Line that needs to be redisplayed. */
104
105
106 /* Current cursor position. Always within file. */
107 int line = 0;
108 int col = 0;
109 size_t file_pos = 0; /* Character position corresponding to cursor. */
110
111 /* Invalidate line map for lines > i */
112 void invalidate_map(int i)
113 {
114 while(current_map -> line > i) {
115 current_map = current_map -> previous;
116 current_map_size--;
117 }
118 }
119
120 /* Reduce the number of map entries to save space for huge files. */
121 /* This also affects maps in histories. */
122 void prune_map()
123 {
124 line_map map = current_map;
125 int start_line = map -> line;
126
127 current_map_size = 0;
128 for(; map != 0; map = map -> previous) {
129 current_map_size++;
130 if (map -> line < start_line - LINES && map -> previous != 0) {
131 map -> previous = map -> previous -> previous;
132 }
133 }
134 }
135 /* Add mapping entry */
136 void add_map(int line, size_t pos)
137 {
138 line_map new_map = GC_NEW(struct LineMapRep);
139
140 if (current_map_size >= MAX_MAP_SIZE) prune_map();
141 new_map -> line = line;
142 new_map -> pos = pos;
143 new_map -> previous = current_map;
144 current_map = new_map;
145 current_map_size++;
146 }
147
148
149
150 /* Return position of column *c of ith line in */
151 /* current file. Adjust *c to be within the line.*/
152 /* A 0 pointer is taken as 0 column. */
153 /* Returns CORD_NOT_FOUND if i is too big. */
154 /* Assumes i > dis_line. */
155 size_t line_pos(int i, int *c)
156 {
157 int j;
158 size_t cur;
159 size_t next;
160 line_map map = current_map;
161
162 while (map -> line > i) map = map -> previous;
163 if (map -> line < i - 2) /* rebuild */ invalidate_map(i);
164 for (j = map -> line, cur = map -> pos; j < i;) {
165 cur = CORD_chr(current, cur, '\n');
166 if (cur == current_len-1) return(CORD_NOT_FOUND);
167 cur++;
168 if (++j > current_map -> line) add_map(j, cur);
169 }
170 if (c != 0) {
171 next = CORD_chr(current, cur, '\n');
172 if (next == CORD_NOT_FOUND) next = current_len - 1;
173 if (next < cur + *c) {
174 *c = next - cur;
175 }
176 cur += *c;
177 }
178 return(cur);
179 }
180
181 void add_hist(CORD s)
182 {
183 history new_file = GC_NEW(struct HistoryRep);
184
185 new_file -> file_contents = current = s;
186 current_len = CORD_len(s);
187 new_file -> previous = now;
188 if (now != 0) now -> map = current_map;
189 now = new_file;
190 }
191
192 void del_hist(void)
193 {
194 now = now -> previous;
195 current = now -> file_contents;
196 current_map = now -> map;
197 current_len = CORD_len(current);
198 }
199
200 /* Current screen_contents; a dynamically allocated array of CORDs */
201 CORD * screen = 0;
202 int screen_size = 0;
203
204 # ifndef WIN32
205 /* Replace a line in the curses stdscr. All control characters are */
206 /* displayed as upper case characters in standout mode. This isn't */
207 /* terribly appropriate for tabs. */
208 void replace_line(int i, CORD s)
209 {
210 register int c;
211 CORD_pos p;
212 size_t len = CORD_len(s);
213
214 if (screen == 0 || LINES > screen_size) {
215 screen_size = LINES;
216 screen = (CORD *)GC_MALLOC(screen_size * sizeof(CORD));
217 }
218 # if !defined(MACINTOSH)
219 /* A gross workaround for an apparent curses bug: */
220 if (i == LINES-1 && len == COLS) {
221 s = CORD_substr(s, 0, CORD_len(s) - 1);
222 }
223 # endif
224 if (CORD_cmp(screen[i], s) != 0) {
225 move(i, 0); clrtoeol(); move(i,0);
226
227 CORD_FOR (p, s) {
228 c = CORD_pos_fetch(p) & 0x7f;
229 if (iscntrl(c)) {
230 standout(); addch(c + 0x40); standend();
231 } else {
232 addch(c);
233 }
234 }
235 screen[i] = s;
236 }
237 }
238 #else
239 # define replace_line(i,s) invalidate_line(i)
240 #endif
241
242 /* Return up to COLS characters of the line of s starting at pos, */
243 /* returning only characters after the given column. */
244 CORD retrieve_line(CORD s, size_t pos, unsigned column)
245 {
246 CORD candidate = CORD_substr(s, pos, column + COLS);
247 /* avoids scanning very long lines */
248 int eol = CORD_chr(candidate, 0, '\n');
249 int len;
250
251 if (eol == CORD_NOT_FOUND) eol = CORD_len(candidate);
252 len = (int)eol - (int)column;
253 if (len < 0) len = 0;
254 return(CORD_substr(s, pos + column, len));
255 }
256
257 # ifdef WIN32
258 # define refresh();
259
260 CORD retrieve_screen_line(int i)
261 {
262 register size_t pos;
263
264 invalidate_map(dis_line + LINES); /* Prune search */
265 pos = line_pos(dis_line + i, 0);
266 if (pos == CORD_NOT_FOUND) return(CORD_EMPTY);
267 return(retrieve_line(current, pos, dis_col));
268 }
269 # endif
270
271 /* Display the visible section of the current file */
272 void redisplay(void)
273 {
274 register int i;
275
276 invalidate_map(dis_line + LINES); /* Prune search */
277 for (i = 0; i < LINES; i++) {
278 if (need_redisplay == ALL || need_redisplay == i) {
279 register size_t pos = line_pos(dis_line + i, 0);
280
281 if (pos == CORD_NOT_FOUND) break;
282 replace_line(i, retrieve_line(current, pos, dis_col));
283 if (need_redisplay == i) goto done;
284 }
285 }
286 for (; i < LINES; i++) replace_line(i, CORD_EMPTY);
287 done:
288 refresh();
289 need_redisplay = NONE;
290 }
291
292 int dis_granularity;
293
294 /* Update dis_line, dis_col, and dis_pos to make cursor visible. */
295 /* Assumes line, col, dis_line, dis_pos are in bounds. */
296 void normalize_display()
297 {
298 int old_line = dis_line;
299 int old_col = dis_col;
300
301 dis_granularity = 1;
302 if (LINES > 15 && COLS > 15) dis_granularity = 2;
303 while (dis_line > line) dis_line -= dis_granularity;
304 while (dis_col > col) dis_col -= dis_granularity;
305 while (line >= dis_line + LINES) dis_line += dis_granularity;
306 while (col >= dis_col + COLS) dis_col += dis_granularity;
307 if (old_line != dis_line || old_col != dis_col) {
308 need_redisplay = ALL;
309 }
310 }
311
312 # if defined(WIN32)
313 # elif defined(MACINTOSH)
314 # define move_cursor(x,y) cgotoxy(x + 1, y + 1, stdout)
315 # else
316 # define move_cursor(x,y) move(y,x)
317 # endif
318
319 /* Adjust display so that cursor is visible; move cursor into position */
320 /* Update screen if necessary. */
321 void fix_cursor(void)
322 {
323 normalize_display();
324 if (need_redisplay != NONE) redisplay();
325 move_cursor(col - dis_col, line - dis_line);
326 refresh();
327 # ifndef WIN32
328 fflush(stdout);
329 # endif
330 }
331
332 /* Make sure line, col, and dis_pos are somewhere inside file. */
333 /* Recompute file_pos. Assumes dis_pos is accurate or past eof */
334 void fix_pos()
335 {
336 int my_col = col;
337
338 if ((size_t)line > current_len) line = current_len;
339 file_pos = line_pos(line, &my_col);
340 if (file_pos == CORD_NOT_FOUND) {
341 for (line = current_map -> line, file_pos = current_map -> pos;
342 file_pos < current_len;
343 line++, file_pos = CORD_chr(current, file_pos, '\n') + 1);
344 line--;
345 file_pos = line_pos(line, &col);
346 } else {
347 col = my_col;
348 }
349 }
350
351 #if defined(WIN32)
352 # define beep() Beep(1000 /* Hz */, 300 /* msecs */)
353 #elif defined(MACINTOSH)
354 # define beep() SysBeep(1)
355 #else
356 /*
357 * beep() is part of some curses packages and not others.
358 * We try to match the type of the builtin one, if any.
359 */
360 #ifdef __STDC__
361 int beep(void)
362 #else
363 int beep()
364 #endif
365 {
366 putc('\007', stderr);
367 return(0);
368 }
369 #endif
370
371 # define NO_PREFIX -1
372 # define BARE_PREFIX -2
373 int repeat_count = NO_PREFIX; /* Current command prefix. */
374
375 int locate_mode = 0; /* Currently between 2 ^Ls */
376 CORD locate_string = CORD_EMPTY; /* Current search string. */
377
378 char * arg_file_name;
379
380 #ifdef WIN32
381 /* Change the current position to whatever is currently displayed at */
382 /* the given SCREEN coordinates. */
383 void set_position(int c, int l)
384 {
385 line = l + dis_line;
386 col = c + dis_col;
387 fix_pos();
388 move_cursor(col - dis_col, line - dis_line);
389 }
390 #endif /* WIN32 */
391
392 /* Perform the command associated with character c. C may be an */
393 /* integer > 256 denoting a windows command, one of the above control */
394 /* characters, or another ASCII character to be used as either a */
395 /* character to be inserted, a repeat count, or a search string, */
396 /* depending on the current state. */
397 void do_command(int c)
398 {
399 int i;
400 int need_fix_pos;
401 FILE * out;
402
403 if ( c == '\r') c = '\n';
404 if (locate_mode) {
405 size_t new_pos;
406
407 if (c == LOCATE) {
408 locate_mode = 0;
409 locate_string = CORD_EMPTY;
410 return;
411 }
412 locate_string = CORD_cat_char(locate_string, (char)c);
413 new_pos = CORD_str(current, file_pos - CORD_len(locate_string) + 1,
414 locate_string);
415 if (new_pos != CORD_NOT_FOUND) {
416 need_redisplay = ALL;
417 new_pos += CORD_len(locate_string);
418 for (;;) {
419 file_pos = line_pos(line + 1, 0);
420 if (file_pos > new_pos) break;
421 line++;
422 }
423 col = new_pos - line_pos(line, 0);
424 file_pos = new_pos;
425 fix_cursor();
426 } else {
427 locate_string = CORD_substr(locate_string, 0,
428 CORD_len(locate_string) - 1);
429 beep();
430 }
431 return;
432 }
433 if (c == REPEAT) {
434 repeat_count = BARE_PREFIX; return;
435 } else if (c < 0x100 && isdigit(c)){
436 if (repeat_count == BARE_PREFIX) {
437 repeat_count = c - '0'; return;
438 } else if (repeat_count != NO_PREFIX) {
439 repeat_count = 10 * repeat_count + c - '0'; return;
440 }
441 }
442 if (repeat_count == NO_PREFIX) repeat_count = 1;
443 if (repeat_count == BARE_PREFIX && (c == UP || c == DOWN)) {
444 repeat_count = LINES - dis_granularity;
445 }
446 if (repeat_count == BARE_PREFIX) repeat_count = 8;
447 need_fix_pos = 0;
448 for (i = 0; i < repeat_count; i++) {
449 switch(c) {
450 case LOCATE:
451 locate_mode = 1;
452 break;
453 case TOP:
454 line = col = file_pos = 0;
455 break;
456 case UP:
457 if (line != 0) {
458 line--;
459 need_fix_pos = 1;
460 }
461 break;
462 case DOWN:
463 line++;
464 need_fix_pos = 1;
465 break;
466 case LEFT:
467 if (col != 0) {
468 col--; file_pos--;
469 }
470 break;
471 case RIGHT:
472 if (CORD_fetch(current, file_pos) == '\n') break;
473 col++; file_pos++;
474 break;
475 case UNDO:
476 del_hist();
477 need_redisplay = ALL; need_fix_pos = 1;
478 break;
479 case BS:
480 if (col == 0) {
481 beep();
482 break;
483 }
484 col--; file_pos--;
485 /* fall through: */
486 case DEL:
487 if (file_pos == current_len-1) break;
488 /* Can't delete trailing newline */
489 if (CORD_fetch(current, file_pos) == '\n') {
490 need_redisplay = ALL; need_fix_pos = 1;
491 } else {
492 need_redisplay = line - dis_line;
493 }
494 add_hist(CORD_cat(
495 CORD_substr(current, 0, file_pos),
496 CORD_substr(current, file_pos+1, current_len)));
497 invalidate_map(line);
498 break;
499 case WRITE:
500 {
501 CORD name = CORD_cat(CORD_from_char_star(arg_file_name),
502 ".new");
503
504 if ((out = fopen(CORD_to_const_char_star(name), "wb")) == NULL
505 || CORD_put(current, out) == EOF) {
506 de_error("Write failed\n");
507 need_redisplay = ALL;
508 } else {
509 fclose(out);
510 }
511 }
512 break;
513 default:
514 {
515 CORD left_part = CORD_substr(current, 0, file_pos);
516 CORD right_part = CORD_substr(current, file_pos, current_len);
517
518 add_hist(CORD_cat(CORD_cat_char(left_part, (char)c),
519 right_part));
520 invalidate_map(line);
521 if (c == '\n') {
522 col = 0; line++; file_pos++;
523 need_redisplay = ALL;
524 } else {
525 col++; file_pos++;
526 need_redisplay = line - dis_line;
527 }
528 break;
529 }
530 }
531 }
532 if (need_fix_pos) fix_pos();
533 fix_cursor();
534 repeat_count = NO_PREFIX;
535 }
536
537 /* OS independent initialization */
538
539 void generic_init(void)
540 {
541 FILE * f;
542 CORD initial;
543
544 if ((f = fopen(arg_file_name, "rb")) == NULL) {
545 initial = "\n";
546 } else {
547 initial = CORD_from_file(f);
548 if (initial == CORD_EMPTY
549 || CORD_fetch(initial, CORD_len(initial)-1) != '\n') {
550 initial = CORD_cat(initial, "\n");
551 }
552 }
553 add_map(0,0);
554 add_hist(initial);
555 now -> map = current_map;
556 now -> previous = now; /* Can't back up further: beginning of the world */
557 need_redisplay = ALL;
558 fix_cursor();
559 }
560
561 #ifndef WIN32
562
563 main(argc, argv)
564 int argc;
565 char ** argv;
566 {
567 int c;
568
569 #if defined(MACINTOSH)
570 console_options.title = "\pDumb Editor";
571 cshow(stdout);
572 argc = ccommand(&argv);
573 #endif
574 GC_INIT();
575
576 if (argc != 2) goto usage;
577 arg_file_name = argv[1];
578 setvbuf(stdout, GC_MALLOC_ATOMIC(8192), _IOFBF, 8192);
579 initscr();
580 noecho(); nonl(); cbreak();
581 generic_init();
582 while ((c = getchar()) != QUIT) {
583 if (c == EOF) break;
584 do_command(c);
585 }
586 done:
587 move(LINES-1, 0);
588 clrtoeol();
589 refresh();
590 nl();
591 echo();
592 endwin();
593 exit(0);
594 usage:
595 fprintf(stderr, "Usage: %s file\n", argv[0]);
596 fprintf(stderr, "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n");
597 fprintf(stderr, "Undo: ^U Write to <file>.new: ^W");
598 fprintf(stderr, "Quit:^D Repeat count: ^R[n]\n");
599 fprintf(stderr, "Top: ^T Locate (search, find): ^L text ^L\n");
600 exit(1);
601 }
602
603 #endif /* !WIN32 */