dm kcopyd: avoid pointless job splitting
[linux/fpc-iii.git] / drivers / tty / vt / selection.c
blob67b1d0d7c8acb924fdc481cfc75b36fa6c925de8
1 /*
2 * This module exports the functions:
4 * 'int set_selection(struct tiocl_selection __user *, struct tty_struct *)'
5 * 'void clear_selection(void)'
6 * 'int paste_selection(struct tty_struct *)'
7 * 'int sel_loadlut(char __user *)'
9 * Now that /dev/vcs exists, most of this can disappear again.
12 #include <linux/module.h>
13 #include <linux/tty.h>
14 #include <linux/sched.h>
15 #include <linux/mm.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
19 #include <asm/uaccess.h>
21 #include <linux/kbd_kern.h>
22 #include <linux/vt_kern.h>
23 #include <linux/consolemap.h>
24 #include <linux/selection.h>
25 #include <linux/tiocl.h>
26 #include <linux/console.h>
28 /* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */
29 #define isspace(c) ((c) == ' ')
31 extern void poke_blanked_console(void);
33 /* Variables for selection control. */
34 /* Use a dynamic buffer, instead of static (Dec 1994) */
35 struct vc_data *sel_cons; /* must not be deallocated */
36 static int use_unicode;
37 static volatile int sel_start = -1; /* cleared by clear_selection */
38 static int sel_end;
39 static int sel_buffer_lth;
40 static char *sel_buffer;
42 /* clear_selection, highlight and highlight_pointer can be called
43 from interrupt (via scrollback/front) */
45 /* set reverse video on characters s-e of console with selection. */
46 static inline void highlight(const int s, const int e)
48 invert_screen(sel_cons, s, e-s+2, 1);
51 /* use complementary color to show the pointer */
52 static inline void highlight_pointer(const int where)
54 complement_pos(sel_cons, where);
57 static u16
58 sel_pos(int n)
60 return inverse_translate(sel_cons, screen_glyph(sel_cons, n),
61 use_unicode);
64 /* remove the current selection highlight, if any,
65 from the console holding the selection. */
66 void
67 clear_selection(void) {
68 highlight_pointer(-1); /* hide the pointer */
69 if (sel_start != -1) {
70 highlight(sel_start, sel_end);
71 sel_start = -1;
76 * User settable table: what characters are to be considered alphabetic?
77 * 256 bits
79 static u32 inwordLut[8]={
80 0x00000000, /* control chars */
81 0x03FF0000, /* digits */
82 0x87FFFFFE, /* uppercase and '_' */
83 0x07FFFFFE, /* lowercase */
84 0x00000000,
85 0x00000000,
86 0xFF7FFFFF, /* latin-1 accented letters, not multiplication sign */
87 0xFF7FFFFF /* latin-1 accented letters, not division sign */
90 static inline int inword(const u16 c) {
91 return c > 0xff || (( inwordLut[c>>5] >> (c & 0x1F) ) & 1);
94 /* set inwordLut contents. Invoked by ioctl(). */
95 int sel_loadlut(char __user *p)
97 return copy_from_user(inwordLut, (u32 __user *)(p+4), 32) ? -EFAULT : 0;
100 /* does screen address p correspond to character at LH/RH edge of screen? */
101 static inline int atedge(const int p, int size_row)
103 return (!(p % size_row) || !((p + 2) % size_row));
106 /* constrain v such that v <= u */
107 static inline unsigned short limit(const unsigned short v, const unsigned short u)
109 return (v > u) ? u : v;
112 /* stores the char in UTF8 and returns the number of bytes used (1-3) */
113 static int store_utf8(u16 c, char *p)
115 if (c < 0x80) {
116 /* 0******* */
117 p[0] = c;
118 return 1;
119 } else if (c < 0x800) {
120 /* 110***** 10****** */
121 p[0] = 0xc0 | (c >> 6);
122 p[1] = 0x80 | (c & 0x3f);
123 return 2;
124 } else {
125 /* 1110**** 10****** 10****** */
126 p[0] = 0xe0 | (c >> 12);
127 p[1] = 0x80 | ((c >> 6) & 0x3f);
128 p[2] = 0x80 | (c & 0x3f);
129 return 3;
133 /* set the current selection. Invoked by ioctl() or by kernel code. */
134 int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *tty)
136 struct vc_data *vc = vc_cons[fg_console].d;
137 int sel_mode, new_sel_start, new_sel_end, spc;
138 char *bp, *obp;
139 int i, ps, pe, multiplier;
140 u16 c;
141 struct kbd_struct *kbd = kbd_table + fg_console;
143 poke_blanked_console();
145 { unsigned short xs, ys, xe, ye;
147 if (!access_ok(VERIFY_READ, sel, sizeof(*sel)))
148 return -EFAULT;
149 __get_user(xs, &sel->xs);
150 __get_user(ys, &sel->ys);
151 __get_user(xe, &sel->xe);
152 __get_user(ye, &sel->ye);
153 __get_user(sel_mode, &sel->sel_mode);
154 xs--; ys--; xe--; ye--;
155 xs = limit(xs, vc->vc_cols - 1);
156 ys = limit(ys, vc->vc_rows - 1);
157 xe = limit(xe, vc->vc_cols - 1);
158 ye = limit(ye, vc->vc_rows - 1);
159 ps = ys * vc->vc_size_row + (xs << 1);
160 pe = ye * vc->vc_size_row + (xe << 1);
162 if (sel_mode == TIOCL_SELCLEAR) {
163 /* useful for screendump without selection highlights */
164 clear_selection();
165 return 0;
168 if (mouse_reporting() && (sel_mode & TIOCL_SELMOUSEREPORT)) {
169 mouse_report(tty, sel_mode & TIOCL_SELBUTTONMASK, xs, ys);
170 return 0;
174 if (ps > pe) /* make sel_start <= sel_end */
176 int tmp = ps;
177 ps = pe;
178 pe = tmp;
181 if (sel_cons != vc_cons[fg_console].d) {
182 clear_selection();
183 sel_cons = vc_cons[fg_console].d;
185 use_unicode = kbd && kbd->kbdmode == VC_UNICODE;
187 switch (sel_mode)
189 case TIOCL_SELCHAR: /* character-by-character selection */
190 new_sel_start = ps;
191 new_sel_end = pe;
192 break;
193 case TIOCL_SELWORD: /* word-by-word selection */
194 spc = isspace(sel_pos(ps));
195 for (new_sel_start = ps; ; ps -= 2)
197 if ((spc && !isspace(sel_pos(ps))) ||
198 (!spc && !inword(sel_pos(ps))))
199 break;
200 new_sel_start = ps;
201 if (!(ps % vc->vc_size_row))
202 break;
204 spc = isspace(sel_pos(pe));
205 for (new_sel_end = pe; ; pe += 2)
207 if ((spc && !isspace(sel_pos(pe))) ||
208 (!spc && !inword(sel_pos(pe))))
209 break;
210 new_sel_end = pe;
211 if (!((pe + 2) % vc->vc_size_row))
212 break;
214 break;
215 case TIOCL_SELLINE: /* line-by-line selection */
216 new_sel_start = ps - ps % vc->vc_size_row;
217 new_sel_end = pe + vc->vc_size_row
218 - pe % vc->vc_size_row - 2;
219 break;
220 case TIOCL_SELPOINTER:
221 highlight_pointer(pe);
222 return 0;
223 default:
224 return -EINVAL;
227 /* remove the pointer */
228 highlight_pointer(-1);
230 /* select to end of line if on trailing space */
231 if (new_sel_end > new_sel_start &&
232 !atedge(new_sel_end, vc->vc_size_row) &&
233 isspace(sel_pos(new_sel_end))) {
234 for (pe = new_sel_end + 2; ; pe += 2)
235 if (!isspace(sel_pos(pe)) ||
236 atedge(pe, vc->vc_size_row))
237 break;
238 if (isspace(sel_pos(pe)))
239 new_sel_end = pe;
241 if (sel_start == -1) /* no current selection */
242 highlight(new_sel_start, new_sel_end);
243 else if (new_sel_start == sel_start)
245 if (new_sel_end == sel_end) /* no action required */
246 return 0;
247 else if (new_sel_end > sel_end) /* extend to right */
248 highlight(sel_end + 2, new_sel_end);
249 else /* contract from right */
250 highlight(new_sel_end + 2, sel_end);
252 else if (new_sel_end == sel_end)
254 if (new_sel_start < sel_start) /* extend to left */
255 highlight(new_sel_start, sel_start - 2);
256 else /* contract from left */
257 highlight(sel_start, new_sel_start - 2);
259 else /* some other case; start selection from scratch */
261 clear_selection();
262 highlight(new_sel_start, new_sel_end);
264 sel_start = new_sel_start;
265 sel_end = new_sel_end;
267 /* Allocate a new buffer before freeing the old one ... */
268 multiplier = use_unicode ? 3 : 1; /* chars can take up to 3 bytes */
269 bp = kmalloc(((sel_end-sel_start)/2+1)*multiplier, GFP_KERNEL);
270 if (!bp) {
271 printk(KERN_WARNING "selection: kmalloc() failed\n");
272 clear_selection();
273 return -ENOMEM;
275 kfree(sel_buffer);
276 sel_buffer = bp;
278 obp = bp;
279 for (i = sel_start; i <= sel_end; i += 2) {
280 c = sel_pos(i);
281 if (use_unicode)
282 bp += store_utf8(c, bp);
283 else
284 *bp++ = c;
285 if (!isspace(c))
286 obp = bp;
287 if (! ((i + 2) % vc->vc_size_row)) {
288 /* strip trailing blanks from line and add newline,
289 unless non-space at end of line. */
290 if (obp != bp) {
291 bp = obp;
292 *bp++ = '\r';
294 obp = bp;
297 sel_buffer_lth = bp - sel_buffer;
298 return 0;
301 /* Insert the contents of the selection buffer into the
302 * queue of the tty associated with the current console.
303 * Invoked by ioctl().
305 int paste_selection(struct tty_struct *tty)
307 struct vc_data *vc = tty->driver_data;
308 int pasted = 0;
309 unsigned int count;
310 struct tty_ldisc *ld;
311 DECLARE_WAITQUEUE(wait, current);
313 /* always called with BTM from vt_ioctl */
314 WARN_ON(!tty_locked());
316 console_lock();
317 poke_blanked_console();
318 console_unlock();
320 ld = tty_ldisc_ref(tty);
321 if (!ld) {
322 tty_unlock();
323 ld = tty_ldisc_ref_wait(tty);
324 tty_lock();
327 add_wait_queue(&vc->paste_wait, &wait);
328 while (sel_buffer && sel_buffer_lth > pasted) {
329 set_current_state(TASK_INTERRUPTIBLE);
330 if (test_bit(TTY_THROTTLED, &tty->flags)) {
331 schedule();
332 continue;
334 count = sel_buffer_lth - pasted;
335 count = tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
336 NULL, count);
337 pasted += count;
339 remove_wait_queue(&vc->paste_wait, &wait);
340 __set_current_state(TASK_RUNNING);
342 tty_ldisc_deref(ld);
343 return 0;