| /* |
| * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. |
| * |
| * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED |
| * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. |
| * |
| * Permission is hereby granted to use or copy this program |
| * for any purpose, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is granted, |
| * provided the above notices are retained, and a notice that the code was |
| * modified is included with the above copyright notice. |
| * |
| * Author: Hans-J. Boehm (boehm@parc.xerox.com) |
| */ |
| /* |
| * A really simple-minded text editor based on cords. |
| * Things it does right: |
| * No size bounds. |
| * Inbounded undo. |
| * Shouldn't crash no matter what file you invoke it on (e.g. /vmunix) |
| * (Make sure /vmunix is not writable before you try this.) |
| * Scrolls horizontally. |
| * Things it does wrong: |
| * It doesn't handle tabs reasonably (use "expand" first). |
| * The command set is MUCH too small. |
| * The redisplay algorithm doesn't let curses do the scrolling. |
| * The rule for moving the window over the file is suboptimal. |
| */ |
| /* Boehm, February 6, 1995 12:27 pm PST */ |
| |
| /* Boehm, May 19, 1994 2:20 pm PDT */ |
| #include <stdio.h> |
| #include "gc.h" |
| #include "cord.h" |
| |
| #ifdef THINK_C |
| #define MACINTOSH |
| #include <ctype.h> |
| #endif |
| |
| #if defined(__BORLANDC__) && !defined(WIN32) |
| /* If this is DOS or win16, we'll fail anyway. */ |
| /* Might as well assume win32. */ |
| # define WIN32 |
| #endif |
| |
| #if defined(WIN32) |
| # include <windows.h> |
| # include "de_win.h" |
| #elif defined(MACINTOSH) |
| # include <console.h> |
| /* curses emulation. */ |
| # define initscr() |
| # define endwin() |
| # define nonl() |
| # define noecho() csetmode(C_NOECHO, stdout) |
| # define cbreak() csetmode(C_CBREAK, stdout) |
| # define refresh() |
| # define addch(c) putchar(c) |
| # define standout() cinverse(1, stdout) |
| # define standend() cinverse(0, stdout) |
| # define move(line,col) cgotoxy(col + 1, line + 1, stdout) |
| # define clrtoeol() ccleol(stdout) |
| # define de_error(s) { fprintf(stderr, s); getchar(); } |
| # define LINES 25 |
| # define COLS 80 |
| #else |
| # include <curses.h> |
| # define de_error(s) { fprintf(stderr, s); sleep(2); } |
| #endif |
| #include "de_cmds.h" |
| |
| /* List of line number to position mappings, in descending order. */ |
| /* There may be holes. */ |
| typedef struct LineMapRep { |
| int line; |
| size_t pos; |
| struct LineMapRep * previous; |
| } * line_map; |
| |
| /* List of file versions, one per edit operation */ |
| typedef struct HistoryRep { |
| CORD file_contents; |
| struct HistoryRep * previous; |
| line_map map; /* Invalid for first record "now" */ |
| } * history; |
| |
| history now = 0; |
| CORD current; /* == now -> file_contents. */ |
| size_t current_len; /* Current file length. */ |
| line_map current_map = 0; /* Current line no. to pos. map */ |
| size_t current_map_size = 0; /* Number of current_map entries. */ |
| /* Not always accurate, but reset */ |
| /* by prune_map. */ |
| # define MAX_MAP_SIZE 3000 |
| |
| /* Current display position */ |
| int dis_line = 0; |
| int dis_col = 0; |
| |
| # define ALL -1 |
| # define NONE - 2 |
| int need_redisplay = 0; /* Line that needs to be redisplayed. */ |
| |
| |
| /* Current cursor position. Always within file. */ |
| int line = 0; |
| int col = 0; |
| size_t file_pos = 0; /* Character position corresponding to cursor. */ |
| |
| /* Invalidate line map for lines > i */ |
| void invalidate_map(int i) |
| { |
| while(current_map -> line > i) { |
| current_map = current_map -> previous; |
| current_map_size--; |
| } |
| } |
| |
| /* Reduce the number of map entries to save space for huge files. */ |
| /* This also affects maps in histories. */ |
| void prune_map() |
| { |
| line_map map = current_map; |
| int start_line = map -> line; |
| |
| current_map_size = 0; |
| for(; map != 0; map = map -> previous) { |
| current_map_size++; |
| if (map -> line < start_line - LINES && map -> previous != 0) { |
| map -> previous = map -> previous -> previous; |
| } |
| } |
| } |
| /* Add mapping entry */ |
| void add_map(int line, size_t pos) |
| { |
| line_map new_map = GC_NEW(struct LineMapRep); |
| |
| if (current_map_size >= MAX_MAP_SIZE) prune_map(); |
| new_map -> line = line; |
| new_map -> pos = pos; |
| new_map -> previous = current_map; |
| current_map = new_map; |
| current_map_size++; |
| } |
| |
| |
| |
| /* Return position of column *c of ith line in */ |
| /* current file. Adjust *c to be within the line.*/ |
| /* A 0 pointer is taken as 0 column. */ |
| /* Returns CORD_NOT_FOUND if i is too big. */ |
| /* Assumes i > dis_line. */ |
| size_t line_pos(int i, int *c) |
| { |
| int j; |
| size_t cur; |
| size_t next; |
| line_map map = current_map; |
| |
| while (map -> line > i) map = map -> previous; |
| if (map -> line < i - 2) /* rebuild */ invalidate_map(i); |
| for (j = map -> line, cur = map -> pos; j < i;) { |
| cur = CORD_chr(current, cur, '\n'); |
| if (cur == current_len-1) return(CORD_NOT_FOUND); |
| cur++; |
| if (++j > current_map -> line) add_map(j, cur); |
| } |
| if (c != 0) { |
| next = CORD_chr(current, cur, '\n'); |
| if (next == CORD_NOT_FOUND) next = current_len - 1; |
| if (next < cur + *c) { |
| *c = next - cur; |
| } |
| cur += *c; |
| } |
| return(cur); |
| } |
| |
| void add_hist(CORD s) |
| { |
| history new_file = GC_NEW(struct HistoryRep); |
| |
| new_file -> file_contents = current = s; |
| current_len = CORD_len(s); |
| new_file -> previous = now; |
| if (now != 0) now -> map = current_map; |
| now = new_file; |
| } |
| |
| void del_hist(void) |
| { |
| now = now -> previous; |
| current = now -> file_contents; |
| current_map = now -> map; |
| current_len = CORD_len(current); |
| } |
| |
| /* Current screen_contents; a dynamically allocated array of CORDs */ |
| CORD * screen = 0; |
| int screen_size = 0; |
| |
| # ifndef WIN32 |
| /* Replace a line in the curses stdscr. All control characters are */ |
| /* displayed as upper case characters in standout mode. This isn't */ |
| /* terribly appropriate for tabs. */ |
| void replace_line(int i, CORD s) |
| { |
| register int c; |
| CORD_pos p; |
| size_t len = CORD_len(s); |
| |
| if (screen == 0 || LINES > screen_size) { |
| screen_size = LINES; |
| screen = (CORD *)GC_MALLOC(screen_size * sizeof(CORD)); |
| } |
| # if !defined(MACINTOSH) |
| /* A gross workaround for an apparent curses bug: */ |
| if (i == LINES-1 && len == COLS) { |
| s = CORD_substr(s, 0, CORD_len(s) - 1); |
| } |
| # endif |
| if (CORD_cmp(screen[i], s) != 0) { |
| move(i, 0); clrtoeol(); move(i,0); |
| |
| CORD_FOR (p, s) { |
| c = CORD_pos_fetch(p) & 0x7f; |
| if (iscntrl(c)) { |
| standout(); addch(c + 0x40); standend(); |
| } else { |
| addch(c); |
| } |
| } |
| screen[i] = s; |
| } |
| } |
| #else |
| # define replace_line(i,s) invalidate_line(i) |
| #endif |
| |
| /* Return up to COLS characters of the line of s starting at pos, */ |
| /* returning only characters after the given column. */ |
| CORD retrieve_line(CORD s, size_t pos, unsigned column) |
| { |
| CORD candidate = CORD_substr(s, pos, column + COLS); |
| /* avoids scanning very long lines */ |
| int eol = CORD_chr(candidate, 0, '\n'); |
| int len; |
| |
| if (eol == CORD_NOT_FOUND) eol = CORD_len(candidate); |
| len = (int)eol - (int)column; |
| if (len < 0) len = 0; |
| return(CORD_substr(s, pos + column, len)); |
| } |
| |
| # ifdef WIN32 |
| # define refresh(); |
| |
| CORD retrieve_screen_line(int i) |
| { |
| register size_t pos; |
| |
| invalidate_map(dis_line + LINES); /* Prune search */ |
| pos = line_pos(dis_line + i, 0); |
| if (pos == CORD_NOT_FOUND) return(CORD_EMPTY); |
| return(retrieve_line(current, pos, dis_col)); |
| } |
| # endif |
| |
| /* Display the visible section of the current file */ |
| void redisplay(void) |
| { |
| register int i; |
| |
| invalidate_map(dis_line + LINES); /* Prune search */ |
| for (i = 0; i < LINES; i++) { |
| if (need_redisplay == ALL || need_redisplay == i) { |
| register size_t pos = line_pos(dis_line + i, 0); |
| |
| if (pos == CORD_NOT_FOUND) break; |
| replace_line(i, retrieve_line(current, pos, dis_col)); |
| if (need_redisplay == i) goto done; |
| } |
| } |
| for (; i < LINES; i++) replace_line(i, CORD_EMPTY); |
| done: |
| refresh(); |
| need_redisplay = NONE; |
| } |
| |
| int dis_granularity; |
| |
| /* Update dis_line, dis_col, and dis_pos to make cursor visible. */ |
| /* Assumes line, col, dis_line, dis_pos are in bounds. */ |
| void normalize_display() |
| { |
| int old_line = dis_line; |
| int old_col = dis_col; |
| |
| dis_granularity = 1; |
| if (LINES > 15 && COLS > 15) dis_granularity = 2; |
| while (dis_line > line) dis_line -= dis_granularity; |
| while (dis_col > col) dis_col -= dis_granularity; |
| while (line >= dis_line + LINES) dis_line += dis_granularity; |
| while (col >= dis_col + COLS) dis_col += dis_granularity; |
| if (old_line != dis_line || old_col != dis_col) { |
| need_redisplay = ALL; |
| } |
| } |
| |
| # if defined(WIN32) |
| # elif defined(MACINTOSH) |
| # define move_cursor(x,y) cgotoxy(x + 1, y + 1, stdout) |
| # else |
| # define move_cursor(x,y) move(y,x) |
| # endif |
| |
| /* Adjust display so that cursor is visible; move cursor into position */ |
| /* Update screen if necessary. */ |
| void fix_cursor(void) |
| { |
| normalize_display(); |
| if (need_redisplay != NONE) redisplay(); |
| move_cursor(col - dis_col, line - dis_line); |
| refresh(); |
| # ifndef WIN32 |
| fflush(stdout); |
| # endif |
| } |
| |
| /* Make sure line, col, and dis_pos are somewhere inside file. */ |
| /* Recompute file_pos. Assumes dis_pos is accurate or past eof */ |
| void fix_pos() |
| { |
| int my_col = col; |
| |
| if ((size_t)line > current_len) line = current_len; |
| file_pos = line_pos(line, &my_col); |
| if (file_pos == CORD_NOT_FOUND) { |
| for (line = current_map -> line, file_pos = current_map -> pos; |
| file_pos < current_len; |
| line++, file_pos = CORD_chr(current, file_pos, '\n') + 1); |
| line--; |
| file_pos = line_pos(line, &col); |
| } else { |
| col = my_col; |
| } |
| } |
| |
| #if defined(WIN32) |
| # define beep() Beep(1000 /* Hz */, 300 /* msecs */) |
| #elif defined(MACINTOSH) |
| # define beep() SysBeep(1) |
| #else |
| /* |
| * beep() is part of some curses packages and not others. |
| * We try to match the type of the builtin one, if any. |
| */ |
| #ifdef __STDC__ |
| int beep(void) |
| #else |
| int beep() |
| #endif |
| { |
| putc('\007', stderr); |
| return(0); |
| } |
| #endif |
| |
| # define NO_PREFIX -1 |
| # define BARE_PREFIX -2 |
| int repeat_count = NO_PREFIX; /* Current command prefix. */ |
| |
| int locate_mode = 0; /* Currently between 2 ^Ls */ |
| CORD locate_string = CORD_EMPTY; /* Current search string. */ |
| |
| char * arg_file_name; |
| |
| #ifdef WIN32 |
| /* Change the current position to whatever is currently displayed at */ |
| /* the given SCREEN coordinates. */ |
| void set_position(int c, int l) |
| { |
| line = l + dis_line; |
| col = c + dis_col; |
| fix_pos(); |
| move_cursor(col - dis_col, line - dis_line); |
| } |
| #endif /* WIN32 */ |
| |
| /* Perform the command associated with character c. C may be an */ |
| /* integer > 256 denoting a windows command, one of the above control */ |
| /* characters, or another ASCII character to be used as either a */ |
| /* character to be inserted, a repeat count, or a search string, */ |
| /* depending on the current state. */ |
| void do_command(int c) |
| { |
| int i; |
| int need_fix_pos; |
| FILE * out; |
| |
| if ( c == '\r') c = '\n'; |
| if (locate_mode) { |
| size_t new_pos; |
| |
| if (c == LOCATE) { |
| locate_mode = 0; |
| locate_string = CORD_EMPTY; |
| return; |
| } |
| locate_string = CORD_cat_char(locate_string, (char)c); |
| new_pos = CORD_str(current, file_pos - CORD_len(locate_string) + 1, |
| locate_string); |
| if (new_pos != CORD_NOT_FOUND) { |
| need_redisplay = ALL; |
| new_pos += CORD_len(locate_string); |
| for (;;) { |
| file_pos = line_pos(line + 1, 0); |
| if (file_pos > new_pos) break; |
| line++; |
| } |
| col = new_pos - line_pos(line, 0); |
| file_pos = new_pos; |
| fix_cursor(); |
| } else { |
| locate_string = CORD_substr(locate_string, 0, |
| CORD_len(locate_string) - 1); |
| beep(); |
| } |
| return; |
| } |
| if (c == REPEAT) { |
| repeat_count = BARE_PREFIX; return; |
| } else if (c < 0x100 && isdigit(c)){ |
| if (repeat_count == BARE_PREFIX) { |
| repeat_count = c - '0'; return; |
| } else if (repeat_count != NO_PREFIX) { |
| repeat_count = 10 * repeat_count + c - '0'; return; |
| } |
| } |
| if (repeat_count == NO_PREFIX) repeat_count = 1; |
| if (repeat_count == BARE_PREFIX && (c == UP || c == DOWN)) { |
| repeat_count = LINES - dis_granularity; |
| } |
| if (repeat_count == BARE_PREFIX) repeat_count = 8; |
| need_fix_pos = 0; |
| for (i = 0; i < repeat_count; i++) { |
| switch(c) { |
| case LOCATE: |
| locate_mode = 1; |
| break; |
| case TOP: |
| line = col = file_pos = 0; |
| break; |
| case UP: |
| if (line != 0) { |
| line--; |
| need_fix_pos = 1; |
| } |
| break; |
| case DOWN: |
| line++; |
| need_fix_pos = 1; |
| break; |
| case LEFT: |
| if (col != 0) { |
| col--; file_pos--; |
| } |
| break; |
| case RIGHT: |
| if (CORD_fetch(current, file_pos) == '\n') break; |
| col++; file_pos++; |
| break; |
| case UNDO: |
| del_hist(); |
| need_redisplay = ALL; need_fix_pos = 1; |
| break; |
| case BS: |
| if (col == 0) { |
| beep(); |
| break; |
| } |
| col--; file_pos--; |
| /* fall through: */ |
| case DEL: |
| if (file_pos == current_len-1) break; |
| /* Can't delete trailing newline */ |
| if (CORD_fetch(current, file_pos) == '\n') { |
| need_redisplay = ALL; need_fix_pos = 1; |
| } else { |
| need_redisplay = line - dis_line; |
| } |
| add_hist(CORD_cat( |
| CORD_substr(current, 0, file_pos), |
| CORD_substr(current, file_pos+1, current_len))); |
| invalidate_map(line); |
| break; |
| case WRITE: |
| { |
| CORD name = CORD_cat(CORD_from_char_star(arg_file_name), |
| ".new"); |
| |
| if ((out = fopen(CORD_to_const_char_star(name), "wb")) == NULL |
| || CORD_put(current, out) == EOF) { |
| de_error("Write failed\n"); |
| need_redisplay = ALL; |
| } else { |
| fclose(out); |
| } |
| } |
| break; |
| default: |
| { |
| CORD left_part = CORD_substr(current, 0, file_pos); |
| CORD right_part = CORD_substr(current, file_pos, current_len); |
| |
| add_hist(CORD_cat(CORD_cat_char(left_part, (char)c), |
| right_part)); |
| invalidate_map(line); |
| if (c == '\n') { |
| col = 0; line++; file_pos++; |
| need_redisplay = ALL; |
| } else { |
| col++; file_pos++; |
| need_redisplay = line - dis_line; |
| } |
| break; |
| } |
| } |
| } |
| if (need_fix_pos) fix_pos(); |
| fix_cursor(); |
| repeat_count = NO_PREFIX; |
| } |
| |
| /* OS independent initialization */ |
| |
| void generic_init(void) |
| { |
| FILE * f; |
| CORD initial; |
| |
| if ((f = fopen(arg_file_name, "rb")) == NULL) { |
| initial = "\n"; |
| } else { |
| initial = CORD_from_file(f); |
| if (initial == CORD_EMPTY |
| || CORD_fetch(initial, CORD_len(initial)-1) != '\n') { |
| initial = CORD_cat(initial, "\n"); |
| } |
| } |
| add_map(0,0); |
| add_hist(initial); |
| now -> map = current_map; |
| now -> previous = now; /* Can't back up further: beginning of the world */ |
| need_redisplay = ALL; |
| fix_cursor(); |
| } |
| |
| #ifndef WIN32 |
| |
| main(argc, argv) |
| int argc; |
| char ** argv; |
| { |
| int c; |
| |
| #if defined(MACINTOSH) |
| console_options.title = "\pDumb Editor"; |
| cshow(stdout); |
| argc = ccommand(&argv); |
| #endif |
| GC_INIT(); |
| |
| if (argc != 2) goto usage; |
| arg_file_name = argv[1]; |
| setvbuf(stdout, GC_MALLOC_ATOMIC(8192), _IOFBF, 8192); |
| initscr(); |
| noecho(); nonl(); cbreak(); |
| generic_init(); |
| while ((c = getchar()) != QUIT) { |
| if (c == EOF) break; |
| do_command(c); |
| } |
| done: |
| move(LINES-1, 0); |
| clrtoeol(); |
| refresh(); |
| nl(); |
| echo(); |
| endwin(); |
| exit(0); |
| usage: |
| fprintf(stderr, "Usage: %s file\n", argv[0]); |
| fprintf(stderr, "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n"); |
| fprintf(stderr, "Undo: ^U Write to <file>.new: ^W"); |
| fprintf(stderr, "Quit:^D Repeat count: ^R[n]\n"); |
| fprintf(stderr, "Top: ^T Locate (search, find): ^L text ^L\n"); |
| exit(1); |
| } |
| |
| #endif /* !WIN32 */ |
