?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libshell / common / edit / emacs.c
blob7a3c39e9519b97b0269b2fef04e306cef7a2c3c0
1 /***********************************************************************
2 * *
3 * This software is part of the ast package *
4 * Copyright (c) 1982-2010 AT&T Intellectual Property *
5 * and is licensed under the *
6 * Common Public License, Version 1.0 *
7 * by AT&T Intellectual Property *
8 * *
9 * A copy of the License is available at *
10 * http://www.opensource.org/licenses/cpl1.0.txt *
11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
12 * *
13 * Information and Software Systems Research *
14 * AT&T Research *
15 * Florham Park NJ *
16 * *
17 * David Korn <dgk@research.att.com> *
18 * *
19 ***********************************************************************/
20 #pragma prototyped
21 /* Original version by Michael T. Veach
22 * Adapted for ksh by David Korn */
23 /* EMACS_MODES: c tabstop=4
24
25 One line screen editor for any program
26
27 */
28
29
30 /* The following is provided by:
31 *
32 * Matthijs N. Melchior
33 * AT&T Network Systems International
34 * APT Nederland
35 * HV BZ335 x2962
36 * hvlpb!mmelchio
37 *
38 * These are now on by default
39 *
40 * ESH_NFIRST
41 * - A ^N as first history related command after the prompt will move
42 * to the next command relative to the last known history position.
43 * It will not start at the position where the last command was entered
44 * as is done by the ^P command. Every history related command will
45 * set both the current and last position. Executing a command will
46 * only set the current position.
47 *
48 * ESH_KAPPEND
49 * - Successive kill and delete commands will accumulate their data
50 * in the kill buffer, by appending or prepending as appropriate.
51 * This mode will be reset by any command not adding something to the
52 * kill buffer.
53 *
54 * ESH_BETTER
55 * - Some enhancements:
56 * - argument for a macro is passed to its replacement
57 * - ^X^H command to find out about history position (debugging)
58 * - ^X^D command to show any debugging info
59 *
60 * I do not pretend these for changes are completely independent,
61 * but you can use them to seperate features.
62 */
63
64 #include <ast.h>
65 #include "FEATURE/cmds"
66 #if KSHELL
67 # include "defs.h"
68 #else
69 # include <ctype.h>
70 #endif /* KSHELL */
71 #include "io.h"
72
73 #include "history.h"
74 #include "edit.h"
75 #include "terminal.h"
76
77 #define ESH_NFIRST
78 #define ESH_KAPPEND
79 #define ESH_BETTER
80
81 #undef putchar
82 #define putchar(ed,c) ed_putchar(ed,c)
83 #define beep() ed_ringbell()
84
85
86 #if SHOPT_MULTIBYTE
87 # define gencpy(a,b) ed_gencpy(a,b)
88 # define genncpy(a,b,n) ed_genncpy(a,b,n)
89 # define genlen(str) ed_genlen(str)
90 static int print(int);
91 static int _isword(int);
92 # define isword(c) _isword(out[c])
93
94 #else
95 # define gencpy(a,b) strcpy((char*)(a),(char*)(b))
96 # define genncpy(a,b,n) strncpy((char*)(a),(char*)(b),n)
97 # define genlen(str) strlen(str)
98 # define print(c) isprint(c)
99 # define isword(c) (isalnum(out[c]) || (out[c]=='_'))
100 #endif /*SHOPT_MULTIBYTE */
101
102 typedef struct _emacs_
103 {
104 genchar *screen; /* pointer to window buffer */
105 genchar *cursor; /* Cursor in real screen */
106 int mark;
107 int in_mult;
108 char cr_ok;
109 char CntrlO;
110 char overflow; /* Screen overflow flag set */
111 char scvalid; /* Screen is up to date */
112 char lastdraw; /* last update type */
113 int offset; /* Screen offset */
114 enum
115 {
116 CRT=0, /* Crt terminal */
117 PAPER /* Paper terminal */
118 } terminal;
119 Histloc_t _location;
120 int prevdirection;
121 Edit_t *ed; /* pointer to edit data */
122 } Emacs_t;
123
124 #define editb (*ep->ed)
125 #define eol editb.e_eol
126 #define cur editb.e_cur
127 #define hline editb.e_hline
128 #define hloff editb.e_hloff
129 #define hismin editb.e_hismin
130 #define usrkill editb.e_kill
131 #define usrlnext editb.e_lnext
132 #define usreof editb.e_eof
133 #define usrerase editb.e_erase
134 #define crallowed editb.e_crlf
135 #define Prompt editb.e_prompt
136 #define plen editb.e_plen
137 #define kstack editb.e_killbuf
138 #define lstring editb.e_search
139 #define lookahead editb.e_lookahead
140 #define env editb.e_env
141 #define raw editb.e_raw
142 #define histlines editb.e_hismax
143 #define w_size editb.e_wsize
144 #define drawbuff editb.e_inbuf
145 #define killing editb.e_mode
146 #define location ep->_location
147
148 #define LBUF 100
149 #define KILLCHAR UKILL
150 #define ERASECHAR UERASE
151 #define EOFCHAR UEOF
152 #define LNEXTCHAR ULNEXT
153 #define DELETE ('a'==97?0177:7)
154
155 /**********************
156 A large lookahead helps when the user is inserting
157 characters in the middle of the line.
158 ************************/
159
160
161 typedef enum
162 {
163 FIRST, /* First time thru for logical line, prompt on screen */
164 REFRESH, /* Redraw entire screen */
165 APPEND, /* Append char before cursor to screen */
166 UPDATE, /* Update the screen as need be */
167 FINAL /* Update screen even if pending look ahead */
168 } Draw_t;
169
170 static void draw(Emacs_t*,Draw_t);
171 static int escape(Emacs_t*,genchar*, int);
172 static void putstring(Emacs_t*,char*);
173 static void search(Emacs_t*,genchar*,int);
174 static void setcursor(Emacs_t*,int, int);
175 static void show_info(Emacs_t*,const char*);
176 static void xcommands(Emacs_t*,int);
177
178 int ed_emacsread(void *context, int fd,char *buff,int scend, int reedit)
179 {
180 Edit_t *ed = (Edit_t*)context;
181 register int c;
182 register int i;
183 register genchar *out;
184 register int count;
185 register Emacs_t *ep = ed->e_emacs;
186 int adjust,oadjust;
187 char backslash;
188 genchar *kptr;
189 char prompt[PRSIZE];
190 genchar Screen[MAXLINE];
191 if(!ep)
192 {
193 ep = ed->e_emacs = newof(0,Emacs_t,1,0);
194 ep->ed = ed;
195 ep->prevdirection = 1;
196 location.hist_command = -5;
197 }
198 Prompt = prompt;
199 ep->screen = Screen;
200 ep->lastdraw = FINAL;
201 if(tty_raw(ERRIO,0) < 0)
202 {
203 return(reedit?reedit:ed_read(context, fd,buff,scend,0));
204 }
205 raw = 1;
206 /* This mess in case the read system call fails */
207
208 ed_setup(ep->ed,fd,reedit);
209 out = (genchar*)buff;
210 #if SHOPT_MULTIBYTE
211 out = (genchar*)roundof(buff-(char*)0,sizeof(genchar));
212 if(reedit)
213 ed_internal(buff,out);
214 #endif /* SHOPT_MULTIBYTE */
215 if(!kstack)
216 {
217 kstack = (genchar*)malloc(CHARSIZE*MAXLINE);
218 kstack[0] = '\0';
219 }
220 drawbuff = out;
221 #ifdef ESH_NFIRST
222 if (location.hist_command == -5) /* to be initialized */
223 {
224 kstack[0] = '\0'; /* also clear kstack... */
225 location.hist_command = hline;
226 location.hist_line = hloff;
227 }
228 if (location.hist_command <= hismin) /* don't start below minimum */
229 {
230 location.hist_command = hismin + 1;
231 location.hist_line = 0;
232 }
233 ep->in_mult = hloff; /* save pos in last command */
234 #endif /* ESH_NFIRST */
235 i = sigsetjmp(env,0);
236 if (i !=0)
237 {
238 if(ep->ed->e_multiline)
239 {
240 cur = eol;
241 draw(ep,FINAL);
242 ed_flush(ep->ed);
243 }
244 tty_cooked(ERRIO);
245 if (i == UEOF)
246 {
247 return(0); /* EOF */
248 }
249 return(-1); /* some other error */
250 }
251 out[reedit] = 0;
252 if(scend+plen > (MAXLINE-2))
253 scend = (MAXLINE-2)-plen;
254 ep->mark = 0;
255 cur = eol;
256 draw(ep,reedit?REFRESH:FIRST);
257 adjust = -1;
258 backslash = 0;
259 if (ep->CntrlO)
260 {
261 #ifdef ESH_NFIRST
262 ed_ungetchar(ep->ed,cntl('N'));
263 #else
264 location = hist_locate(sh.hist_ptr,location.hist_command,location.hist_line,1);
265 if (location.hist_command < histlines)
266 {
267 hline = location.hist_command;
268 hloff = location.hist_line;
269 hist_copy((char*)kstack,MAXLINE, hline,hloff);
270 # if SHOPT_MULTIBYTE
271 ed_internal((char*)kstack,kstack);
272 # endif /* SHOPT_MULTIBYTE */
273 ed_ungetchar(ep->ed,cntl('Y'));
274 }
275 #endif /* ESH_NFIRST */
276 }
277 ep->CntrlO = 0;
278 while ((c = ed_getchar(ep->ed,0)) != (-1))
279 {
280 if (backslash)
281 {
282 backslash = 0;
283 if (c==usrerase||c==usrkill||(!print(c) &&
284 (c!='\r'&&c!='\n')))
285 {
286 /* accept a backslashed character */
287 cur--;
288 out[cur++] = c;
289 out[eol] = '\0';
290 draw(ep,APPEND);
291 continue;
292 }
293 }
294 if (c == usrkill)
295 {
296 c = KILLCHAR ;
297 }
298 else if (c == usrerase)
299 {
300 c = ERASECHAR ;
301 }
302 else if (c == usrlnext)
303 {
304 c = LNEXTCHAR ;
305 }
306 else if ((c == usreof)&&(eol == 0))
307 {
308 c = EOFCHAR;
309 }
310 #ifdef ESH_KAPPEND
311 if (--killing <= 0) /* reset killing flag */
312 killing = 0;
313 #endif
314 oadjust = count = adjust;
315 if(count<0)
316 count = 1;
317 adjust = -1;
318 i = cur;
319 switch(c)
320 {
321 case LNEXTCHAR:
322 c = ed_getchar(ep->ed,2);
323 goto do_default_processing;
324 case cntl('V'):
325 show_info(ep,fmtident(e_version));
326 continue;
327 case '\0':
328 ep->mark = i;
329 continue;
330 case cntl('X'):
331 xcommands(ep,count);
332 continue;
333 case EOFCHAR:
334 ed_flush(ep->ed);
335 tty_cooked(ERRIO);
336 return(0);
337 #ifdef u370
338 case cntl('S') :
339 case cntl('Q') :
340 continue;
341 #endif /* u370 */
342 case '\t':
343 if(cur>0 && ep->ed->sh->nextprompt)
344 {
345 if(ep->ed->e_tabcount==0)
346 {
347 ep->ed->e_tabcount=1;
348 ed_ungetchar(ep->ed,ESC);
349 goto do_escape;
350 }
351 else if(ep->ed->e_tabcount==1)
352 {
353 ed_ungetchar(ep->ed,'=');
354 goto do_escape;
355 }
356 ep->ed->e_tabcount = 0;
357 }
358 do_default_processing:
359 default:
360
361 if ((eol+1) >= (scend)) /* will not fit on line */
362 {
363 ed_ungetchar(ep->ed,c); /* save character for next line */
364 goto process;
365 }
366 for(i= ++eol; i>cur; i--)
367 out[i] = out[i-1];
368 backslash = (c == '\\');
369 out[cur++] = c;
370 draw(ep,APPEND);
371 continue;
372 case cntl('Y') :
373 {
374 c = genlen(kstack);
375 if ((c + eol) > scend)
376 {
377 beep();
378 continue;
379 }
380 ep->mark = i;
381 for(i=eol;i>=cur;i--)
382 out[c+i] = out[i];
383 kptr=kstack;
384 while (i = *kptr++)
385 out[cur++] = i;
386 draw(ep,UPDATE);
387 eol = genlen(out);
388 continue;
389 }
390 case '\n':
391 case '\r':
392 c = '\n';
393 goto process;
394
395 case DELETE: /* delete char 0x7f */
396 case '\b': /* backspace, ^h */
397 case ERASECHAR :
398 if (count > i)
399 count = i;
400 #ifdef ESH_KAPPEND
401 kptr = &kstack[count]; /* move old contents here */
402 if (killing) /* prepend to killbuf */
403 {
404 c = genlen(kstack) + CHARSIZE; /* include '\0' */
405 while(c--) /* copy stuff */
406 kptr[c] = kstack[c];
407 }
408 else
409 *kptr = 0; /* this is end of data */
410 killing = 2; /* we are killing */
411 i -= count;
412 eol -= count;
413 genncpy(kstack,out+i,cur-i);
414 #else
415 while ((count--)&&(i>0))
416 {
417 i--;
418 eol--;
419 }
420 genncpy(kstack,out+i,cur-i);
421 kstack[cur-i] = 0;
422 #endif /* ESH_KAPPEND */
423 gencpy(out+i,out+cur);
424 ep->mark = i;
425 goto update;
426 case cntl('W') :
427 #ifdef ESH_KAPPEND
428 ++killing; /* keep killing flag */
429 #endif
430 if (ep->mark > eol )
431 ep->mark = eol;
432 if (ep->mark == i)
433 continue;
434 if (ep->mark > i)
435 {
436 adjust = ep->mark - i;
437 ed_ungetchar(ep->ed,cntl('D'));
438 continue;
439 }
440 adjust = i - ep->mark;
441 ed_ungetchar(ep->ed,usrerase);
442 continue;
443 case cntl('D') :
444 ep->mark = i;
445 #ifdef ESH_KAPPEND
446 if (killing)
447 kptr = &kstack[genlen(kstack)]; /* append here */
448 else
449 kptr = kstack;
450 killing = 2; /* we are now killing */
451 #else
452 kptr = kstack;
453 #endif /* ESH_KAPPEND */
454 while ((count--)&&(eol>0)&&(i<eol))
455 {
456 *kptr++ = out[i];
457 eol--;
458 while(1)
459 {
460 if ((out[i] = out[(i+1)])==0)
461 break;
462 i++;
463 }
464 i = cur;
465 }
466 *kptr = '\0';
467 goto update;
468 case cntl('C') :
469 case cntl('F') :
470 {
471 int cntlC = (c==cntl('C'));
472 while (count-- && eol>i)
473 {
474 if (cntlC)
475 {
476 c = out[i];
477 #if SHOPT_MULTIBYTE
478 if((c&~STRIP)==0 && islower(c))
479 #else
480 if(islower(c))
481 #endif /* SHOPT_MULTIBYTE */
482 {
483 c += 'A' - 'a';
484 out[i] = c;
485 }
486 }
487 i++;
488 }
489 goto update;
490 }
491 case cntl(']') :
492 c = ed_getchar(ep->ed,1);
493 if ((count == 0) || (count > eol))
494 {
495 beep();
496 continue;
497 }
498 if (out[i])
499 i++;
500 while (i < eol)
501 {
502 if (out[i] == c && --count==0)
503 goto update;
504 i++;
505 }
506 i = 0;
507 while (i < cur)
508 {
509 if (out[i] == c && --count==0)
510 break;
511 i++;
512 };
513
514 update:
515 cur = i;
516 draw(ep,UPDATE);
517 continue;
518
519 case cntl('B') :
520 if (count > i)
521 count = i;
522 i -= count;
523 goto update;
524 case cntl('T') :
525 if ((sh_isoption(SH_EMACS))&& (eol!=i))
526 i++;
527 if (i >= 2)
528 {
529 c = out[i - 1];
530 out[i-1] = out[i-2];
531 out[i-2] = c;
532 }
533 else
534 {
535 if(sh_isoption(SH_EMACS))
536 i--;
537 beep();
538 continue;
539 }
540 goto update;
541 case cntl('A') :
542 i = 0;
543 goto update;
544 case cntl('E') :
545 i = eol;
546 goto update;
547 case cntl('U') :
548 adjust = 4*count;
549 continue;
550 case KILLCHAR :
551 cur = 0;
552 oadjust = -1;
553 case cntl('K') :
554 if(oadjust >= 0)
555 {
556 #ifdef ESH_KAPPEND
557 killing = 2; /* set killing signal */
558 #endif
559 ep->mark = count;
560 ed_ungetchar(ep->ed,cntl('W'));
561 continue;
562 }
563 i = cur;
564 eol = i;
565 ep->mark = i;
566 #ifdef ESH_KAPPEND
567 if (killing) /* append to kill buffer */
568 gencpy(&kstack[genlen(kstack)], &out[i]);
569 else
570 gencpy(kstack,&out[i]);
571 killing = 2; /* set killing signal */
572 #else
573 gencpy(kstack,&out[i]);
574 #endif /* ESH_KAPPEND */
575 out[i] = 0;
576 draw(ep,UPDATE);
577 if (c == KILLCHAR)
578 {
579 if (ep->terminal == PAPER)
580 {
581 putchar(ep->ed,'\n');
582 putstring(ep,Prompt);
583 }
584 c = ed_getchar(ep->ed,0);
585 if (c != usrkill)
586 {
587 ed_ungetchar(ep->ed,c);
588 continue;
589 }
590 if (ep->terminal == PAPER)
591 ep->terminal = CRT;
592 else
593 {
594 ep->terminal = PAPER;
595 putchar(ep->ed,'\n');
596 putstring(ep,Prompt);
597 }
598 }
599 continue;
600 case cntl('L'):
601 if(!ep->ed->e_nocrnl)
602 ed_crlf(ep->ed);
603 draw(ep,REFRESH);
604 ep->ed->e_nocrnl = 0;
605 continue;
606 case cntl('[') :
607 do_escape:
608 adjust = escape(ep,out,oadjust);
609 continue;
610 case cntl('R') :
611 search(ep,out,count);
612 goto drawline;
613 case cntl('P') :
614 if (count <= hloff)
615 hloff -= count;
616 else
617 {
618 hline -= count - hloff;
619 hloff = 0;
620 }
621 #ifdef ESH_NFIRST
622 if (hline <= hismin)
623 #else
624 if (hline < hismin)
625 #endif /* ESH_NFIRST */
626 {
627 hline = hismin+1;
628 beep();
629 #ifndef ESH_NFIRST
630 continue;
631 #endif
632 }
633 goto common;
634
635 case cntl('O') :
636 location.hist_command = hline;
637 location.hist_line = hloff;
638 ep->CntrlO = 1;
639 c = '\n';
640 goto process;
641 case cntl('N') :
642 #ifdef ESH_NFIRST
643 hline = location.hist_command; /* start at saved position */
644 hloff = location.hist_line;
645 #endif /* ESH_NFIRST */
646 location = hist_locate(sh.hist_ptr,hline,hloff,count);
647 if (location.hist_command > histlines)
648 {
649 beep();
650 #ifdef ESH_NFIRST
651 location.hist_command = histlines;
652 location.hist_line = ep->in_mult;
653 #else
654 continue;
655 #endif /* ESH_NFIRST */
656 }
657 hline = location.hist_command;
658 hloff = location.hist_line;
659 common:
660 #ifdef ESH_NFIRST
661 location.hist_command = hline; /* save current position */
662 location.hist_line = hloff;
663 #endif
664 cur = 0;
665 draw(ep,UPDATE);
666 hist_copy((char*)out,MAXLINE, hline,hloff);
667 #if SHOPT_MULTIBYTE
668 ed_internal((char*)(out),out);
669 #endif /* SHOPT_MULTIBYTE */
670 drawline:
671 eol = genlen(out);
672 cur = eol;
673 draw(ep,UPDATE);
674 continue;
675 }
676
677 }
678
679 process:
680
681 if (c == (-1))
682 {
683 lookahead = 0;
684 beep();
685 *out = '\0';
686 }
687 draw(ep,FINAL);
688 tty_cooked(ERRIO);
689 if(ed->e_nlist)
690 {
691 ed->e_nlist = 0;
692 stakset(ed->e_stkptr,ed->e_stkoff);
693 }
694 if(c == '\n')
695 {
696 out[eol++] = '\n';
697 out[eol] = '\0';
698 ed_crlf(ep->ed);
699 }
700 #if SHOPT_MULTIBYTE
701 ed_external(out,buff);
702 #endif /* SHOPT_MULTIBYTE */
703 i = strlen(buff);
704 if (i)
705 return(i);
706 return(-1);
707 }
708
709 static void show_info(Emacs_t *ep,const char *str)
710 {
711 register genchar *out = drawbuff;
712 register int c;
713 genchar string[LBUF];
714 int sav_cur = cur;
715 /* save current line */
716 genncpy(string,out,sizeof(string)/sizeof(*string));
717 *out = 0;
718 cur = 0;
719 #if SHOPT_MULTIBYTE
720 ed_internal(str,out);
721 #else
722 gencpy(out,str);
723 #endif /* SHOPT_MULTIBYTE */
724 draw(ep,UPDATE);
725 c = ed_getchar(ep->ed,0);
726 if(c!=' ')
727 ed_ungetchar(ep->ed,c);
728 /* restore line */
729 cur = sav_cur;
730 genncpy(out,string,sizeof(string)/sizeof(*string));
731 draw(ep,UPDATE);
732 }
733
734 static void putstring(Emacs_t* ep,register char *sp)
735 {
736 register int c;
737 while (c= *sp++)
738 putchar(ep->ed,c);
739 }
740
741
742 static int escape(register Emacs_t* ep,register genchar *out,int count)
743 {
744 register int i,value;
745 int digit,ch;
746 digit = 0;
747 value = 0;
748 while ((i=ed_getchar(ep->ed,0)),isdigit(i))
749 {
750 value *= 10;
751 value += (i - '0');
752 digit = 1;
753 }
754 if (digit)
755 {
756 ed_ungetchar(ep->ed,i) ;
757 #ifdef ESH_KAPPEND
758 ++killing; /* don't modify killing signal */
759 #endif
760 return(value);
761 }
762 value = count;
763 if(value<0)
764 value = 1;
765 switch(ch=i)
766 {
767 case cntl('V'):
768 show_info(ep,fmtident(e_version));
769 return(-1);
770 case ' ':
771 ep->mark = cur;
772 return(-1);
773
774 #ifdef ESH_KAPPEND
775 case '+': /* M-+ = append next kill */
776 killing = 2;
777 return -1; /* no argument for next command */
778 #endif
779
780 case 'p': /* M-p == ^W^Y (copy stack == kill & yank) */
781 ed_ungetchar(ep->ed,cntl('Y'));
782 ed_ungetchar(ep->ed,cntl('W'));
783 #ifdef ESH_KAPPEND
784 killing = 0; /* start fresh */
785 #endif
786 return(-1);
787
788 case 'l': /* M-l == lower-case */
789 case 'd':
790 case 'c':
791 case 'f':
792 {
793 i = cur;
794 while(value-- && i<eol)
795 {
796 while ((out[i])&&(!isword(i)))
797 i++;
798 while ((out[i])&&(isword(i)))
799 i++;
800 }
801 if(ch=='l')
802 {
803 value = i-cur;
804 while (value-- > 0)
805 {
806 i = out[cur];
807 #if SHOPT_MULTIBYTE
808 if((i&~STRIP)==0 && isupper(i))
809 #else
810 if(isupper(i))
811 #endif /* SHOPT_MULTIBYTE */
812 {
813 i += 'a' - 'A';
814 out[cur] = i;
815 }
816 cur++;
817 }
818 draw(ep,UPDATE);
819 return(-1);
820 }
821
822 else if(ch=='f')
823 goto update;
824 else if(ch=='c')
825 {
826 ed_ungetchar(ep->ed,cntl('C'));
827 return(i-cur);
828 }
829 else
830 {
831 if (i-cur)
832 {
833 ed_ungetchar(ep->ed,cntl('D'));
834 #ifdef ESH_KAPPEND
835 ++killing; /* keep killing signal */
836 #endif
837 return(i-cur);
838 }
839 beep();
840 return(-1);
841 }
842 }
843
844
845 case 'b':
846 case DELETE :
847 case '\b':
848 case 'h':
849 {
850 i = cur;
851 while(value-- && i>0)
852 {
853 i--;
854 while ((i>0)&&(!isword(i)))
855 i--;
856 while ((i>0)&&(isword(i-1)))
857 i--;
858 }
859 if(ch=='b')
860 goto update;
861 else
862 {
863 ed_ungetchar(ep->ed,usrerase);
864 #ifdef ESH_KAPPEND
865 ++killing;
866 #endif
867 return(cur-i);
868 }
869 }
870
871 case '>':
872 ed_ungetchar(ep->ed,cntl('N'));
873 #ifdef ESH_NFIRST
874 if (ep->in_mult)
875 {
876 location.hist_command = histlines;
877 location.hist_line = ep->in_mult - 1;
878 }
879 else
880 {
881 location.hist_command = histlines - 1;
882 location.hist_line = 0;
883 }
884 #else
885 hline = histlines-1;
886 hloff = 0;
887 #endif /* ESH_NFIRST */
888 return(0);
889
890 case '<':
891 ed_ungetchar(ep->ed,cntl('P'));
892 hloff = 0;
893 #ifdef ESH_NFIRST
894 hline = hismin + 1;
895 return 0;
896 #else
897 return(hline-hismin);
898 #endif /* ESH_NFIRST */
899
900
901 case '#':
902 ed_ungetchar(ep->ed,'\n');
903 ed_ungetchar(ep->ed,(out[0]=='#')?cntl('D'):'#');
904 ed_ungetchar(ep->ed,cntl('A'));
905 return(-1);
906 case '_' :
907 case '.' :
908 {
909 genchar name[MAXLINE];
910 char buf[MAXLINE];
911 char *ptr;
912 ptr = hist_word(buf,MAXLINE,(count?count:-1));
913 if(ptr==0)
914 {
915 beep();
916 break;
917 }
918 if ((eol - cur) >= sizeof(name))
919 {
920 beep();
921 return(-1);
922 }
923 ep->mark = cur;
924 gencpy(name,&out[cur]);
925 while(*ptr)
926 {
927 out[cur++] = *ptr++;
928 eol++;
929 }
930 gencpy(&out[cur],name);
931 draw(ep,UPDATE);
932 return(-1);
933 }
934 #if KSHELL
935
936 /* file name expansion */
937 case cntl('[') : /* filename completion */
938 i = '\\';
939 case '*': /* filename expansion */
940 case '=': /* escape = - list all matching file names */
941 ep->mark = cur;
942 if(ed_expand(ep->ed,(char*)out,&cur,&eol,i,count) < 0)
943 {
944 if(ep->ed->e_tabcount==1)
945 {
946 ep->ed->e_tabcount=2;
947 ed_ungetchar(ep->ed,cntl('\t'));
948 return(-1);
949 }
950 beep();
951 }
952 else if(i=='=')
953 {
954 draw(ep,REFRESH);
955 if(count>0)
956 ep->ed->e_tabcount=0;
957 else
958 {
959 i=ed_getchar(ep->ed,0);
960 ed_ungetchar(ep->ed,i);
961 if(isdigit(i))
962 ed_ungetchar(ep->ed,ESC);
963 }
964 }
965 else
966 {
967 if(i=='\\' && cur>ep->mark && (out[cur-1]=='/' || out[cur-1]==' '))
968 ep->ed->e_tabcount=0;
969 draw(ep,UPDATE);
970 }
971 return(-1);
972
973 /* search back for character */
974 case cntl(']'): /* feature not in book */
975 {
976 int c = ed_getchar(ep->ed,1);
977 if ((value == 0) || (value > eol))
978 {
979 beep();
980 return(-1);
981 }
982 i = cur;
983 if (i > 0)
984 i--;
985 while (i >= 0)
986 {
987 if (out[i] == c && --value==0)
988 goto update;
989 i--;
990 }
991 i = eol;
992 while (i > cur)
993 {
994 if (out[i] == c && --value==0)
995 break;
996 i--;
997 };
998
999 }
1000 update:
1001 cur = i;
1002 draw(ep,UPDATE);
1003 return(-1);
1004
1005 #ifdef _cmd_tput
1006 case cntl('L'): /* clear screen */
1007 sh_trap("tput clear", 0);
1008 draw(ep,REFRESH);
1009 return(-1);
1010 #endif
1011 case '[': /* feature not in book */
1012 switch(i=ed_getchar(ep->ed,1))
1013 {
1014 case 'A':
1015 if(cur>0 && eol==cur && (cur<(SEARCHSIZE-2) || ep->prevdirection == -2))
1016 {
1017 if(ep->lastdraw==APPEND && ep->prevdirection != -2)
1018 {
1019 out[cur] = 0;
1020 gencpy(&((genchar*)lstring)[1],out);
1021 #if SHOPT_MULTIBYTE
1022 ed_external(&((genchar*)lstring)[1],lstring+1);
1023 #endif /* SHOPT_MULTIBYTE */
1024 *lstring = '^';
1025 ep->prevdirection = -2;
1026 }
1027 if(*lstring)
1028 {
1029 ed_ungetchar(ep->ed,'\r');
1030 ed_ungetchar(ep->ed,cntl('R'));
1031 return(-1);
1032 }
1033 }
1034 *lstring = 0;
1035 ed_ungetchar(ep->ed,cntl('P'));
1036 return(-1);
1037 case 'B':
1038 ed_ungetchar(ep->ed,cntl('N'));
1039 return(-1);
1040 case 'C':
1041 ed_ungetchar(ep->ed,cntl('F'));
1042 return(-1);
1043 case 'D':
1044 ed_ungetchar(ep->ed,cntl('B'));
1045 return(-1);
1046 case 'H':
1047 ed_ungetchar(ep->ed,cntl('A'));
1048 return(-1);
1049 case 'Y':
1050 ed_ungetchar(ep->ed,cntl('E'));
1051 return(-1);
1052 default:
1053 ed_ungetchar(ep->ed,i);
1054 }
1055 i = '_';
1056
1057 default:
1058 /* look for user defined macro definitions */
1059 if(ed_macro(ep->ed,i))
1060 # ifdef ESH_BETTER
1061 return(count); /* pass argument to macro */
1062 # else
1063 return(-1);
1064 # endif /* ESH_BETTER */
1065 #else
1066 update:
1067 cur = i;
1068 draw(ep,UPDATE);
1069 return(-1);
1070
1071 default:
1072 #endif /* KSHELL */
1073 beep();
1074 return(-1);
1075 }
1076 return(-1);
1077 }
1078
1079
1080 /*
1081 * This routine process all commands starting with ^X
1082 */
1083
1084 static void xcommands(register Emacs_t *ep,int count)
1085 {
1086 register int i = ed_getchar(ep->ed,0);
1087 NOT_USED(count);
1088 switch(i)
1089 {
1090 case cntl('X'): /* exchange dot and mark */
1091 if (ep->mark > eol)
1092 ep->mark = eol;
1093 i = ep->mark;
1094 ep->mark = cur;
1095 cur = i;
1096 draw(ep,UPDATE);
1097 return;
1098
1099 #if KSHELL
1100 # ifdef ESH_BETTER
1101 case cntl('E'): /* invoke emacs on current command */
1102 if(ed_fulledit(ep->ed)==-1)
1103 beep();
1104 else
1105 {
1106 #if SHOPT_MULTIBYTE
1107 ed_internal((char*)drawbuff,drawbuff);
1108 #endif /* SHOPT_MULTIBYTE */
1109 ed_ungetchar(ep->ed,'\n');
1110 }
1111 return;
1112
1113 # define itos(i) fmtbase((long)(i),0,0)/* want signed conversion */
1114
1115 case cntl('H'): /* ^X^H show history info */
1116 {
1117 char hbuf[MAXLINE];
1118
1119 strcpy(hbuf, "Current command ");
1120 strcat(hbuf, itos(hline));
1121 if (hloff)
1122 {
1123 strcat(hbuf, " (line ");
1124 strcat(hbuf, itos(hloff+1));
1125 strcat(hbuf, ")");
1126 }
1127 if ((hline != location.hist_command) ||
1128 (hloff != location.hist_line))
1129 {
1130 strcat(hbuf, "; Previous command ");
1131 strcat(hbuf, itos(location.hist_command));
1132 if (location.hist_line)
1133 {
1134 strcat(hbuf, " (line ");
1135 strcat(hbuf, itos(location.hist_line+1));
1136 strcat(hbuf, ")");
1137 }
1138 }
1139 show_info(ep,hbuf);
1140 return;
1141 }
1142 # if 0 /* debugging, modify as required */
1143 case cntl('D'): /* ^X^D show debugging info */
1144 {
1145 char debugbuf[MAXLINE];
1146
1147 strcpy(debugbuf, "count=");
1148 strcat(debugbuf, itos(count));
1149 strcat(debugbuf, " eol=");
1150 strcat(debugbuf, itos(eol));
1151 strcat(debugbuf, " cur=");
1152 strcat(debugbuf, itos(cur));
1153 strcat(debugbuf, " crallowed=");
1154 strcat(debugbuf, itos(crallowed));
1155 strcat(debugbuf, " plen=");
1156 strcat(debugbuf, itos(plen));
1157 strcat(debugbuf, " w_size=");
1158 strcat(debugbuf, itos(w_size));
1159
1160 show_info(ep,debugbuf);
1161 return;
1162 }
1163 # endif /* debugging code */
1164 # endif /* ESH_BETTER */
1165 #endif /* KSHELL */
1166
1167 default:
1168 beep();
1169 return;
1170 }
1171 }
1172
1173 static void search(Emacs_t* ep,genchar *out,int direction)
1174 {
1175 #ifndef ESH_NFIRST
1176 Histloc_t location;
1177 #endif
1178 register int i,sl;
1179 genchar str_buff[LBUF];
1180 register genchar *string = drawbuff;
1181 /* save current line */
1182 int sav_cur = cur;
1183 genncpy(str_buff,string,sizeof(str_buff)/sizeof(*str_buff));
1184 string[0] = '^';
1185 string[1] = 'R';
1186 string[2] = '\0';
1187 sl = 2;
1188 cur = sl;
1189 draw(ep,UPDATE);
1190 while ((i = ed_getchar(ep->ed,1))&&(i != '\r')&&(i != '\n'))
1191 {
1192 if (i==usrerase || i==DELETE || i=='\b' || i==ERASECHAR)
1193 {
1194 if (sl > 2)
1195 {
1196 string[--sl] = '\0';
1197 cur = sl;
1198 draw(ep,UPDATE);
1199 }
1200 else
1201 beep();
1202 continue;
1203 }
1204 if (i==usrkill)
1205 {
1206 beep();
1207 goto restore;
1208 }
1209 if (i == '\\')
1210 {
1211 string[sl++] = '\\';
1212 string[sl] = '\0';
1213 cur = sl;
1214 draw(ep,APPEND);
1215 i = ed_getchar(ep->ed,1);
1216 string[--sl] = '\0';
1217 }
1218 string[sl++] = i;
1219 string[sl] = '\0';
1220 cur = sl;
1221 draw(ep,APPEND);
1222 }
1223 i = genlen(string);
1224
1225 if(ep->prevdirection == -2 && i!=2 || direction!=1)
1226 ep->prevdirection = -1;
1227 if (direction < 1)
1228 {
1229 ep->prevdirection = -ep->prevdirection;
1230 direction = 1;
1231 }
1232 else
1233 direction = -1;
1234 if (i != 2)
1235 {
1236 #if SHOPT_MULTIBYTE
1237 ed_external(string,(char*)string);
1238 #endif /* SHOPT_MULTIBYTE */
1239 strncpy(lstring,((char*)string)+2,SEARCHSIZE);
1240 ep->prevdirection = direction;
1241 }
1242 else
1243 direction = ep->prevdirection ;
1244 location = hist_find(sh.hist_ptr,(char*)lstring,hline,1,direction);
1245 i = location.hist_command;
1246 if(i>0)
1247 {
1248 hline = i;
1249 #ifdef ESH_NFIRST
1250 hloff = location.hist_line = 0; /* display first line of multi line command */
1251 #else
1252 hloff = location.hist_line;
1253 #endif /* ESH_NFIRST */
1254 hist_copy((char*)out,MAXLINE, hline,hloff);
1255 #if SHOPT_MULTIBYTE
1256 ed_internal((char*)out,out);
1257 #endif /* SHOPT_MULTIBYTE */
1258 return;
1259 }
1260 if (i < 0)
1261 {
1262 beep();
1263 #ifdef ESH_NFIRST
1264 location.hist_command = hline;
1265 location.hist_line = hloff;
1266 #else
1267 hloff = 0;
1268 hline = histlines;
1269 #endif /* ESH_NFIRST */
1270 }
1271 restore:
1272 genncpy(string,str_buff,sizeof(str_buff)/sizeof(*str_buff));
1273 cur = sav_cur;
1274 return;
1275 }
1276
1277
1278 /* Adjust screen to agree with inputs: logical line and cursor */
1279 /* If 'first' assume screen is blank */
1280 /* Prompt is always kept on the screen */
1281
1282 static void draw(register Emacs_t *ep,Draw_t option)
1283 {
1284 #define NORMAL ' '
1285 #define LOWER '<'
1286 #define BOTH '*'
1287 #define UPPER '>'
1288
1289 register genchar *sptr; /* Pointer within screen */
1290 genchar nscreen[2*MAXLINE]; /* New entire screen */
1291 genchar *ncursor; /* New cursor */
1292 register genchar *nptr; /* Pointer to New screen */
1293 char longline; /* Line overflow */
1294 genchar *logcursor;
1295 genchar *nscend; /* end of logical screen */
1296 register int i;
1297
1298 nptr = nscreen;
1299 sptr = drawbuff;
1300 logcursor = sptr + cur;
1301 longline = NORMAL;
1302 ep->lastdraw = option;
1303
1304 if (option == FIRST || option == REFRESH)
1305 {
1306 ep->overflow = NORMAL;
1307 ep->cursor = ep->screen;
1308 ep->offset = 0;
1309 ep->cr_ok = crallowed;
1310 if (option == FIRST)
1311 {
1312 ep->scvalid = 1;
1313 return;
1314 }
1315 *ep->cursor = '\0';
1316 putstring(ep,Prompt); /* start with prompt */
1317 }
1318
1319 /*********************
1320 Do not update screen if pending characters
1321 **********************/
1322
1323 if ((lookahead)&&(option != FINAL))
1324 {
1325
1326 ep->scvalid = 0; /* Screen is out of date, APPEND will not work */
1327
1328 return;
1329 }
1330
1331 /***************************************
1332 If in append mode, cursor at end of line, screen up to date,
1333 the previous character was a 'normal' character,
1334 and the window has room for another character.
1335 Then output the character and adjust the screen only.
1336 *****************************************/
1337
1338
1339 i = *(logcursor-1); /* last character inserted */
1340
1341 if ((option == APPEND)&&(ep->scvalid)&&(*logcursor == '\0')&&
1342 print(i)&&((ep->cursor-ep->screen)<(w_size-1)))
1343 {
1344 putchar(ep->ed,i);
1345 *ep->cursor++ = i;
1346 *ep->cursor = '\0';
1347 return;
1348 }
1349
1350 /* copy the line */
1351 ncursor = nptr + ed_virt_to_phys(ep->ed,sptr,nptr,cur,0,0);
1352 nptr += genlen(nptr);
1353 sptr += genlen(sptr);
1354 nscend = nptr - 1;
1355 if(sptr == logcursor)
1356 ncursor = nptr;
1357
1358 /*********************
1359 Does ncursor appear on the screen?
1360 If not, adjust the screen offset so it does.
1361 **********************/
1362
1363 i = ncursor - nscreen;
1364
1365 if ((ep->offset && i<=ep->offset)||(i >= (ep->offset+w_size)))
1366 {
1367 /* Center the cursor on the screen */
1368 ep->offset = i - (w_size>>1);
1369 if (--ep->offset < 0)
1370 ep->offset = 0;
1371 }
1372
1373 /*********************
1374 Is the range of screen[0] thru screen[w_size] up-to-date
1375 with nscreen[offset] thru nscreen[offset+w_size] ?
1376 If not, update as need be.
1377 ***********************/
1378
1379 nptr = &nscreen[ep->offset];
1380 sptr = ep->screen;
1381
1382 i = w_size;
1383
1384 while (i-- > 0)
1385 {
1386
1387 if (*nptr == '\0')
1388 {
1389 *(nptr + 1) = '\0';
1390 *nptr = ' ';
1391 }
1392 if (*sptr == '\0')
1393 {
1394 *(sptr + 1) = '\0';
1395 *sptr = ' ';
1396 }
1397 if (*nptr == *sptr)
1398 {
1399 nptr++;
1400 sptr++;
1401 continue;
1402 }
1403 setcursor(ep,sptr-ep->screen,*nptr);
1404 *sptr++ = *nptr++;
1405 #if SHOPT_MULTIBYTE
1406 while(*nptr==MARKER)
1407 {
1408 if(*sptr=='\0')
1409 *(sptr + 1) = '\0';
1410 *sptr++ = *nptr++;
1411 i--;
1412 ep->cursor++;
1413 }
1414 #endif /* SHOPT_MULTIBYTE */
1415 }
1416 if(ep->ed->e_multiline && option == REFRESH && ep->ed->e_nocrnl==0)
1417 ed_setcursor(ep->ed, ep->screen, ep->cursor-ep->screen, ep->ed->e_peol, -1);
1418
1419
1420 /******************
1421
1422 Screen overflow checks
1423
1424 ********************/
1425
1426 if (nscend >= &nscreen[ep->offset+w_size])
1427 {
1428 if (ep->offset > 0)
1429 longline = BOTH;
1430 else
1431 longline = UPPER;
1432 }
1433 else
1434 {
1435 if (ep->offset > 0)
1436 longline = LOWER;
1437 }
1438
1439 /* Update screen overflow indicator if need be */
1440
1441 if (longline != ep->overflow)
1442 {
1443 setcursor(ep,w_size,longline);
1444 ep->overflow = longline;
1445 }
1446 i = (ncursor-nscreen) - ep->offset;
1447 setcursor(ep,i,0);
1448 if(option==FINAL && ep->ed->e_multiline)
1449 setcursor(ep,nscend+1-nscreen,0);
1450 ep->scvalid = 1;
1451 return;
1452 }
1453
1454 /*
1455 * put the cursor to the <newp> position within screen buffer
1456 * if <c> is non-zero then output this character
1457 * cursor is set to reflect the change
1458 */
1459
1460 static void setcursor(register Emacs_t *ep,register int newp,int c)
1461 {
1462 register int oldp = ep->cursor - ep->screen;
1463 newp = ed_setcursor(ep->ed, ep->screen, oldp, newp, 0);
1464 if(c)
1465 {
1466 putchar(ep->ed,c);
1467 newp++;
1468 }
1469 ep->cursor = ep->screen+newp;
1470 return;
1471 }
1472
1473 #if SHOPT_MULTIBYTE
1474 static int print(register int c)
1475 {
1476 return((c&~STRIP)==0 && isprint(c));
1477 }
1478
1479 static int _isword(register int c)
1480 {
1481 return((c&~STRIP) || isalnum(c) || c=='_');
1482 }
1483 #endif /* SHOPT_MULTIBYTE */
unleashed repo fork