boehm-gc/cord/de.c

   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 */