phunix/commands/mined/mined2.c

/*
 * Part 2 of the mined editor.
 */

/*  ========================================================================  *
 *				Move Commands				      *	
 *  ========================================================================  */

#include "mined.h"
#include <string.h>

/*
 * Move one line up.
 */
void UP()
{
  if (y == 0) {		/* Top line of screen. Scroll one line */
  	(void) reverse_scroll();
  	move_to(x, y);
  }
  else			/* Move to previous line */
  	move_to(x, y - 1);
}

/*
 * Move one line down.
 */
void DN()
{
  if (y == last_y) {	/* Last line of screen. Scroll one line */
	if (bot_line->next == tail && bot_line->text[0] != '\n') {
		dummy_line();		/* Create new empty line */
		DN();
		return;
	}
	else {
		(void) forward_scroll();
		move_to(x, y);
	}
  }
  else			/* Move to next line */
  	move_to(x, y + 1);
}

/*
 * Move left one position.
 */
void LF()
{
  if (x == 0 && get_shift(cur_line->shift_count) == 0) {/* Begin of line */
	if (cur_line->prev != header) {
		UP();					/* Move one line up */
		move_to(LINE_END, y);
	}
  }
  else
  	move_to(x - 1, y);
}

/*
 * Move right one position.
 */
void RT()
{
  if (*cur_text == '\n') {
  	if (cur_line->next != tail) {		/* Last char of file */
		DN();				/* Move one line down */
		move_to(LINE_START, y);
	}
  }
  else
  	move_to(x + 1, y);
}

/*
 * Move to coordinates [0, 0] on screen.
 */
void HIGH()
{
  move_to(0, 0);
}

/*
 * Move to coordinates [0, YMAX] on screen.
 */
void LOW()
{
  move_to(0, last_y);
}

/*
 * Move to begin of line.
 */
void BL()
{
  move_to(LINE_START, y);
}

/*
 * Move to end of line.
 */
void EL()
{
  move_to(LINE_END, y);
}

/*
 * GOTO() prompts for a linenumber and moves to that line.
 */
void GOTO()
{
  int number;
  LINE *line;

  if (get_number("Please enter line number.", &number) == ERRORS)
  	return;

  if (number <= 0 || (line = proceed(header->next, number - 1)) == tail)
  	error("Illegal line number: ", num_out((long) number));
  else
  	move_to(x, find_y(line));
}

/*
 * Scroll forward one page or to eof, whatever comes first. (Bot_line becomes 
 * top_line of display.) Try to leave the cursor on the same line. If this is
 * not possible, leave cursor on the line halfway the page.
 */
void PD()
{
  register int i;

  for (i = 0; i < screenmax; i++)
  	if (forward_scroll() == ERRORS)
  		break;			/* EOF reached */
  if (y - i < 0)				/* Line no longer on screen */
  	move_to(0, screenmax >> 1);
  else
  	move_to(0, y - i);
}


/*
 * Scroll backwards one page or to top of file, whatever comes first. (Top_line
 * becomes bot_line of display).  The very bottom line (YMAX) is always blank.
 * Try to leave the cursor on the same line. If this is not possible, leave
 * cursor on the line halfway the page.
 */
void PU()
{
  register int i;

  for (i = 0; i < screenmax; i++)
  	if (reverse_scroll() == ERRORS)
  		break;			/* Top of file reached */
  set_cursor(0, ymax);			/* Erase very bottom line */
#ifdef UNIX
  tputs(CE, 0, _putchar);
#else
  string_print(blank_line);
#endif /* UNIX */
  if (y + i > screenmax)			/* line no longer on screen */
  	move_to(0, screenmax >> 1);
  else
  	move_to(0, y + i);
}

/*
 * Go to top of file, scrolling if possible, else redrawing screen.
 */
void HO()
{
  if (proceed(top_line, -screenmax) == header)
  	PU();			/* It fits. Let PU do it */
  else {
  	reset(header->next, 0);/* Reset top_line, etc. */
  	RD();			/* Display full page */
  }
  move_to(LINE_START, 0);
}

/*
 * Go to last line of file, scrolling if possible, else redrawing screen
 */
void EF()
{
  if (tail->prev->text[0] != '\n')
	dummy_line();
  if (proceed(bot_line, screenmax) == tail)
  	PD();			/* It fits. Let PD do it */
  else {
  	reset(proceed(tail->prev, -screenmax), screenmax);
  	RD();			/* Display full page */
  }
  move_to(LINE_START, last_y);
}

/*
 * Scroll one line up. Leave the cursor on the same line (if possible).
 */
void SU()
{
  if (top_line->prev == header)	/* Top of file. Can't scroll */
  	return;

  (void) reverse_scroll();
  set_cursor(0, ymax);		/* Erase very bottom line */
#ifdef UNIX
  tputs(CE, 0, _putchar);
#else
  string_print(blank_line);
#endif /* UNIX */
  move_to(x, (y == screenmax) ? screenmax : y + 1);
}

/*
 * Scroll one line down. Leave the cursor on the same line (if possible).
 */
void SD()
{
  if (forward_scroll() != ERRORS) 
  	move_to(x, (y == 0) ? 0 : y - 1);
  else
  	set_cursor(x, y);
}

/*
 * Perform a forward scroll. It returns ERRORS if we're at the last line of the
 * file.
 */
int forward_scroll()
{
  if (bot_line->next == tail)		/* Last line of file. No dice */
  	return ERRORS;
  top_line = top_line->next;
  bot_line = bot_line->next;
  cur_line = cur_line->next;
  set_cursor(0, ymax);
  line_print(bot_line);

  return FINE;
}

/*
 * Perform a backwards scroll. It returns ERRORS if we're at the first line
 * of the file.
 */
int reverse_scroll()
{
  if (top_line->prev == header)
  	return ERRORS;		/* Top of file. Can't scroll */

  if (last_y != screenmax)	/* Reset last_y if necessary */
  	last_y++;
  else
  	bot_line = bot_line->prev;	/* Else adjust bot_line */
  top_line = top_line->prev;
  cur_line = cur_line->prev;

/* Perform the scroll */
  set_cursor(0, 0);
#ifdef UNIX
  tputs(AL, 0, _putchar);
#else
  string_print(rev_scroll);
#endif /* UNIX */
  set_cursor(0, 0);
  line_print(top_line);

  return FINE;
}

/*
 * A word is defined as a number of non-blank characters separated by tabs
 * spaces or linefeeds.
 */

/*
 * MP() moves to the start of the previous word. A word is defined as a
 * number of non-blank characters separated by tabs spaces or linefeeds.
 */
void MP()
{
  move_previous_word(NO_DELETE);
}

void move_previous_word(remove)
FLAG remove;
{
  register char *begin_line;
  register char *textp;
  char start_char = *cur_text;
  char *start_pos = cur_text;

/* Fist check if we're at the beginning of line. */
  if (cur_text == cur_line->text) {
  	if (cur_line->prev == header)
  		return;
  	start_char = '\0';
  }

  LF();

  begin_line = cur_line->text;
  textp = cur_text;

/* Check if we're in the middle of a word. */
  if (!alpha(*textp) || !alpha(start_char)) {
  	while (textp != begin_line && (white_space(*textp) || *textp == '\n'))
  		textp--;
  }

/* Now we're at the end of previous word. Skip non-blanks until a blank comes */
  while (textp != begin_line && alpha(*textp))
  	textp--;

/* Go to the next char if we're not at the beginning of the line */
  if (textp != begin_line && *textp != '\n')
  	textp++;

/* Find the x-coordinate of this address, and move to it */
  move_address(textp);
  if (remove == DELETE)
  	delete(cur_line, textp, cur_line, start_pos);
}

/*
 * MN() moves to the start of the next word. A word is defined as a number of
 * non-blank characters separated by tabs spaces or linefeeds. Always keep in
 * mind that the pointer shouldn't pass the '\n'.
 */
void MN()
{
  move_next_word(NO_DELETE);
}

void move_next_word(remove)
FLAG remove;
{
  register char *textp = cur_text;

/* Move to the end of the current word. */
  while (*textp != '\n' && alpha(*textp))
  	textp++;

/* Skip all white spaces */
  while (*textp != '\n' && white_space(*textp))
  	textp++;
/* If we're deleting. delete the text in between */
  if (remove == DELETE) {
  	delete(cur_line, cur_text, cur_line, textp);
  	return;
  }

/* If we're at end of line. move to the first word on the next line. */
  if (*textp == '\n' && cur_line->next != tail) {
  	DN();
  	move_to(LINE_START, y);
  	textp = cur_text;
  	while (*textp != '\n' && white_space(*textp))
  		textp++;
  }
  move_address(textp);
}

/*  ========================================================================  *
 *				Modify Commands				      *
 *  ========================================================================  */

/*
 * DCC deletes the character under the cursor.  If this character is a '\n' the
 * current line is joined with the next one.
 * If this character is the only character of the line, the current line will
 * be deleted.
 */
void DCC()
{
  if (*cur_text == '\n')
  	delete(cur_line,cur_text, cur_line->next,cur_line->next->text);
  else
  	delete(cur_line, cur_text, cur_line, cur_text + 1);
}

/*
 * DPC deletes the character on the left side of the cursor.  If the cursor is
 * at the beginning of the line, the last character if the previous line is
 * deleted. 
 */
void DPC()
{
  if (x == 0 && cur_line->prev == header)
  	return;			/* Top of file */
  
  LF();				/* Move one left */
  DCC();				/* Delete character under cursor */
}

/*
 * DLN deletes all characters until the end of the line. If the current
 * character is a '\n', then delete that char.
 */
void DLN()
{
  if (*cur_text == '\n')
  	DCC();
  else
  	delete(cur_line, cur_text, cur_line, cur_text + length_of(cur_text) -1);
}

/*
 * DNW() deletes the next word (as described in MN())
 */
void DNW()
{
  if (*cur_text == '\n')
  	DCC();
  else
  	move_next_word(DELETE);
}

/*
 * DPW() deletes the next word (as described in MP())
 */
void DPW()
{
  if (cur_text == cur_line->text)
  	DPC();
  else
  	move_previous_word(DELETE);
}

/*
 * Insert character `character' at current location.
 */
void S(character)
register char character;
{
  static char buffer[2];

  buffer[0] = character;
/* Insert the character */
  if (insert(cur_line, cur_text, buffer) == ERRORS)
  	return;

/* Fix screen */
  if (character == '\n') {
  	set_cursor(0, y);
  	if (y == screenmax) {		/* Can't use display */
  		line_print(cur_line);
  		(void) forward_scroll();
  	}
  	else {
  		reset(top_line, y);	/* Reset pointers */
  		display(0, y, cur_line, last_y - y);
  	}
  	move_to(0, (y == screenmax) ? y : y + 1);
  }
  else if (x + 1 == XBREAK)/* If line must be shifted, just call move_to*/
  	move_to(x + 1, y);
  else {			 /* else display rest of line */
  	put_line(cur_line, x, FALSE);
  	move_to(x + 1, y);
  }
}

/*
 * CTL inserts a control-char at the current location. A message that this
 * function is called is displayed at the status line.
 */
void CTL()
{
  register char ctrl;

  status_line("Enter control character.", NIL_PTR);
  if ((ctrl = getchar()) >= '\01' && ctrl <= '\037') {
  	S(ctrl);		/* Insert the char */
	clear_status();
  }
  else
	error ("Unknown control character", NIL_PTR);
}

/*
 * LIB insert a line at the current position and moves back to the end of
 * the previous line.
 */
void LIB()
{
  S('\n');	  		/* Insert the line */
  UP();				/* Move one line up */
  move_to(LINE_END, y);		/* Move to end of this line */
}

/*
 * Line_insert() inserts a new line with text pointed to by `string'.
 * It returns the address of the new line.
 */
LINE *line_insert(line, string, len)
register LINE *line;
char *string;
int len;
{
  register LINE *new_line;

/* Allocate space for LINE structure and text */
  new_line = install_line(string, len);

/* Install the line into the double linked list */
  new_line->prev = line;
  new_line->next = line->next;
  line->next = new_line;
  new_line->next->prev = new_line;

/* Increment nlines */
  nlines++;

  return new_line;
}

/*
 * Insert() insert the string `string' at the given line and location.
 */
int insert(line, location, string)
register LINE *line;
char *location, *string;
{
  register char *bufp = text_buffer;	/* Buffer for building line */
  register char *textp = line->text;

  if (length_of(textp) + length_of(string) >= MAX_CHARS) {
  	error("Line too long", NIL_PTR);
  	return ERRORS;
  }

  modified = TRUE;			/* File has been modified */

/* Copy part of line until `location' has been reached */
  while (textp != location)
  	*bufp++ = *textp++;
  
/* Insert string at this location */
  while (*string != '\0')
  	*bufp++ = *string++;
  *bufp = '\0';
  
  if (*(string - 1) == '\n')		/* Insert a new line */
  	(void) line_insert(line, location, length_of(location));
  else					/* Append last part of line */
  	copy_string(bufp, location);

/* Install the new text in this line */
  free_space(line->text);
  line->text = alloc(length_of(text_buffer) + 1);
  copy_string(line->text, text_buffer);

  return FINE;
}

/*
 * Line_delete() deletes the argument line out of the line list. The pointer to
 * the next line is returned.
 */
LINE *line_delete(line)
register LINE *line;
{
  register LINE *next_line = line->next;

/* Delete the line */
  line->prev->next = line->next;
  line->next->prev = line->prev;

/* Free allocated space */
  free_space(line->text);
  free_space((char*)line);

/* Decrement nlines */
  nlines--;

  return next_line;
}

/*
 * Delete() deletes all the characters (including newlines) between the
 * startposition and endposition and fixes the screen accordingly. It
 * returns the number of lines deleted.
 */
void delete(start_line, start_textp, end_line, end_textp)
register LINE *start_line;
LINE *end_line;
char *start_textp, *end_textp;
{
  register char *textp = start_line->text;
  register char *bufp = text_buffer;	/* Storage for new line->text */
  LINE *line, *stop;
  int line_cnt = 0;			/* Nr of lines deleted */
  int count = 0;
  int shift = 0;				/* Used in shift calculation */
  int nx = x;

  modified = TRUE;			/* File has been modified */

/* Set up new line. Copy first part of start line until start_position. */
  while (textp < start_textp) {
  	*bufp++ = *textp++;
  	count++;
  }

/* Check if line doesn't exceed MAX_CHARS */
  if (count + length_of(end_textp) >= MAX_CHARS) {
  	error("Line too long", NIL_PTR);
  	return;
  }

/* Copy last part of end_line if end_line is not tail */
  copy_string(bufp, (end_textp != NIL_PTR) ? end_textp : "\n");

/* Delete all lines between start and end_position (including end_line) */
  line = start_line->next;
  stop = end_line->next;
  while (line != stop && line != tail) {
  	line = line_delete(line);
  	line_cnt++;
  }

/* Check if last line of file should be deleted */
  if (end_textp == NIL_PTR && length_of(start_line->text) == 1 && nlines > 1) {
  	start_line = start_line->prev;
  	(void) line_delete(start_line->next);
  	line_cnt++;
  }
  else {	/* Install new text */
  	free_space(start_line->text);
  	start_line->text = alloc(length_of(text_buffer) + 1);
  	copy_string(start_line->text, text_buffer);
  }

/* Fix screen. First check if line is shifted. Perhaps we should shift it back*/
  if (get_shift(start_line->shift_count)) {
  	shift = (XBREAK - count_chars(start_line)) / SHIFT_SIZE;
  	if (shift > 0) {		/* Shift line `shift' back */
  		if (shift >= get_shift(start_line->shift_count))
  			start_line->shift_count = 0;
  		else
  			start_line->shift_count -= shift;
  		nx += shift * SHIFT_SIZE;/* Reset x value */
  	}
  }

  if (line_cnt == 0) {		    /* Check if only one line changed */
  	if (shift > 0) {	    /* Reprint whole line */
  		set_cursor(0, y);
  		line_print(start_line);
  	}
  	else {			    /* Just display last part of line */
  		set_cursor(x, y);
  		put_line(start_line, x, TRUE);
  	}
  	move_to(nx, y);	   /* Reset cur_text */
  	return;
  }

  shift = last_y;	   /* Save value */
  reset(top_line, y);
  display(0, y, start_line, shift - y);
  move_to((line_cnt == 1) ? nx : 0, y);
}

/*  ========================================================================  *
 *				Yank Commands				      *	
 *  ========================================================================  */

LINE *mark_line;			/* For marking position. */
char *mark_text;
int lines_saved;			/* Nr of lines in buffer */

/*
 * PT() inserts the buffer at the current location.
 */
void PT()
{
  register int fd;		/* File descriptor for buffer */

  if ((fd = scratch_file(READ)) == ERRORS)
  	error("Buffer is empty.", NIL_PTR);
  else {
  	file_insert(fd, FALSE);/* Insert the buffer */
  	(void) close(fd);
  }
}

/*
 * IF() prompt for a filename and inserts the file at the current location 
 * in the file.
 */
void IF()
{
  register int fd;		/* File descriptor of file */
  char name[LINE_LEN];		/* Buffer for file name */

/* Get the file name */
  if (get_file("Get and insert file:", name) != FINE)
  	return;
  
  if ((fd = open(name, 0)) < 0)
  	error("Cannot open ", name);
  else {
  	file_insert(fd, TRUE);	/* Insert the file */
  	(void) close(fd);
  }
}

/*
 * File_insert() inserts a an opened file (as given by filedescriptor fd)
 * at the current location.
 */
void file_insert(fd, old_pos)
int fd;
FLAG old_pos;
{
  char line_buffer[MAX_CHARS];		/* Buffer for next line */
  register LINE *line = cur_line;
  register int line_count = nlines;	/* Nr of lines inserted */
  LINE *page = cur_line;
  int ret = ERRORS;
  
/* Get the first piece of text (might be ended with a '\n') from fd */
  if (get_line(fd, line_buffer) == ERRORS)
  	return;				/* Empty file */

/* Insert this text at the current location. */
  if (insert(line, cur_text, line_buffer) == ERRORS)
  	return;

/* Repeat getting lines (and inserting lines) until EOF is reached */
  while ((ret = get_line(fd, line_buffer)) != ERRORS && ret != NO_LINE)
  	line = line_insert(line, line_buffer, ret);
  
  if (ret == NO_LINE) {		/* Last line read not ended by a '\n' */
  	line = line->next;
  	(void) insert(line, line->text, line_buffer);
  }

/* Calculate nr of lines added */
  line_count = nlines - line_count;

/* Fix the screen */
  if (line_count == 0) {		/* Only one line changed */
  	set_cursor(0, y);
  	line_print(line);
  	move_to((old_pos == TRUE) ? x : x + length_of(line_buffer), y);
  }
  else {				/* Several lines changed */
  	reset(top_line, y);	/* Reset pointers */
  	while (page != line && page != bot_line->next)
  		page = page->next;
  	if (page != bot_line->next || old_pos == TRUE)
  		display(0, y, cur_line, screenmax - y);
  	if (old_pos == TRUE)
  		move_to(x, y);
  	else if (ret == NO_LINE)
		move_to(length_of(line_buffer), find_y(line));
	else 
		move_to(0, find_y(line->next));
  }

/* If nr of added line >= REPORT, print the count */
  if (line_count >= REPORT)
  	status_line(num_out((long) line_count), " lines added.");
}

/*
 * WB() writes the buffer (yank_file) into another file, which
 * is prompted for.
 */
void WB()
{
  register int new_fd;		/* Filedescriptor to copy file */
  int yank_fd;			/* Filedescriptor to buffer */
  register int cnt;		/* Count check for read/write */
  int ret = 0;			/* Error check for write */
  char file[LINE_LEN];		/* Output file */
  
/* Checkout the buffer */
  if ((yank_fd = scratch_file(READ)) == ERRORS) {
  	error("Buffer is empty.", NIL_PTR);
  	return;
  }

/* Get file name */
  if (get_file("Write buffer to file:", file) != FINE)
  	return;
  
/* Creat the new file */
  if ((new_fd = creat(file, 0644)) < 0) {
  	error("Cannot create ", file);
  	return;
  }

  status_line("Writing ", file);
  
/* Copy buffer into file */
  while ((cnt = read(yank_fd, text_buffer, sizeof(text_buffer))) > 0)
  	if (write(new_fd, text_buffer, cnt) != cnt) {
  		bad_write(new_fd);
  		ret = ERRORS;
  		break;
  	}

/* Clean up open files and status_line */
  (void) close(new_fd);
  (void) close(yank_fd);

  if (ret != ERRORS)			/* Bad write */
  	file_status("Wrote", chars_saved, file, lines_saved, TRUE, FALSE);
}

/*
 * MA sets mark_line (mark_text) to the current line (text pointer). 
 */
void MA()
{
  mark_line = cur_line;
  mark_text = cur_text;
  status_line("Mark set", NIL_PTR);
}

/*
 * YA() puts the text between the marked position and the current
 * in the buffer.
 */
void YA()
{
  set_up(NO_DELETE);
}

/*
 * DT() is essentially the same as YA(), but in DT() the text is deleted.
 */
void DT()
{
  set_up(DELETE);
}

/*
 * Set_up is an interface to the actual yank. It calls checkmark () to check
 * if the marked position is still valid. If it is, yank is called with the
 * arguments in the right order.
 */
void set_up(remove)
FLAG remove;				/* DELETE if text should be deleted */
{
  switch (checkmark()) {
  	case NOT_VALID :
  		error("Mark not set.", NIL_PTR);
  		return;
  	case SMALLER :
  		yank(mark_line, mark_text, cur_line, cur_text, remove);
  		break;
  	case BIGGER :
  		yank(cur_line, cur_text, mark_line, mark_text, remove);
  		break;
  	case SAME :		/* Ignore stupid behaviour */
  		yank_status = EMPTY;
  		chars_saved = 0L;
  		status_line("0 characters saved in buffer.", NIL_PTR);
  		break;
  }
}

/*
 * Check_mark() checks if mark_line and mark_text are still valid pointers. If
 * they are it returns SMALLER if the marked position is before the current,
 * BIGGER if it isn't or SAME if somebody didn't get the point.
 * NOT_VALID is returned when mark_line and/or mark_text are no longer valid.
 * Legal() checks if mark_text is valid on the mark_line.
 */
FLAG checkmark()
{
  register LINE *line;
  FLAG cur_seen = FALSE;

/* Special case: check is mark_line and cur_line are the same. */
  if (mark_line == cur_line) {
  	if (mark_text == cur_text)	/* Even same place */
  		return SAME;
  	if (legal() == ERRORS)		/* mark_text out of range */
  		return NOT_VALID;
  	return (mark_text < cur_text) ? SMALLER : BIGGER;
  }

/* Start looking for mark_line in the line structure */
  for (line = header->next; line != tail; line = line->next) {
  	if (line == cur_line)
  		cur_seen = TRUE;
  	else if (line == mark_line)
  		break;
  }

/* If we found mark_line (line != tail) check for legality of mark_text */
  if (line == tail || legal() == ERRORS)
  	return NOT_VALID;

/* cur_seen is TRUE if cur_line is before mark_line */
  return (cur_seen == TRUE) ? BIGGER : SMALLER;
}

/*
 * Legal() checks if mark_text is still a valid pointer.
 */
int legal()
{
  register char *textp = mark_line->text;

/* Locate mark_text on mark_line */
  while (textp != mark_text && *textp++ != '\0')
  	;
  return (*textp == '\0') ? ERRORS : FINE;
}

/*
 * Yank puts all the text between start_position and end_position into
 * the buffer.
 * The caller must check that the arguments to yank() are valid. (E.g. in
 * the right order)
 */
void yank(start_line, start_textp, end_line, end_textp, remove)
LINE *start_line, *end_line;
char *start_textp, *end_textp;
FLAG remove;				/* DELETE if text should be deleted */
{
  register LINE *line = start_line;
  register char *textp = start_textp;
  int fd;

/* Creat file to hold buffer */
  if ((fd = scratch_file(WRITE)) == ERRORS)
  	return;
  
  chars_saved = 0L;
  lines_saved = 0;
  status_line("Saving text.", NIL_PTR);

/* Keep writing chars until the end_location is reached. */
  while (textp != end_textp) {
  	if (write_char(fd, *textp) == ERRORS) {
  		(void) close(fd);
  		return;
  	}
  	if (*textp++ == '\n') {	/* Move to the next line */
  		line = line->next;
  		textp = line->text;
  		lines_saved++;
  	}
  	chars_saved++;
  }

/* Flush the I/O buffer and close file */
  if (flush_buffer(fd) == ERRORS) {
  	(void) close(fd);
  	return;
  }
  (void) close(fd);
  yank_status = VALID;

/*
 * Check if the text should be deleted as well. If it should, the following
 * hack is used to save a lot of code. First move back to the start_position.
 * (This might be the location we're on now!) and them delete the text.
 * It might be a bit confusing the first time somebody uses it.
 * Delete() will fix the screen.
 */
  if (remove == DELETE) {
  	move_to(find_x(start_line, start_textp), find_y(start_line));
  	delete(start_line, start_textp, end_line, end_textp);
  }

  status_line(num_out(chars_saved), " characters saved in buffer.");
}

/*
 * Scratch_file() creates a uniq file in /usr/tmp. If the file couldn't
 * be created other combinations of files are tried until a maximum
 * of MAXTRAILS times. After MAXTRAILS times, an error message is given
 * and ERRORS is returned.
 */

#define MAXTRAILS	26

int scratch_file(mode)
FLAG mode;				/* Can be READ or WRITE permission */
{
  static int trials = 0;		/* Keep track of trails */
  register char *y_ptr, *n_ptr;
  int fd;				/* Filedescriptor to buffer */

/* If yank_status == NOT_VALID, scratch_file is called for the first time */
  if (yank_status == NOT_VALID && mode == WRITE) { /* Create new file */
  	/* Generate file name. */
	y_ptr = &yank_file[11];
	n_ptr = num_out((long) getpid());
	while ((*y_ptr = *n_ptr++) != '\0')
		y_ptr++;
	*y_ptr++ = 'a' + trials;
	*y_ptr = '\0';
  	/* Check file existence */
  	if (access(yank_file, 0) == 0 || (fd = creat(yank_file, 0644)) < 0) {
  		if (trials++ >= MAXTRAILS) {
  			error("Unable to creat scratchfile.", NIL_PTR);
  			return ERRORS;
  		}
  		else
  			return scratch_file(mode);/* Have another go */
  	}
  }
  else if ((mode == READ && (fd = open(yank_file, 0)) < 0) ||
			(mode == WRITE && (fd = creat(yank_file, 0644)) < 0)) {
  	yank_status = NOT_VALID;
  	return ERRORS;
  }

  clear_buffer();
  return fd;
}

/*  ========================================================================  *
 *				Search Routines				      *	
 *  ========================================================================  */

/*
 * A regular expression consists of a sequence of:
 * 	1. A normal character matching that character.
 * 	2. A . matching any character.
 * 	3. A ^ matching the begin of a line.
 * 	4. A $ (as last character of the pattern) mathing the end of a line.
 * 	5. A \<character> matching <character>.
 * 	6. A number of characters enclosed in [] pairs matching any of these
 * 	   characters. A list of characters can be indicated by a '-'. So
 * 	   [a-z] matches any letter of the alphabet. If the first character
 * 	   after the '[' is a '^' then the set is negated (matching none of
 * 	   the characters). 
 * 	   A ']', '^' or '-' can be escaped by putting a '\' in front of it.
 * 	7. If one of the expressions as described in 1-6 is followed by a
 * 	   '*' than that expressions matches a sequence of 0 or more of
 * 	   that expression.
 */

char typed_expression[LINE_LEN];	/* Holds previous expr. */

/*
 * SF searches forward for an expression.
 */
void SF()
{
  search("Search forward:", FORWARD);
}

/*
 * SF searches backwards for an expression.
 */
void SR()
{
  search("Search reverse:", REVERSE);
}

/*
 * Get_expression() prompts for an expression. If just a return is typed, the
 * old expression is used. If the expression changed, compile() is called and
 * the returning REGEX structure is returned. It returns NIL_REG upon error.
 * The save flag indicates whether the expression should be appended at the
 * message pointer.
 */
REGEX *get_expression(message)
char *message;
{
  static REGEX program;			/* Program of expression */
  char exp_buf[LINE_LEN];			/* Buffer for new expr. */

  if (get_string(message, exp_buf, FALSE) == ERRORS)
  	return NIL_REG;
  
  if (exp_buf[0] == '\0' && typed_expression[0] == '\0') {
  	error("No previous expression.", NIL_PTR);
  	return NIL_REG;
  }

  if (exp_buf[0] != '\0') {		/* A new expr. is typed */
  	copy_string(typed_expression, exp_buf);/* Save expr. */
  	compile(exp_buf, &program);	/* Compile new expression */
  }

  if (program.status == REG_ERROR) {	/* Error during compiling */
  	error(program.result.err_mess, NIL_PTR);
  	return NIL_REG;
  }
  return &program;
}

/*
 * GR() a replaces all matches from the current position until the end
 * of the file.
 */
void GR()
{
  change("Global replace:", VALID);
}

/*
 * LR() replaces all matches on the current line.
 */
void LR()
{
  change("Line replace:", NOT_VALID);
}

/*
 * Change() prompts for an expression and a substitution pattern and changes
 * all matches of the expression into the substitution. change() start looking
 * for expressions at the current line and continues until the end of the file
 * if the FLAG file is VALID.
 */
void change(message, file)
char *message;				/* Message to prompt for expression */
FLAG file;
{
  char mess_buf[LINE_LEN];	/* Buffer to hold message */
  char replacement[LINE_LEN];	/* Buffer to hold subst. pattern */
  REGEX *program;			/* Program resulting from compilation */
  register LINE *line = cur_line;
  register char *textp;
  long lines = 0L;		/* Nr of lines on which subs occurred */
  long subs = 0L;			/* Nr of subs made */
  int page = y;			/* Index to check if line is on screen*/

/* Save message and get expression */
  copy_string(mess_buf, message);
  if ((program = get_expression(mess_buf)) == NIL_REG)
  	return;
  
/* Get substitution pattern */
  build_string(mess_buf, "%s %s by:", mess_buf, typed_expression);
  if (get_string(mess_buf, replacement, FALSE) == ERRORS)
  	return;
  
  set_cursor(0, ymax);
  flush();
/* Substitute until end of file */
  do {
  	if (line_check(program, line->text, FORWARD)) {
  		lines++;
  		/* Repeat sub. on this line as long as we find a match*/
  		do {
  			subs++;	/* Increment subs */
  			if ((textp = substitute(line, program,replacement))
								     == NIL_PTR)
  				return;	/* Line too long */
  		} while ((program->status & BEGIN_LINE) != BEGIN_LINE &&
			 (program->status & END_LINE) != END_LINE &&
					  line_check(program, textp, FORWARD));
  		/* Check to see if we can print the result */
  		if (page <= screenmax) {
  			set_cursor(0, page);
  			line_print(line);
  		}
  	}
  	if (page <= screenmax)
  		page++;
  	line = line->next;
  } while (line != tail && file == VALID && quit == FALSE);

  copy_string(mess_buf, (quit == TRUE) ? "(Aborted) " : "");
/* Fix the status line */
  if (subs == 0L && quit == FALSE)
  	error("Pattern not found.", NIL_PTR);
  else if (lines >= REPORT || quit == TRUE) {
  	build_string(mess_buf, "%s %D substitutions on %D lines.", mess_buf,
								   subs, lines);
  	status_line(mess_buf, NIL_PTR);
  }
  else if (file == NOT_VALID && subs >= REPORT)
  	status_line(num_out(subs), " substitutions.");
  else
  	clear_status();
  move_to (x, y);
}

/*
 * Substitute() replaces the match on this line by the substitute pattern
 * as indicated by the program. Every '&' in the replacement is replaced by 
 * the original match. A \ in the replacement escapes the next character.
 */
char *substitute(line, program, replacement)
LINE *line;
REGEX *program;
char *replacement;		/* Contains replacement pattern */
{
  register char *textp = text_buffer;
  register char *subp = replacement;
  char *linep = line->text;
  char *amp;

  modified = TRUE;

/* Copy part of line until the beginning of the match */
  while (linep != program->start_ptr)
  	*textp++ = *linep++;
  
/*
 * Replace the match by the substitution pattern. Each occurrence of '&' is
 * replaced by the original match. A \ escapes the next character.
 */
  while (*subp != '\0' && textp < &text_buffer[MAX_CHARS]) {
  	if (*subp == '&') {		/* Replace the original match */
  		amp = program->start_ptr;
  		while (amp < program->end_ptr && textp<&text_buffer[MAX_CHARS])
  			*textp++ = *amp++;
  		subp++;
  	}
  	else {
  		if (*subp == '\\' && *(subp + 1) != '\0')
  			subp++;
  		*textp++ = *subp++;
  	}
  }

/* Check for line length not exceeding MAX_CHARS */
  if (length_of(text_buffer) + length_of(program->end_ptr) >= MAX_CHARS) {
  	error("Substitution result: line too big", NIL_PTR);
  	return NIL_PTR;
  }

/* Append last part of line to the new build line */
  copy_string(textp, program->end_ptr);

/* Free old line and install new one */
  free_space(line->text);
  line->text = alloc(length_of(text_buffer) + 1);
  copy_string(line->text, text_buffer);

  return(line->text + (textp - text_buffer));
}

/*
 * Search() calls get_expression to fetch the expression. If this went well,
 * the function match() is called which returns the line with the next match.
 * If this line is the NIL_LINE, it means that a match could not be found.
 * Find_x() and find_y() display the right page on the screen, and return
 * the right coordinates for x and y. These coordinates are passed to move_to()
 */
void search(message, method)
char *message;
FLAG method;
{
  register REGEX *program;
  register LINE *match_line;

/* Get the expression */
  if ((program = get_expression(message)) == NIL_REG)
  	return;

  set_cursor(0, ymax);
  flush();
/* Find the match */
  if ((match_line = match(program, cur_text, method)) == NIL_LINE) {
  	if (quit == TRUE)
  		status_line("Aborted", NIL_PTR);
  	else
  		status_line("Pattern not found.", NIL_PTR);
  	return;
  }

  move(0, program->start_ptr, find_y(match_line));
  clear_status();
}

/*
 * find_y() checks if the matched line is on the current page.  If it is, it
 * returns the new y coordinate, else it displays the correct page with the
 * matched line in the middle and returns the new y value;
 */
int find_y(match_line)
LINE *match_line;
{
  register LINE *line;
  register int count = 0;

/* Check if match_line is on the same page as currently displayed. */
  for (line = top_line; line != match_line && line != bot_line->next;
  						      line = line->next)
  	count++;
  if (line != bot_line->next)
  	return count;

/* Display new page, with match_line in center. */
  if ((line = proceed(match_line, -(screenmax >> 1))) == header) {
  /* Can't display in the middle. Make first line of file top_line */
  	count = 0;
  	for (line = header->next; line != match_line; line = line->next)
  		count++;
  	line = header->next;
  }
  else	/* New page is displayed. Set cursor to middle of page */
  	count = screenmax >> 1;

/* Reset pointers and redraw the screen */
  reset(line, 0);
  RD();

  return count;
}

/* Opcodes for characters */
#define	NORMAL		0x0200
#define DOT		0x0400
#define EOLN		0x0800
#define STAR		0x1000
#define BRACKET		0x2000
#define NEGATE		0x0100
#define DONE		0x4000

/* Mask for opcodes and characters */
#define LOW_BYTE	0x00FF
#define HIGH_BYTE	0xFF00

/* Previous is the contents of the previous address (ptr) points to */
#define previous(ptr)		(*((ptr) - 1))

/* Buffer to store outcome of compilation */
int exp_buffer[BLOCK_SIZE];

/* Errors often used */
char *too_long = "Regular expression too long";

/*
 * Reg_error() is called by compile() is something went wrong. It set the
 * status of the structure to error, and assigns the error field of the union.
 */
#define reg_error(str)	program->status = REG_ERROR, \
  					program->result.err_mess = (str)
/*
 * Finished() is called when everything went right during compilation. It
 * allocates space for the expression, and copies the expression buffer into
 * this field.
 */
void finished(program, last_exp)
register REGEX *program;
int *last_exp;
{
  register int length = (last_exp - exp_buffer) * sizeof(int);

/* Allocate space */
  program->result.expression = (int *) alloc(length);
/* Copy expression. (expression consists of ints!) */
  bcopy(exp_buffer, program->result.expression, length);
}

/*
 * Compile compiles the pattern into a more comprehensible form and returns a 
 * REGEX structure. If something went wrong, the status field of the structure
 * is set to REG_ERROR and an error message is set into the err_mess field of
 * the union. If all went well the expression is saved and the expression
 * pointer is set to the saved (and compiled) expression.
 */
void compile(pattern, program)
register char *pattern;			/* Pointer to pattern */
REGEX *program;
{
  register int *expression = exp_buffer;
  int *prev_char;			/* Pointer to previous compiled atom */
  int *acct_field;		/* Pointer to last BRACKET start */
  FLAG negate;			/* Negate flag for BRACKET */
  char low_char;			/* Index for chars in BRACKET */
  char c;

/* Check for begin of line */
  if (*pattern == '^') {
  	program->status = BEGIN_LINE;
  	pattern++;
  }
  else {
  	program->status = 0;
/* If the first character is a '*' we have to assign it here. */
  	if (*pattern == '*') {
  		*expression++ = '*' + NORMAL;
  		pattern++;
  	}
  }

  for (; ;) {
  	switch (c = *pattern++) {
  	case '.' :
  		*expression++ = DOT;
  		break;
  	case '$' :
  		/*
  		 * Only means EOLN if it is the last char of the pattern
  		 */
  		if (*pattern == '\0') {
  			*expression++ = EOLN | DONE;
  			program->status |= END_LINE;
  			finished(program, expression);
  			return;
  		}
  		else
  			*expression++ = NORMAL + '$';
  		break;
  	case '\0' :
  		*expression++ = DONE;
  		finished(program, expression);
  		return;
  	case '\\' :
  		/* If last char, it must! mean a normal '\' */
  		if (*pattern == '\0')
  			*expression++ = NORMAL + '\\';
  		else
  			*expression++ = NORMAL + *pattern++;
  		break;
  	case '*' :
  		/*
  		 * If the previous expression was a [] find out the
  		 * begin of the list, and adjust the opcode.
  		 */
  		prev_char = expression - 1;
  		if (*prev_char & BRACKET)
  			*(expression - (*acct_field & LOW_BYTE))|= STAR;
  		else
  			*prev_char |= STAR;
  		break;
  	case '[' :
  		/*
  		 * First field in expression gives information about
  		 * the list.
  		 * The opcode consists of BRACKET and if necessary
  		 * NEGATE to indicate that the list should be negated
  		 * and/or STAR to indicate a number of sequence of this 
  		 * list.
  		 * The lower byte contains the length of the list.
  		 */
  		acct_field = expression++;
  		if (*pattern == '^') {	/* List must be negated */
  			pattern++;
  			negate = TRUE;
  		}
  		else
  			negate = FALSE;
  		while (*pattern != ']') {
  			if (*pattern == '\0') {
  				reg_error("Missing ]");
  				return;
  			}
  			if (*pattern == '\\')
  				pattern++;
  			*expression++ = *pattern++;
  			if (*pattern == '-') {
  						/* Make list of chars */
  				low_char = previous(pattern);
  				pattern++;	/* Skip '-' */
  				if (low_char++ > *pattern) {
  					reg_error("Bad range in [a-z]");
  					return;
  				}
  				/* Build list */
  				while (low_char <= *pattern)
  					*expression++ = low_char++;
  				pattern++;
  			}
  			if (expression >= &exp_buffer[BLOCK_SIZE]) {
  				reg_error(too_long);
  				return;
  			}
  		}
  		pattern++;			/* Skip ']' */
  		/* Assign length of list in acct field */
  		if ((*acct_field = (expression - acct_field)) == 1) {
  			reg_error("Empty []");
  			return;
  		}
  		/* Assign negate and bracket field */
  		*acct_field |= BRACKET;
  		if (negate == TRUE)
  			*acct_field |= NEGATE;
  		/*
  		 * Add BRACKET to opcode of last char in field because
  		 * a '*' may be following the list.
  		 */
  		previous(expression) |= BRACKET;
  		break;
  	default :
  		*expression++ = c + NORMAL;
  	}
  	if (expression == &exp_buffer[BLOCK_SIZE]) {
  		reg_error(too_long);
  		return;
  	}
  }
  /* NOTREACHED */
}

/*
 * Match gets as argument the program, pointer to place in current line to 
 * start from and the method to search for (either FORWARD or REVERSE).
 * Match() will look through the whole file until a match is found.
 * NIL_LINE is returned if no match could be found.
 */
LINE *match(program, string, method)
REGEX *program;
char *string;
register FLAG method;
{
  register LINE *line = cur_line;
  char old_char;				/* For saving chars */

/* Corrupted program */
  if (program->status == REG_ERROR)
  	return NIL_LINE;

/* Check part of text first */
  if (!(program->status & BEGIN_LINE)) {
  	if (method == FORWARD) {
  		if (line_check(program, string + 1, method) == MATCH)
  			return cur_line;	/* Match found */
  	}
  	else if (!(program->status & END_LINE)) {
  		old_char = *string;	/* Save char and */
  		*string = '\n';		/* Assign '\n' for line_check */
  		if (line_check(program, line->text, method) == MATCH) {
  			*string = old_char; /* Restore char */
  			return cur_line;    /* Found match */
  		}
  		*string = old_char;	/* No match, but restore char */
  	}
  }

/* No match in last (or first) part of line. Check out rest of file */
  do {
  	line = (method == FORWARD) ? line->next : line->prev;
  	if (line->text == NIL_PTR)	/* Header/tail */
  		continue;
  	if (line_check(program, line->text, method) == MATCH)
  		return line;
  } while (line != cur_line && quit == FALSE);

/* No match found. */
  return NIL_LINE;
}

/*
 * Line_check() checks the line (or rather string) for a match. Method
 * indicates FORWARD or REVERSE search. It scans through the whole string
 * until a match is found, or the end of the string is reached.
 */
int line_check(program, string, method)
register REGEX *program;
char *string;
FLAG method;
{
  register char *textp = string;

/* Assign start_ptr field. We might find a match right away! */
  program->start_ptr = textp;

/* If the match must be anchored, just check the string. */
  if (program->status & BEGIN_LINE)
  	return check_string(program, string, NIL_INT);
  
  if (method == REVERSE) {
  	/* First move to the end of the string */
  	for (textp = string; *textp != '\n'; textp++)
  		;
  	/* Start checking string until the begin of the string is met */
  	while (textp >= string) {
  		program->start_ptr = textp;
  		if (check_string(program, textp--, NIL_INT))
  			return MATCH;
  	}
  }
  else {
  	/* Move through the string until the end of is found */
	while (quit == FALSE && *textp != '\0') {
  		program->start_ptr = textp;
  		if (check_string(program, textp, NIL_INT))
  			return MATCH;
		if (*textp == '\n')
			break;
		textp++;
  	}
  }

  return NO_MATCH;
}

/*
 * Check() checks of a match can be found in the given string. Whenever a STAR
 * is found during matching, then the begin position of the string is marked
 * and the maximum number of matches is performed. Then the function star()
 * is called which starts to finish the match from this position of the string
 * (and expression). Check() return MATCH for a match, NO_MATCH is the string 
 * couldn't be matched or REG_ERROR for an illegal opcode in expression.
 */
int check_string(program, string, expression)
REGEX *program;
register char *string;
int *expression;
{
  register int opcode;		/* Holds opcode of next expr. atom */
  char c;				/* Char that must be matched */
  char *mark;			/* For marking position */
  int star_fl;			/* A star has been born */

  if (expression == NIL_INT)
  	expression = program->result.expression;

/* Loop until end of string or end of expression */
  while (quit == FALSE && !(*expression & DONE) &&
					   *string != '\0' && *string != '\n') {
  	c = *expression & LOW_BYTE;	  /* Extract match char */
  	opcode = *expression & HIGH_BYTE; /* Extract opcode */
  	if (star_fl = (opcode & STAR)) {  /* Check star occurrence */
  		opcode &= ~STAR;	  /* Strip opcode */
  		mark = string;		  /* Mark current position */
  	}
  	expression++;		/* Increment expr. */
  	switch (opcode) {
  	case NORMAL :
  		if (star_fl)
  			while (*string++ == c)	/* Skip all matches */
  				;
  		else if (*string++ != c)
  			return NO_MATCH;
  		break;
  	case DOT :
  		string++;
  		if (star_fl)			/* Skip to eoln */
  			while (*string != '\0' && *string++ != '\n')
  				;
  		break;
  	case NEGATE | BRACKET:
  	case BRACKET :
  		if (star_fl)
  			while (in_list(expression, *string++, c, opcode)
								       == MATCH)
  				;
  		else if (in_list(expression, *string++, c, opcode) == NO_MATCH)
  			return NO_MATCH;
  		expression += c - 1;	/* Add length of list */
  		break;
  	default :
  		panic("Corrupted program in check_string()");
  	}
  	if (star_fl) 
  		return star(program, mark, string, expression);
  }
  if (*expression & DONE) {
  	program->end_ptr = string;	/* Match ends here */
  	/*
  	 * We might have found a match. The last thing to do is check
  	 * whether a '$' was given at the end of the expression, or
  	 * the match was found on a null string. (E.g. [a-z]* always
  	 * matches) unless a ^ or $ was included in the pattern.
  	 */
  	if ((*expression & EOLN) && *string != '\n' && *string != '\0')
  		return NO_MATCH;
	if (string == program->start_ptr && !(program->status & BEGIN_LINE)
					 && !(*expression & EOLN))
  		return NO_MATCH;
  	return MATCH;
  }
  return NO_MATCH;
}

/*
 * Star() calls check_string() to find out the longest match possible.
 * It searches backwards until the (in check_string()) marked position
 * is reached, or a match is found.
 */
int star(program, end_position, string, expression)
REGEX *program;
register char *end_position;
register char *string;
int *expression;
{
  do {
  	string--;
  	if (check_string(program, string, expression))
  		return MATCH;
  } while (string != end_position);

  return NO_MATCH;
}

/*
 * In_list() checks if the given character is in the list of []. If it is
 * it returns MATCH. if it isn't it returns NO_MATCH. These returns values
 * are reversed when the NEGATE field in the opcode is present.
 */
int in_list(list, c, list_length, opcode)
register int *list;
char c;
register int list_length;
int opcode;
{
  if (c == '\0' || c == '\n')	/* End of string, never matches */
  	return NO_MATCH;
  while (list_length-- > 1) {	/* > 1, don't check acct_field */
  	if ((*list & LOW_BYTE) == c)
  		return (opcode & NEGATE) ? NO_MATCH : MATCH;
  	list++;
  }
  return (opcode & NEGATE) ? MATCH : NO_MATCH;
}

/*
 * Dummy_line() adds an empty line at the end of the file. This is sometimes
 * useful in combination with the EF and DN command in combination with the
 * Yank command set.
 */
void dummy_line()
{
	(void) line_insert(tail->prev, "\n", 1);
	tail->prev->shift_count = DUMMY;
	if (last_y != screenmax) {
		last_y++;
		bot_line = bot_line->next;
	}
}