PageRenderTime 46ms CodeModel.GetById 16ms app.highlight 25ms RepoModel.GetById 1ms app.codeStats 0ms

/vendor/gc/cord/de.c

http://github.com/feyeleanor/RubyGoLightly
C | 603 lines | 466 code | 59 blank | 78 comment | 131 complexity | 7d33b5ab9a3872847582496b7cfb6baf MD5 | raw file
  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.						  */
 75typedef 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 */
 82typedef struct HistoryRep {
 83    CORD file_contents;
 84    struct HistoryRep * previous;
 85    line_map map;	/* Invalid for first record "now" */
 86} * history;
 87
 88history now = 0;
 89CORD current;		/* == now -> file_contents.	*/
 90size_t current_len;	/* Current file length.		*/
 91line_map current_map = 0;	/* Current line no. to pos. map	 */
 92size_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 */
 98int dis_line = 0;
 99int dis_col = 0;
100
101# define ALL -1
102# define NONE - 2
103int need_redisplay = 0;	/* Line that needs to be redisplayed.	*/
104
105
106/* Current cursor position. Always within file. */
107int line = 0; 
108int col = 0;
109size_t file_pos = 0;	/* Character position corresponding to cursor.	*/
110
111/* Invalidate line map for lines > i */
112void 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.				  */
122void 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 */
136void 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.			 */
155size_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
181void 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
192void 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	*/
201CORD * screen = 0;
202int 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.									*/
208void 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.			*/
244CORD 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	 */
272void 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);
287done:
288    refresh();
289    need_redisplay = NONE;
290}
291
292int 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.			*/
296void 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.						*/
321void 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	*/
334void 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
373int repeat_count = NO_PREFIX;	/* Current command prefix. */
374
375int locate_mode = 0;			/* Currently between 2 ^Ls	*/
376CORD locate_string = CORD_EMPTY;	/* Current search string.	*/
377
378char * arg_file_name;
379
380#ifdef WIN32
381/* Change the current position to whatever is currently displayed at	*/
382/* the given SCREEN coordinates.					*/
383void 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.					*/
397void 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
539void 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
563main(argc, argv)
564int argc;
565char ** 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    }
586done:
587    move(LINES-1, 0);
588    clrtoeol();
589    refresh();
590    nl();
591    echo();
592    endwin();
593    exit(0);
594usage:
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 */