?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / rom / filesys / console_handler / support.c
blobeb969c100aab19795f23df4eb2a2fb76ca88ad2d
1 /*
2 Copyright © 1995-2015, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Support functions for console handler.
6 Lang: english
7 */
8
9 /****************************************************************************************/
10
11 #define CYCLIC_HISTORY_WALK 0
12
13 /****************************************************************************************/
14
15 #include <proto/exec.h>
16 #include <exec/libraries.h>
17 #include <exec/resident.h>
18 #include <exec/memory.h>
19 #include <exec/io.h>
20 #include <exec/errors.h>
21 #include <exec/alerts.h>
22 #include <utility/tagitem.h>
23 #include <dos/exall.h>
24 #include <dos/dosasl.h>
25 #include <intuition/intuition.h>
26 #include <intuition/sghooks.h>
27 #include <proto/dos.h>
28 #include <proto/intuition.h>
29 #include <proto/input.h>
30 #include <devices/conunit.h>
31
32 #define SDEBUG 0
33 #define DEBUG 0
34 #include <aros/debug.h>
35
36 #include <string.h>
37 #include <stdio.h>
38 #include <ctype.h>
39
40 #include "con_handler_intern.h"
41 #include "support.h"
42 #include "completion.h"
43
44 #define ioReq(x) ((struct IORequest *)x)
45
46 void replypkt(struct DosPacket *dp, SIPTR res1)
47 {
48 struct MsgPort *mp;
49 struct Message *mn;
50
51 mp = dp->dp_Port;
52 mn = dp->dp_Link;
53 mn->mn_Node.ln_Name = (char*) dp;
54 dp->dp_Port = &((struct Process*) FindTask(NULL))->pr_MsgPort;
55 dp->dp_Res1 = res1;
56 PutMsg(mp, mn);
57 }
58 void replypkt2(struct DosPacket *dp, SIPTR res1, SIPTR res2)
59 {
60 dp->dp_Res2 = res2;
61 replypkt(dp, res1);
62 }
63
64
65 /******************************************************************************************/
66
67 static const UBYTE up_seq[] = { 'A' };
68 static const UBYTE down_seq[] = { 'B' };
69 static const UBYTE right_seq[] = { 'C' };
70 static const UBYTE left_seq[] = { 'D' };
71 static const UBYTE shift_up_seq[] = { 'T' };
72 static const UBYTE shift_down_seq[] = { 'S' };
73 static const UBYTE shift_right_seq[] = { ' ', '@' };
74 static const UBYTE shift_left_seq[] = { ' ', 'A' };
75 static const UBYTE shift_tab_seq[] = { 'Z' };
76 static const UBYTE help_seq[] = { '?', '~' };
77 static const UBYTE f1_seq[] = { '0', '~' };
78 static const UBYTE f2_seq[] = { '1', '~' };
79 static const UBYTE f3_seq[] = { '2', '~' };
80 static const UBYTE f4_seq[] = { '3', '~' };
81 static const UBYTE f5_seq[] = { '4', '~' };
82 static const UBYTE f6_seq[] = { '5', '~' };
83 static const UBYTE f7_seq[] = { '6', '~' };
84 static const UBYTE f8_seq[] = { '7', '~' };
85 static const UBYTE f9_seq[] = { '8', '~' };
86 static const UBYTE f10_seq[] = { '9', '~' };
87 static const UBYTE paste_seq[] = { '0', ' ', 'v' };
88 static const UBYTE f11_seq[] = { '2', '0', '~' };
89 static const UBYTE f12_seq[] = { '2', '1', '~' };
90 static const UBYTE shift_f1_seq[] = { '1', '0', '~' };
91 static const UBYTE shift_f2_seq[] = { '1', '1', '~' };
92 static const UBYTE shift_f3_seq[] = { '1', '2', '~' };
93 static const UBYTE shift_f4_seq[] = { '1', '3', '~' };
94 static const UBYTE shift_f5_seq[] = { '1', '4', '~' };
95 static const UBYTE shift_f6_seq[] = { '1', '5', '~' };
96 static const UBYTE shift_f7_seq[] = { '1', '6', '~' };
97 static const UBYTE shift_f8_seq[] = { '1', '7', '~' };
98 static const UBYTE shift_f9_seq[] = { '1', '8', '~' };
99 static const UBYTE shift_f10_seq[] = { '1', '9', '~' };
100 static const UBYTE shift_f11_seq[] = { '3', '0', '~' };
101 static const UBYTE shift_f12_seq[] = { '3', '1', '~' };
102 static const UBYTE insert_seq[] = { '4', '0', '~' };
103 static const UBYTE pageup_seq[] = { '4', '1', '~' };
104 static const UBYTE pagedown_seq[] = { '4', '2', '~' };
105 static const UBYTE pause_seq[] = { '4', '3', '~' };
106 static const UBYTE break_seq[] = { '5', '3', '~' };
107 static const UBYTE home_seq[] = { '4', '4', '~' };
108 static const UBYTE end_seq[] = { '4', '5', '~' };
109 static const UBYTE shift_insert_seq[] = { '5', '0', '~' };
110 static const UBYTE shift_pageup_seq[] = { '5', '1', '~' };
111 static const UBYTE shift_pagedown_seq[] = { '5', '2', '~' };
112 static const UBYTE shift_home_seq[] = { '5', '4', '~' };
113 static const UBYTE shift_end_seq[] = { '5', '5', '~' };
114
115 /* F11, F12, insert, pageup, pagedown, ... seq taken from
116 RKRM: Devices/Console/Reading from the Console Device/Information about the Input Stream */
117
118 static CONST struct csimatch
119 {
120 CONST UBYTE *seq;
121 WORD len;
122 WORD inp;
123 }
124 csimatchtable[] =
125 {
126 {up_seq , 1, INP_CURSORUP },
127 {down_seq , 1, INP_CURSORDOWN },
128 {right_seq , 1, INP_CURSORRIGHT },
129 {left_seq , 1, INP_CURSORLEFT },
130 {shift_up_seq , 1, INP_SHIFT_CURSORUP },
131 {shift_down_seq , 1, INP_SHIFT_CURSORDOWN },
132 {shift_right_seq , 2, INP_SHIFT_CURSORRIGHT },
133 {shift_left_seq , 2, INP_SHIFT_CURSORLEFT },
134 {shift_tab_seq , 1, INP_SHIFT_TAB },
135 {help_seq , 2, INP_HELP },
136 {f1_seq , 2, INP_F1 },
137 {f2_seq , 2, INP_F2 },
138 {f3_seq , 2, INP_F3 },
139 {f4_seq , 2, INP_F4 },
140 {f5_seq , 2, INP_F5 },
141 {f6_seq , 2, INP_F6 },
142 {f7_seq , 2, INP_F7 },
143 {f8_seq , 2, INP_F8 },
144 {f9_seq , 2, INP_F9 },
145 {f10_seq , 2, INP_F10 },
146 {f11_seq , 3, INP_F11 },
147 {f12_seq , 3, INP_F12 },
148 {shift_f1_seq , 3, INP_SHIFT_F1 },
149 {shift_f2_seq , 3, INP_SHIFT_F2 },
150 {shift_f3_seq , 3, INP_SHIFT_F3 },
151 {shift_f4_seq , 3, INP_SHIFT_F4 },
152 {shift_f5_seq , 3, INP_SHIFT_F5 },
153 {shift_f6_seq , 3, INP_SHIFT_F6 },
154 {shift_f7_seq , 3, INP_SHIFT_F7 },
155 {shift_f8_seq , 3, INP_SHIFT_F8 },
156 {shift_f9_seq , 3, INP_SHIFT_F9 },
157 {shift_f10_seq , 3, INP_SHIFT_F10 },
158 {shift_f11_seq , 3, INP_SHIFT_F11 },
159 {shift_f12_seq , 3, INP_SHIFT_F12 },
160 {insert_seq , 3, INP_INSERT },
161 {pageup_seq , 3, INP_PAGEUP },
162 {pagedown_seq , 3, INP_PAGEDOWN },
163 {pause_seq , 3, INP_PAUSE },
164 {break_seq , 3, INP_BREAK },
165 {home_seq , 3, INP_HOME },
166 {end_seq , 3, INP_END },
167 {shift_insert_seq , 3, INP_SHIFT_INSERT },
168 {shift_pageup_seq , 3, INP_SHIFT_PAGEUP },
169 {shift_pagedown_seq , 3, INP_SHIFT_PAGEDOWN },
170 {shift_home_seq , 3, INP_SHIFT_HOME },
171 {shift_end_seq , 3, INP_SHIFT_END },
172 {paste_seq , 3, INP_PASTE },
173 {0 , 0, 0 }
174 };
175
176
177 /******************************************************************************************/
178
179 static UBYTE hex2val(char c)
180 {
181 if (c >= '0' && c <= '9')
182 return c - '0';
183 c &= ~0x20;
184 return c - 'A' + 10;
185 }
186 /* strtoul() not used because it is much larger and uses .bss
187 * TODO: Sanity checks. */
188 static IPTR string2val(const char *s, WORD len)
189 {
190 IPTR v = 0;
191
192 if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
193 {
194 s += 2;
195 while (len-- > 0 && *s)
196 {
197 v <<= 4;
198 v |= hex2val(*s);
199 s++;
200 }
201 }
202 else
203 {
204 while (len-- > 0 && *s)
205 {
206 v *= 10;
207 v += *s - '0';
208 s++;
209 }
210 }
211 return v;
212 }
213
214 BOOL parse_filename(struct filehandle *fh, char *filename, struct NewWindow *nw)
215 {
216 char *param;
217 UBYTE c;
218 WORD paramid = 1;
219 LONG paramval = 0;
220 BOOL ok = TRUE, done = FALSE, paramok = FALSE;
221
222 ASSERT_VALID_PTR(fh);
223 ASSERT_VALID_PTR(nw);
224
225 param = filename;
226 ASSERT_VALID_PTR(param);
227
228 while (!done)
229 {
230 c = *filename++;
231
232 switch (c)
233 {
234 case '0':
235 case '1':
236 case '2':
237 case '3':
238 case '4':
239 case '5':
240 case '6':
241 case '7':
242 case '8':
243 case '9':
244 if (paramid <= 4)
245 {
246 paramval *= 10;
247 paramval += c - '0';
248 }
249 paramok = TRUE;
250 break;
251
252 case '\0':
253 done = TRUE;
254 /* fall through */
255
256 case '/':
257 if (paramok)
258 {
259 UWORD paramlen = filename - param - 1;
260
261 switch (paramid)
262 {
263 case 1:
264 nw->LeftEdge = paramval;
265 break;
266
267 case 2:
268 nw->TopEdge = paramval;
269 break;
270
271 case 3:
272 nw->Width = paramval;
273 break;
274
275 case 4:
276 nw->Height = paramval;
277 break;
278
279 case 5:
280 if ((fh->wintitle = AllocVec(paramlen + 1, MEMF_PUBLIC)))
281 {
282 CopyMem(param, fh->wintitle, paramlen);
283 fh->wintitle[paramlen] = '\0';
284 nw->Title = fh->wintitle;
285 }
286 break;
287
288 default:
289 if (!strnicmp(param, "WAIT", paramlen))
290 {
291 fh->flags |= FHFLG_WAIT;
292 }
293 else if (!strnicmp(param, "CLOSE", paramlen))
294 {
295 nw->Flags |= WFLG_CLOSEGADGET;
296 }
297 else if (!strnicmp(param, "NOCLOSE", paramlen))
298 {
299 nw->Flags &= ~WFLG_CLOSEGADGET;
300 }
301 else if (!strnicmp(param, "AUTO", paramlen))
302 {
303 fh->flags |= FHFLG_AUTO;
304 }
305 else if (!strnicmp(param, "INACTIVE", paramlen))
306 {
307 nw->Flags &= ~WFLG_ACTIVATE;
308 }
309 else if (!strnicmp(param, "NODEPTH", paramlen))
310 {
311 nw->Flags &= ~WFLG_DEPTHGADGET;
312 }
313 else if (!strnicmp(param, "NOSIZE", paramlen))
314 {
315 nw->Flags &= ~WFLG_SIZEGADGET;
316 }
317 else if (!strnicmp(param, "NODRAG", paramlen))
318 {
319 nw->Flags &= ~WFLG_DRAGBAR;
320 }
321 else if (!strnicmp(param, "NOBORDER", paramlen))
322 {
323 nw->Flags |= WFLG_BORDERLESS;
324 }
325 else if (!strnicmp(param, "BACKDROP", paramlen))
326 {
327 nw->Flags |= WFLG_BACKDROP;
328 nw->Flags &= ~(WFLG_DRAGBAR | WFLG_SIZEGADGET);
329 }
330 else if (!strnicmp(param, "SIMPLE", paramlen))
331 {
332 /* TODO */
333 }
334 else if (!strnicmp(param, "SMART", paramlen))
335 {
336 /* TODO */
337 }
338 else if (!strnicmp(param, "ALT", paramlen))
339 {
340 /* TODO: style "ALT30/30/200/200" */
341 }
342 else if (!strnicmp(param, "WINDOW", 6))
343 {
344 /* Do we need some sanity checks here? */
345 fh->otherwindow = (struct Window*) string2val(param + 6, paramlen - 6);
346 }
347 else if (!strnicmp(param, "SCREEN", 6))
348 {
349 if ((fh->screenname = AllocVec(paramlen - 5, MEMF_PUBLIC)))
350 {
351 CopyMem(param + 6, fh->screenname, paramlen - 6);
352 fh->screenname[paramlen - 6] = '\0';
353 }
354 }
355 else if (!strnicmp(param, "BOOT", paramlen)) /* Private parameter */
356 {
357 fh->flags |= FHFLG_BOOTCON;
358 }
359 break;
360
361 } /* switch(paramid) */
362
363 paramok = FALSE;
364
365 } /* if (paramok) */
366
367 paramval = 0;
368 paramid++;
369 param = filename;
370 break;
371
372 default:
373 if (paramid < 5)
374 {
375 done = TRUE;
376 ok = FALSE;
377 }
378 else
379 paramok = TRUE;
380 break;
381
382 } /* switch(c) */
383
384 } /* while (!done) */
385
386 return ok;
387 }
388
389 /******************************************************************************************/
390
391 void do_write(struct filehandle *fh, APTR data, ULONG length)
392 {
393 fh->conwriteio.io_Command = CMD_WRITE;
394 fh->conwriteio.io_Data = data;
395 fh->conwriteio.io_Length = length;
396
397 DoIO((struct IORequest *) &fh->conwriteio);
398 }
399
400 /******************************************************************************************/
401
402 void do_movecursor(struct filehandle *fh, UBYTE direction, UBYTE howmuch)
403 {
404 UBYTE seq[6]; /* 9B <N> <N> <N> <dir> <0> */
405 ULONG size;
406
407 if (howmuch > 0)
408 {
409 seq[0] = 0x9B;
410
411 if (howmuch == 1)
412 {
413 seq[1] = direction;
414 size = 2;
415 }
416 else
417 {
418 sprintf(&seq[1], "%d%c", howmuch, direction);
419 size = strlen(seq);
420 }
421
422 do_write(fh, seq, size);
423 }
424 }
425
426 /******************************************************************************************/
427
428 void do_cursorvisible(struct filehandle *fh, BOOL on)
429 {
430 UBYTE seq[4];
431 ULONG size = 0;
432
433 seq[size++] = 0x9B;
434 if (!on)
435 seq[size++] = '0';
436 seq[size++] = ' ';
437 seq[size++] = 'p';
438
439 do_write(fh, seq, size);
440 }
441
442 /******************************************************************************************/
443
444 void do_deletechar(struct filehandle *fh)
445 {
446 UBYTE seq[] =
447 { 0x9B, 'P' };
448
449 do_write(fh, seq, 2);
450 }
451
452 /******************************************************************************************/
453
454 void do_eraseinline(struct filehandle *fh)
455 {
456 UBYTE seq[] =
457 { 0x9B, 'K' };
458
459 do_write(fh, seq, 2);
460 }
461
462 /******************************************************************************************/
463
464 void do_eraseindisplay(struct filehandle *fh)
465 {
466 UBYTE seq[] =
467 { 0x9B, 'J' };
468
469 do_write(fh, seq, 2);
470 }
471 /******************************************************************************************/
472 static void copy_from_pastebuf(struct filehandle * fh)
473 {
474 if (fh->conbufferpos >= fh->conbuffersize && fh->pastebuffer && fh->pastebufferpos < fh->pastebuffersize)
475 {
476 ULONG len = CONSOLEBUFFER_SIZE;
477 ULONG pastelen = fh->pastebuffersize - fh->pastebufferpos;
478 if (pastelen < len)
479 len = pastelen;
480
481 D(bug("Copying %d bytes from paste buffer\n", len));
482
483 fh->conbufferpos = 0;
484 CopyMem(fh->pastebuffer + fh->pastebufferpos, &fh->consolebuffer, len);
485 fh->conbuffersize = len;
486 fh->pastebufferpos += len;
487 if (fh->pastebufferpos >= fh->pastebuffersize)
488 {
489 FreeMem(fh->pastebuffer, PASTEBUFSIZE);
490 fh->pastebuffer = 0;
491 }
492 }
493 }
494
495 WORD scan_input(struct filehandle *fh, UBYTE *buffer)
496 {
497 CONST
498 struct csimatch *match;
499 UBYTE c;
500 WORD result = INP_DONE;
501
502 copy_from_pastebuf(fh);
503
504 if (fh->conbufferpos < fh->conbuffersize)
505 {
506 c = fh->consolebuffer[fh->conbufferpos++];
507 D(bug("scan_input: check char %d\n", c));
508 switch (c)
509 {
510 case 3:
511 case 4:
512 case 5:
513 case 6:
514 result = INP_CTRL_C - 3 + (WORD) c;
515 break;
516
517 case 8:
518 /* FIXME: Ugh... Race condition, anyone? The qualifier might
519 have changed between the keypress and the time we do this */
520 if (PeekQualifier() & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
521 {
522 result = INP_SHIFT_BACKSPACE;
523 }
524 else
525 {
526 result = INP_BACKSPACE;
527 }
528 break;
529
530 case 9:
531 result = INP_TAB;
532 break;
533
534 case 10:
535 result = INP_LINEFEED;
536 break;
537
538 case 12: /* CTRL-L */
539 *buffer = c;
540 result = INP_ECHO_STRING;
541 break;
542
543 case 13:
544 result = INP_RETURN;
545 break;
546
547 case 127:
548 if (PeekQualifier() & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
549 {
550 result = INP_SHIFT_DELETE;
551 }
552 else
553 {
554 result = INP_DELETE;
555 }
556 break;
557
558 case 24:
559 result = INP_CONTROL_X;
560 break;
561
562 case 28: /* CTRL-\ */
563 result = INP_EOF;
564 break;
565
566 case 0x9B: /* CSI */
567 result = INP_UNKNOWN;
568
569 match = csimatchtable;
570 for (; match->seq; match++)
571 {
572 if (!strncmp(match->seq, &(fh->consolebuffer[fh->conbufferpos]), match->len))
573 {
574 result = match->inp;
575 fh->conbufferpos += match->len;
576 break;
577 }
578 }
579 break;
580
581 default:
582 /* normal keys */
583 *buffer = c;
584 result = INP_STRING;
585 break;
586
587 } /* switch(c) */
588
589 } /* if (fh->conbufferpos < fh->conbuffersize) */
590
591 D(bug("scan_input: result %d\n", result));
592
593 return result;
594 }
595
596 /******************************************************************************************/
597
598 void add_to_history(struct filehandle *fh)
599 {
600 BOOL add_to_history = FALSE;
601
602 fh->inputbuffer[fh->inputsize] = '\0';
603
604 /* Don't add emptry strings */
605 if (fh->inputbuffer[fh->inputstart] == '\0')
606 return;
607
608 if (fh->historysize == 0)
609 {
610 add_to_history = TRUE;
611 }
612 else
613 {
614 WORD old_historypos;
615
616 old_historypos = fh->historypos - 1;
617 if (old_historypos < 0)
618 old_historypos = fh->historysize - 1;
619
620 if (strcmp(&fh->inputbuffer[fh->inputstart], fh->historybuffer[old_historypos]))
621 {
622 /* add to history only if different from last history entry */
623
624 add_to_history = TRUE;
625 }
626 }
627
628 if (add_to_history)
629 {
630 if (fh->historysize < CMD_HISTORY_SIZE)
631 fh->historysize++;
632
633 strcpy(fh->historybuffer[fh->historypos], &fh->inputbuffer[fh->inputstart]);
634
635 fh->historypos++;
636 if (fh->historypos >= CMD_HISTORY_SIZE)
637 fh->historypos = 0;
638 }
639
640 fh->historyviewpos = fh->historypos;
641 }
642
643 /******************************************************************************************/
644
645 void history_walk(struct filehandle *fh, WORD inp)
646 {
647 if (fh->historysize)
648 {
649 #if !CYCLIC_HISTORY_WALK
650 BOOL walk_to_empty_string = FALSE;
651 #endif
652 WORD len;
653
654 switch (inp)
655 {
656 case INP_SHIFT_CURSORUP:
657 fh->historyviewpos = 0;
658 break;
659
660 case INP_SHIFT_CURSORDOWN:
661 fh->historyviewpos = fh->historysize - 1;
662 ;
663 break;
664
665 case INP_CURSORUP:
666 #if CYCLIC_HISTORY_WALK
667 fh->historyviewpos--;
668 if (fh->historyviewpos < 0) fh->historyviewpos = fh->historysize - 1;
669 #else
670 if (fh->historyviewpos != -1)
671 {
672 fh->historyviewpos--;
673 if (fh->historyviewpos < 0 && fh->historysize == CMD_HISTORY_SIZE)
674 fh->historyviewpos = CMD_HISTORY_SIZE - 1;
675 if (fh->historyviewpos == fh->historypos)
676 fh->historyviewpos = -1;
677 }
678 if (fh->historyviewpos == -1)
679 walk_to_empty_string = TRUE;
680 #endif
681 break;
682
683 case INP_CURSORDOWN:
684 #if CYCLIC_HISTORY_WALK
685 fh->historyviewpos++;
686 if (fh->historyviewpos >= fh->historysize) fh->historyviewpos = 0;
687 #else
688 if (fh->historyviewpos != fh->historypos)
689 {
690 if (fh->historyviewpos == -1 && fh->historysize == CMD_HISTORY_SIZE)
691 fh->historyviewpos = fh->historypos;
692 fh->historyviewpos = (fh->historyviewpos + 1) % CMD_HISTORY_SIZE;
693 }
694 if (fh->historyviewpos == fh->historypos)
695 walk_to_empty_string = TRUE;
696 #endif
697 break;
698 }
699
700 if (fh->inputpos > fh->inputstart)
701 {
702 do_movecursor(fh, CUR_LEFT, fh->inputpos - fh->inputstart);
703 }
704
705 do_eraseinline(fh);
706
707 fh->inputsize = fh->inputstart;
708 fh->inputpos = fh->inputstart;
709
710 #if !CYCLIC_HISTORY_WALK
711 if (!walk_to_empty_string)
712 {
713 #endif
714 len = strlen(fh->historybuffer[fh->historyviewpos]);
715 if (len > (INPUTBUFFER_SIZE - fh->inputstart))
716 {
717 len = INPUTBUFFER_SIZE - fh->inputstart;
718 }
719
720 if (len > 0)
721 {
722 CopyMem(fh->historybuffer[fh->historyviewpos], &fh->inputbuffer[fh->inputstart], len);
723
724 fh->inputsize += len;
725 fh->inputpos += len;
726
727 do_write(fh, &fh->inputbuffer[fh->inputstart], len);
728 }
729
730 #if !CYCLIC_HISTORY_WALK
731 } /* if (!walk_to_empty_string) */
732 #endif
733
734 } /* if (fh->historysize) */
735 }
736
737 /****************************************************************************************/
738
739 static const STRPTR CONCLIP_PORTNAME = "ConClip.rendezvous";
740
741 struct MyEditHookMsg
742 {
743 struct Message msg;
744 struct SGWork *sgw;
745 WORD code;
746 };
747
748 static void do_paste(struct filehandle * fh)
749 {
750 struct MsgPort replyport, *port;
751 struct SGWork sgw;
752 struct MyEditHookMsg msg;
753 struct StringInfo sinfo;
754
755 if (!(port = FindPort(CONCLIP_PORTNAME)))
756 {
757 D(bug("ConClip not running, but we got a ConClip paste request"));
758 return;
759 }
760
761 D(bug("PASTE REQUEST!\n"));
762
763 memset( &replyport, 0, sizeof( replyport ) );
764 replyport.mp_Node.ln_Type = NT_MSGPORT;
765 replyport.mp_Flags = PA_SIGNAL;
766 replyport.mp_SigBit = SIGB_SINGLE;
767 replyport.mp_SigTask = FindTask(NULL);
768 NEWLIST(&replyport.mp_MsgList);
769
770 msg.msg.mn_Node.ln_Type = NT_MESSAGE;
771 msg.msg.mn_ReplyPort = &replyport;
772 msg.msg.mn_Length = sizeof(msg);
773
774 msg.code = 'V';
775 msg.sgw = &sgw;
776
777 /* FIXME: Ensure no fields are left uninitialized */
778
779 sgw.Gadget = 0;
780 sgw.WorkBuffer = AllocMem(PASTEBUFSIZE, MEMF_CLEAR | MEMF_ANY);
781 sgw.PrevBuffer = 0;
782 sgw.IEvent = 0;
783 sgw.Code = 'V';
784 sgw.Actions = 0;
785 sgw.LongInt = 0;
786 sgw.GadgetInfo = 0;
787 sgw.EditOp = EO_BIGCHANGE;
788 sgw.BufferPos = 0;
789 sgw.NumChars = 0;
790
791 /* ConClip only ever looks at MaxChars in StringInfo */
792 sinfo.MaxChars = PASTEBUFSIZE;
793 sgw.StringInfo = &sinfo;
794
795 SetSignal(0, SIGF_SINGLE);
796 PutMsg(port, &msg.msg);
797 WaitPort(&replyport);
798
799 D(bug("Pasting %d bytes\n", sgw.BufferPos));
800
801 if (fh->pastebuffer)
802 FreeMem(fh->pastebuffer, PASTEBUFSIZE);
803 fh->pastebuffer = sgw.WorkBuffer;
804 fh->pastebuffersize = sgw.BufferPos;
805 fh->pastebufferpos = 0;
806 }
807
808 /****************************************************************************************/
809
810 BOOL process_input(struct filehandle *fh)
811 {
812 UBYTE c;
813 WORD inp;
814 while ((inp = scan_input(fh, &c)) != INP_DONE)
815 {
816 D(bug("Input Code: %d\n", inp));
817
818 switch (inp)
819 {
820 case INP_CURSORLEFT:
821 if (fh->inputpos > fh->inputstart)
822 {
823 fh->inputpos--;
824 do_movecursor(fh, CUR_LEFT, 1);
825 }
826 break;
827
828 case INP_SHIFT_CURSORLEFT: /* move to beginning of line */
829 case INP_HOME:
830 if (fh->inputpos > fh->inputstart)
831 {
832 do_movecursor(fh, CUR_LEFT, fh->inputpos - fh->inputstart);
833 fh->inputpos = fh->inputstart;
834 }
835 break;
836
837 case INP_CURSORRIGHT:
838 if (fh->inputpos < fh->inputsize)
839 {
840 fh->inputpos++;
841 do_movecursor(fh, CUR_RIGHT, 1);
842 }
843 break;
844
845 case INP_SHIFT_CURSORRIGHT: /* move to end of line */
846 case INP_END:
847 if (fh->inputpos != fh->inputsize)
848 {
849 do_movecursor(fh, CUR_RIGHT, fh->inputsize - fh->inputpos);
850 fh->inputpos = fh->inputsize;
851 }
852 break;
853
854 case INP_CURSORUP: /* walk through cmd history */
855 case INP_CURSORDOWN:
856 case INP_SHIFT_CURSORUP:
857 case INP_SHIFT_CURSORDOWN:
858 history_walk(fh, inp);
859 break;
860
861 case INP_BACKSPACE:
862 if (fh->inputpos > fh->inputstart)
863 {
864 do_movecursor(fh, CUR_LEFT, 1);
865
866 if (fh->inputpos == fh->inputsize)
867 {
868 do_deletechar(fh);
869
870 fh->inputsize--;
871 fh->inputpos--;
872 }
873 else
874 {
875 WORD chars_right = fh->inputsize - fh->inputpos;
876
877 fh->inputsize--;
878 fh->inputpos--;
879
880 do_cursorvisible(fh, FALSE);
881 do_write(fh, &fh->inputbuffer[fh->inputpos + 1], chars_right);
882 do_deletechar(fh);
883 do_movecursor(fh, CUR_LEFT, chars_right);
884 do_cursorvisible(fh, TRUE);
885
886 memmove(&fh->inputbuffer[fh->inputpos], &fh->inputbuffer[fh->inputpos + 1], chars_right);
887
888 }
889 }
890 break;
891
892 case INP_SHIFT_BACKSPACE:
893 if (fh->inputpos > fh->inputstart)
894 {
895 do_movecursor(fh, CUR_LEFT, fh->inputpos - fh->inputstart);
896 if (fh->inputpos == fh->inputsize)
897 {
898 do_eraseinline(fh);
899
900 fh->inputpos = fh->inputsize = fh->inputstart;
901 }
902 else
903 {
904 WORD chars_right = fh->inputsize - fh->inputpos;
905
906 do_cursorvisible(fh, FALSE);
907 do_write(fh, &fh->inputbuffer[fh->inputpos], chars_right);
908 do_eraseinline(fh);
909 do_movecursor(fh, CUR_LEFT, chars_right);
910 do_cursorvisible(fh, TRUE);
911
912 memmove(&fh->inputbuffer[fh->inputstart], &fh->inputbuffer[fh->inputpos], chars_right);
913
914 fh->inputsize -= (fh->inputpos - fh->inputstart);
915 fh->inputpos = fh->inputstart;
916 }
917 }
918 break;
919
920 case INP_DELETE:
921 if (fh->inputpos < fh->inputsize)
922 {
923 fh->inputsize--;
924
925 if (fh->inputpos == fh->inputsize)
926 {
927 do_deletechar(fh);
928 }
929 else
930 {
931 WORD chars_right = fh->inputsize - fh->inputpos;
932
933 do_cursorvisible(fh, FALSE);
934 do_write(fh, &fh->inputbuffer[fh->inputpos + 1], chars_right);
935 do_deletechar(fh);
936 do_movecursor(fh, CUR_LEFT, chars_right);
937 do_cursorvisible(fh, TRUE);
938
939 memmove(&fh->inputbuffer[fh->inputpos], &fh->inputbuffer[fh->inputpos + 1], chars_right);
940 }
941 }
942 break;
943
944 case INP_SHIFT_DELETE:
945 if (fh->inputpos < fh->inputsize)
946 {
947 fh->inputsize = fh->inputpos;
948 do_eraseinline(fh);
949 }
950 break;
951
952 case INP_CONTROL_X:
953 if ((fh->inputsize - fh->inputstart) > 0)
954 {
955 if (fh->inputpos > fh->inputstart)
956 {
957 do_movecursor(fh, CUR_LEFT, fh->inputpos - fh->inputstart);
958 }
959 do_eraseinline(fh);
960
961 fh->inputpos = fh->inputsize = fh->inputstart;
962 }
963 break;
964
965 case INP_ECHO_STRING:
966 do_write(fh, &c, 1);
967 break;
968
969 case INP_STRING:
970 if (fh->inputsize < INPUTBUFFER_SIZE)
971 {
972 do_write(fh, &c, 1);
973
974 if (fh->inputpos == fh->inputsize)
975 {
976 fh->inputbuffer[fh->inputpos++] = c;
977 fh->inputsize++;
978 }
979 else
980 {
981 WORD chars_right = fh->inputsize - fh->inputpos;
982
983 do_cursorvisible(fh, FALSE);
984 do_write(fh, &fh->inputbuffer[fh->inputpos], chars_right);
985 do_movecursor(fh, CUR_LEFT, chars_right);
986 do_cursorvisible(fh, TRUE);
987
988 memmove(&fh->inputbuffer[fh->inputpos + 1], &fh->inputbuffer[fh->inputpos], chars_right);
989 fh->inputbuffer[fh->inputpos++] = c;
990 fh->inputsize++;
991 }
992 }
993 break;
994
995 case INP_EOF:
996 D(bug("[CON] Read EOF (window closing)\n"));
997
998 if (fh->flags & FHFLG_WAITFORCLOSE)
999 return TRUE;
1000
1001 fh->flags |= FHFLG_EOF;
1002 if (fh->flags & FHFLG_AUTO && fh->window)
1003 {
1004 if (fh->flags & FHFLG_CONSOLEDEVICEOPEN)
1005 {
1006 /* Close the device, it will be re-opened if needed */
1007 CloseDevice((struct IORequest *) fh->conreadio);
1008 fh->flags &= ~FHFLG_CONSOLEDEVICEOPEN;
1009 }
1010 /* Only now close the window itself */
1011 CloseWindow(fh->window);
1012 fh->window = NULL;
1013 }
1014
1015 /* fall through */
1016
1017 case INP_RETURN:
1018 if (fh->inputsize < INPUTBUFFER_SIZE)
1019 {
1020 if (inp != INP_EOF)
1021 {
1022 c = '\n';
1023 do_write(fh, &c, 1);
1024 add_to_history(fh);
1025
1026 fh->inputbuffer[fh->inputsize++] = '\n';
1027 }
1028
1029 fh->inputstart = fh->inputsize;
1030 fh->inputpos = fh->inputstart;
1031
1032 if (fh->inputsize)
1033 HandlePendingReads(fh);
1034
1035 if ((fh->flags & FHFLG_EOF) && (fh->flags & FHFLG_READPENDING))
1036 {
1037 struct Message *msg = (struct Message*) RemHead((struct List *) &fh->pendingReads);
1038 struct DosPacket *dp = (struct DosPacket*) msg->mn_Node.ln_Name;
1039
1040 if (dp)
1041 {
1042 replypkt2(dp, 0, 0);
1043 fh->flags &= ~FHFLG_EOF;
1044 }
1045
1046 if (IsListEmpty(&fh->pendingReads))
1047 fh->flags &= ~FHFLG_READPENDING;
1048 }
1049
1050 } /* if (fh->inputsize < INPUTBUFFER_SIZE) */
1051 break;
1052
1053 case INP_LINEFEED:
1054 if (fh->inputsize < INPUTBUFFER_SIZE)
1055 {
1056 c = '\n';
1057 do_write(fh, &c, 1);
1058 add_to_history(fh);
1059
1060 fh->inputbuffer[fh->inputsize++] = c;
1061 fh->inputstart = fh->inputsize;
1062 fh->inputpos = fh->inputsize;
1063 }
1064 break;
1065
1066 case INP_CTRL_C:
1067 case INP_CTRL_D:
1068 case INP_CTRL_E:
1069 case INP_CTRL_F:
1070 if (fh->breaktask)
1071 {
1072 Signal(fh->breaktask, 1L << (12 + inp - INP_CTRL_C));
1073 }
1074 break;
1075
1076 case INP_TAB:
1077 Completion(fh, FALSE);
1078 break;
1079
1080 case INP_SHIFT_TAB:
1081 Completion(fh, TRUE);
1082 break;
1083
1084 case INP_PASTE:
1085 do_paste(fh);
1086 break;
1087
1088 } /* switch(inp) */
1089
1090 } /* while((inp = scan_input(fh, &c)) != INP_DONE) */
1091
1092 return FALSE;
1093 }
1094
1095 BOOL answer_write_request(struct filehandle *fh, struct DosPacket *dp)
1096 {
1097 UBYTE *buffer = (UBYTE*) dp->dp_Arg2;
1098 LONG length = dp->dp_Arg3;
1099
1100 #if RMB_FREEZES_OUTPUT
1101 struct Window *conwindow;
1102
1103 conwindow = ((struct ConUnit *) fh->conwriteio.io_Unit)->cu_Window;
1104
1105 while ((PeekQualifier() & IEQUALIFIER_RBUTTON) && conwindow && (conwindow == IntuitionBase->ActiveWindow))
1106 {
1107 Delay(2);
1108 }
1109 #endif
1110
1111 if ((dp->dp_Port->mp_Flags & PF_ACTION) == PA_SIGNAL && dp->dp_Port->mp_SigTask)
1112 {
1113 fh->lastwritetask = dp->dp_Port->mp_SigTask;
1114 }
1115
1116 do_write(fh, buffer, length);
1117 replypkt2(dp, length, 0);
1118
1119 return TRUE;
1120 }
1121
1122 void answer_read_request(struct filehandle *fh, struct DosPacket *dp, ULONG dp_Arg3)
1123 {
1124 ULONG readlen;
1125
1126 readlen = (fh->inputsize < dp_Arg3) ? fh->inputsize : dp_Arg3;
1127
1128 CopyMem(fh->inputbuffer, (UBYTE*) dp->dp_Arg2, readlen);
1129 CopyMem(fh->inputbuffer + readlen, fh->inputbuffer, fh->inputsize - readlen);
1130
1131 fh->inputsize -= readlen;
1132 fh->inputpos -= readlen;
1133 fh->inputstart -= readlen;
1134
1135 replypkt2(dp, readlen, 0);
1136 }
1137
1138 void HandlePendingReads(struct filehandle *fh)
1139 {
1140 if (fh->flags & FHFLG_READPENDING)
1141 {
1142 struct DosPacket *dp;
1143 struct Message *msg, *next_msg;
1144
1145 ForeachNodeSafe(&fh->pendingReads, msg, next_msg)
1146 {
1147 Remove((struct Node *) msg);
1148 dp = (struct DosPacket*) msg->mn_Node.ln_Name;
1149 answer_read_request(fh, dp, dp->dp_Arg3);
1150
1151 if (fh->inputsize == 0)
1152 break;
1153
1154 }
1155 if (IsListEmpty(&fh->pendingReads))
1156 fh->flags &= ~FHFLG_READPENDING;
1157 }
1158
1159 if (fh->inputsize)
1160 {
1161 fh->flags |= FHFLG_CANREAD;
1162 fh->canreadsize = fh->inputsize;
1163 }
1164 }
1165
1166 void con_read(struct filehandle *fh, struct DosPacket *dp)
1167 {
1168 if (fh->flags & FHFLG_CANREAD)
1169 {
1170 ULONG readlen = (fh->canreadsize < dp->dp_Arg3) ? fh->canreadsize : dp->dp_Arg3;
1171
1172 answer_read_request(fh, dp, readlen);
1173
1174 fh->canreadsize -= readlen;
1175 if (fh->canreadsize == 0)
1176 fh->flags &= ~FHFLG_CANREAD;
1177
1178 }
1179 else
1180 {
1181 if (fh->flags & FHFLG_EOF)
1182 {
1183 replypkt2(dp, 0, 0);
1184 fh->flags &= ~FHFLG_EOF;
1185 }
1186 else
1187 {
1188 AddTail((struct List *) &fh->pendingReads, (struct Node *) dp->dp_Link);
1189 fh->flags |= FHFLG_READPENDING;
1190 }
1191 }
1192 }
Mirror of AROS' svn.