text: #include <linux/slab.h> /* for kmalloc */
  #include <linux/consolemap.h>
  #include <linux/interrupt.h>
  #include <linux/sched.h>
  #include <linux/selection.h>
  
  #include "speakup.h"
  
  /* ------ cut and paste ----- */
  /* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */
  #define ishardspace(c)      ((c) == ' ')
  
  unsigned short xs, ys, xe, ye; /* our region points */
  
  /* Variables for selection control. */
  /* must not be disallocated */
  struct vc_data *spk_sel_cons;
  /* cleared by clear_selection */
  static int sel_start = -1;
  static int sel_end;
  static int sel_buffer_lth;
  static char *sel_buffer;
  
  static unsigned char sel_pos(int n)
  {
  	return inverse_translate(spk_sel_cons,
  		screen_glyph(spk_sel_cons, n), 0);
  }
  
  void speakup_clear_selection(void)
  {
  	sel_start = -1;
  }
  
  /* does screen address p correspond to character at LH/RH edge of screen? */
  static int atedge(const int p, int size_row)
  {
  	return !(p % size_row) || !((p + 2) % size_row);
  }
  
  /* constrain v such that v <= u */
  static unsigned short limit(const unsigned short v, const unsigned short u)
  {
  	return (v > u) ? u : v;
  }
  
  int speakup_set_selection(struct tty_struct *tty)
  {
  	int new_sel_start, new_sel_end;
  	char *bp, *obp;
  	int i, ps, pe;
  	struct vc_data *vc = vc_cons[fg_console].d;
  
  	xs = limit(xs, vc->vc_cols - 1);
  	ys = limit(ys, vc->vc_rows - 1);
  	xe = limit(xe, vc->vc_cols - 1);
  	ye = limit(ye, vc->vc_rows - 1);
  	ps = ys * vc->vc_size_row + (xs << 1);
  	pe = ye * vc->vc_size_row + (xe << 1);
  
  	if (ps > pe) {
  		/* make sel_start <= sel_end */
  		int tmp = ps;
  		ps = pe;
  		pe = tmp;
  	}
  
  	if (spk_sel_cons != vc_cons[fg_console].d) {
  		speakup_clear_selection();
  		spk_sel_cons = vc_cons[fg_console].d;
  		dev_warn(tty->dev,
  			"Selection: mark console not the same as cut\n");
  		return -EINVAL;
  	}
  
  	new_sel_start = ps;
  	new_sel_end = pe;
  
  	/* select to end of line if on trailing space */
  	if (new_sel_end > new_sel_start &&
  	    !atedge(new_sel_end, vc->vc_size_row) &&
  	    ishardspace(sel_pos(new_sel_end))) {
  		for (pe = new_sel_end + 2; ; pe += 2)
  			if (!ishardspace(sel_pos(pe)) ||
  			    atedge(pe, vc->vc_size_row))
  				break;
  		if (ishardspace(sel_pos(pe)))
  			new_sel_end = pe;
  	}
  	if ((new_sel_start == sel_start) && (new_sel_end == sel_end))
  		return 0; /* no action required */
  
  	sel_start = new_sel_start;
  	sel_end = new_sel_end;
  	/* Allocate a new buffer before freeing the old one ... */
  	bp = kmalloc((sel_end-sel_start)/2+1, GFP_ATOMIC);
  	if (!bp) {
  		dev_warn(tty->dev, "selection: kmalloc() failed\n");
  		speakup_clear_selection();
  		return -ENOMEM;
  	}
  	kfree(sel_buffer);
  	sel_buffer = bp;
  
  	obp = bp;
  	for (i = sel_start; i <= sel_end; i += 2) {
  		*bp = sel_pos(i);
  		if (!ishardspace(*bp++))
  			obp = bp;
  		if (!((i + 2) % vc->vc_size_row)) {
  			/* strip trailing blanks from line and add newline,
  			   unless non-space at end of line. */
  			if (obp != bp) {
  				bp = obp;
  				*bp++ = '\r';
  			}
  			obp = bp;
  		}
  	}
  	sel_buffer_lth = bp - sel_buffer;
  	return 0;
  }
  
  /* TODO: move to some helper thread, probably.  That'd fix having to check for
   * in_atomic().  */
  int speakup_paste_selection(struct tty_struct *tty)
  {
  	struct vc_data *vc = (struct vc_data *) tty->driver_data;
  	int pasted = 0, count;
  	DECLARE_WAITQUEUE(wait, current);
  	add_wait_queue(&vc->paste_wait, &wait);
  	while (sel_buffer && sel_buffer_lth > pasted) {
  		set_current_state(TASK_INTERRUPTIBLE);
  		if (test_bit(TTY_THROTTLED, &tty->flags)) {
  			if (in_atomic())
  				/* if we are in an interrupt handler, abort */
  				break;
  			schedule();
  			continue;
  		}
  		count = sel_buffer_lth - pasted;
  		count = min_t(int, count, tty->receive_room);
  		tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
  			NULL, count);
  		pasted += count;
  	}
  	remove_wait_queue(&vc->paste_wait, &wait);
  	current->state = TASK_RUNNING;
  	return 0;
  }
  
  