1 #include <u.h>
2 #include <libc.h>
3 #include <draw.h>
4 #include <thread.h>
5 #include <cursor.h>
6 #include <mouse.h>
7 #include <keyboard.h>
8 #include <frame.h>
9 #include <fcall.h>
10 #include <plumb.h>
11 #include "dat.h"
12 #include "edit.h"
13 #include "fns.h"
14 
15 static char	linex[]="\n";
16 static char	wordx[]=" \t\n";
17 struct cmdtab cmdtab[]={
18 /*	cmdc	text	regexp	addr	defcmd	defaddr	count	token	 fn	*/
19 	'\n',	0,	0,	0,	0,	aDot,	0,	0,	nl_cmd,
20 	'a',	1,	0,	0,	0,	aDot,	0,	0,	a_cmd,
21 	'b',	0,	0,	0,	0,	aNo,	0,	linex,	b_cmd,
22 	'c',	1,	0,	0,	0,	aDot,	0,	0,	c_cmd,
23 	'd',	0,	0,	0,	0,	aDot,	0,	0,	d_cmd,
24 	'e',	0,	0,	0,	0,	aNo,	0,	wordx,	e_cmd,
25 	'f',	0,	0,	0,	0,	aNo,	0,	wordx,	f_cmd,
26 	'g',	0,	1,	0,	'p',	aDot,	0,	0,	g_cmd,
27 	'i',	1,	0,	0,	0,	aDot,	0,	0,	i_cmd,
28 	'm',	0,	0,	1,	0,	aDot,	0,	0,	m_cmd,
29 	'p',	0,	0,	0,	0,	aDot,	0,	0,	p_cmd,
30 	'r',	0,	0,	0,	0,	aDot,	0,	wordx,	e_cmd,
31 	's',	0,	1,	0,	0,	aDot,	1,	0,	s_cmd,
32 	't',	0,	0,	1,	0,	aDot,	0,	0,	m_cmd,
33 	'u',	0,	0,	0,	0,	aNo,	2,	0,	u_cmd,
34 	'v',	0,	1,	0,	'p',	aDot,	0,	0,	g_cmd,
35 	'w',	0,	0,	0,	0,	aAll,	0,	wordx,	w_cmd,
36 	'x',	0,	1,	0,	'p',	aDot,	0,	0,	x_cmd,
37 	'y',	0,	1,	0,	'p',	aDot,	0,	0,	x_cmd,
38 	'=',	0,	0,	0,	0,	aDot,	0,	linex,	eq_cmd,
39 	'B',	0,	0,	0,	0,	aNo,	0,	linex,	B_cmd,
40 	'D',	0,	0,	0,	0,	aNo,	0,	linex,	D_cmd,
41 	'X',	0,	1,	0,	'f',	aNo,	0,	0,	X_cmd,
42 	'Y',	0,	1,	0,	'f',	aNo,	0,	0,	X_cmd,
43 	'<',	0,	0,	0,	0,	aDot,	0,	linex,	pipe_cmd,
44 	'|',	0,	0,	0,	0,	aDot,	0,	linex,	pipe_cmd,
45 	'>',	0,	0,	0,	0,	aDot,	0,	linex,	pipe_cmd,
46 /* deliberately unimplemented:
47 	'k',	0,	0,	0,	0,	aDot,	0,	0,	k_cmd,
48 	'n',	0,	0,	0,	0,	aNo,	0,	0,	n_cmd,
49 	'q',	0,	0,	0,	0,	aNo,	0,	0,	q_cmd,
50 	'!',	0,	0,	0,	0,	aNo,	0,	linex,	plan9_cmd,
51  */
52 	0,	0,	0,	0,	0,	0,	0,	0,
53 };
54 
55 Cmd	*parsecmd(int);
56 Addr	*compoundaddr(void);
57 Addr	*simpleaddr(void);
58 void	freecmd(void);
59 void	okdelim(int);
60 
61 Rune	*cmdstartp;
62 Rune *cmdendp;
63 Rune	*cmdp;
64 Channel	*editerrc;
65 
66 String	*lastpat;
67 int	patset;
68 
69 List	cmdlist;
70 List	addrlist;
71 List	stringlist;
72 Text	*curtext;
73 int	editing = Inactive;
74 
75 String*	newstring(int);
76 
77 void
78 editthread(void *v)
79 {
80 	Cmd *cmdp;
81 
82 	USED(v);
83 	threadsetname("editthread");
84 	while((cmdp=parsecmd(0)) != 0){
85 //		ocurfile = curfile;
86 //		loaded = curfile && !curfile->unread;
87 		if(cmdexec(curtext, cmdp) == 0)
88 			break;
89 		freecmd();
90 	}
91 	sendp(editerrc, nil);
92 }
93 
94 void
95 allelogterm(Window *w, void *x)
96 {
97 	USED(x);
98 	elogterm(w->body.file);
99 }
100 
101 void
102 alleditinit(Window *w, void *x)
103 {
104 	USED(x);
105 	textcommit(&w->tag, TRUE);
106 	textcommit(&w->body, TRUE);
107 	w->body.file->editclean = FALSE;
108 }
109 
110 void
111 allupdate(Window *w, void *x)
112 {
113 	Text *t;
114 	int i;
115 	File *f;
116 
117 	USED(x);
118 	t = &w->body;
119 	f = t->file;
120 	if(f->curtext != t)	/* do curtext only */
121 		return;
122 	if(f->elog.type == Null)
123 		elogterm(f);
124 	else if(f->elog.type != Empty){
125 		elogapply(f);
126 		if(f->editclean){
127 			f->mod = FALSE;
128 			for(i=0; i<f->ntext; i++)
129 				f->text[i]->w->dirty = FALSE;
130 		}
131 	}
132 	textsetselect(t, t->q0, t->q1);
133 	textscrdraw(t);
134 	winsettag(w);
135 }
136 
137 void
138 editerror(char *fmt, ...)
139 {
140 	va_list arg;
141 	char *s;
142 
143 	va_start(arg, fmt);
144 	s = vsmprint(fmt, arg);
145 	va_end(arg);
146 	freecmd();
147 	allwindows(allelogterm, nil);	/* truncate the edit logs */
148 	sendp(editerrc, s);
149 	threadexits(nil);
150 }
151 
152 void
153 editcmd(Text *ct, Rune *r, uint n)
154 {
155 	char *err;
156 
157 	if(n == 0)
158 		return;
159 	if(2*n > RBUFSIZE){
160 		warning(nil, "string too long\n");
161 		return;
162 	}
163 
164 	allwindows(alleditinit, nil);
165 	if(cmdstartp)
166 		free(cmdstartp);
167 	cmdstartp = runemalloc(n+2);
168 	runemove(cmdstartp, r, n);
169 	if(r[n] != '\n')
170 		cmdstartp[n++] = '\n';
171 	cmdstartp[n] = '\0';
172 	cmdendp = cmdstartp+n;
173 	cmdp = cmdstartp;
174 	if(ct->w == nil)
175 		curtext = nil;
176 	else
177 		curtext = &ct->w->body;
178 	resetxec();
179 	if(editerrc == nil){
180 		editerrc = chancreate(sizeof(char*), 0);
181 		lastpat = allocstring(0);
182 	}
183 	threadcreate(editthread, nil, STACK);
184 	err = recvp(editerrc);
185 	editing = Inactive;
186 	if(err != nil){
187 		if(err[0] != '\0')
188 			warning(nil, "Edit: %s\n", err);
189 		free(err);
190 	}
191 
192 	/* update everyone whose edit log has data */
193 	allwindows(allupdate, nil);
194 }
195 
196 int
197 getch(void)
198 {
199 	if(*cmdp == *cmdendp)
200 		return -1;
201 	return *cmdp++;
202 }
203 
204 int
205 nextc(void)
206 {
207 	if(*cmdp == *cmdendp)
208 		return -1;
209 	return *cmdp;
210 }
211 
212 void
213 ungetch(void)
214 {
215 	if(--cmdp < cmdstartp)
216 		error("ungetch");
217 }
218 
219 long
220 getnum(int signok)
221 {
222 	long n;
223 	int c, sign;
224 
225 	n = 0;
226 	sign = 1;
227 	if(signok>1 && nextc()=='-'){
228 		sign = -1;
229 		getch();
230 	}
231 	if((c=nextc())<'0' || '9'<c)	/* no number defaults to 1 */
232 		return sign;
233 	while('0'<=(c=getch()) && c<='9')
234 		n = n*10 + (c-'0');
235 	ungetch();
236 	return sign*n;
237 }
238 
239 int
240 cmdskipbl(void)
241 {
242 	int c;
243 	do
244 		c = getch();
245 	while(c==' ' || c=='\t');
246 	if(c >= 0)
247 		ungetch();
248 	return c;
249 }
250 
251 /*
252  * Check that list has room for one more element.
253  */
254 void
255 growlist(List *l)
256 {
257 	if(l->u.listptr==0 || l->nalloc==0){
258 		l->nalloc = INCR;
259 		l->u.listptr = emalloc(INCR*sizeof(long));
260 		l->nused = 0;
261 	}else if(l->nused == l->nalloc){
262 		l->u.listptr = erealloc(l->u.listptr, (l->nalloc+INCR)*sizeof(long));
263 		memset((void*)(l->u.longptr+l->nalloc), 0, INCR*sizeof(long));
264 		l->nalloc += INCR;
265 	}
266 }
267 
268 /*
269  * Remove the ith element from the list
270  */
271 void
272 dellist(List *l, int i)
273 {
274 	memmove(&l->u.longptr[i], &l->u.longptr[i+1], (l->nused-(i+1))*sizeof(long));
275 	l->nused--;
276 }
277 
278 /*
279  * Add a new element, whose position is i, to the list
280  */
281 void
282 inslist(List *l, int i, long val)
283 {
284 	growlist(l);
285 	memmove(&l->u.longptr[i+1], &l->u.longptr[i], (l->nused-i)*sizeof(long));
286 	l->u.longptr[i] = val;
287 	l->nused++;
288 }
289 
290 void
291 listfree(List *l)
292 {
293 	free(l->u.listptr);
294 	free(l);
295 }
296 
297 String*
298 allocstring(int n)
299 {
300 	String *s;
301 
302 	s = emalloc(sizeof(String));
303 	s->n = n;
304 	s->nalloc = n+10;
305 	s->r = emalloc(s->nalloc*sizeof(Rune));
306 	s->r[n] = '\0';
307 	return s;
308 }
309 
310 void
311 freestring(String *s)
312 {
313 	free(s->r);
314 	free(s);
315 }
316 
317 Cmd*
318 newcmd(void){
319 	Cmd *p;
320 
321 	p = emalloc(sizeof(Cmd));
322 	inslist(&cmdlist, cmdlist.nused, (long)p);
323 	return p;
324 }
325 
326 String*
327 newstring(int n)
328 {
329 	String *p;
330 
331 	p = allocstring(n);
332 	inslist(&stringlist, stringlist.nused, (long)p);
333 	return p;
334 }
335 
336 Addr*
337 newaddr(void)
338 {
339 	Addr *p;
340 
341 	p = emalloc(sizeof(Addr));
342 	inslist(&addrlist, addrlist.nused, (long)p);
343 	return p;
344 }
345 
346 void
347 freecmd(void)
348 {
349 	int i;
350 
351 	while(cmdlist.nused > 0)
352 		free(cmdlist.u.ucharptr[--cmdlist.nused]);
353 	while(addrlist.nused > 0)
354 		free(addrlist.u.ucharptr[--addrlist.nused]);
355 	while(stringlist.nused>0){
356 		i = --stringlist.nused;
357 		freestring(stringlist.u.stringptr[i]);
358 	}
359 }
360 
361 void
362 okdelim(int c)
363 {
364 	if(c=='\\' || ('a'<=c && c<='z')
365 	|| ('A'<=c && c<='Z') || ('0'<=c && c<='9'))
366 		editerror("bad delimiter %c\n", c);
367 }
368 
369 void
370 atnl(void)
371 {
372 	int c;
373 
374 	cmdskipbl();
375 	c = getch();
376 	if(c != '\n')
377 		editerror("newline expected (saw %C)", c);
378 }
379 
380 void
381 Straddc(String *s, int c)
382 {
383 	if(s->n+1 >= s->nalloc){
384 		s->nalloc += 10;
385 		s->r = erealloc(s->r, s->nalloc*sizeof(Rune));
386 	}
387 	s->r[s->n++] = c;
388 	s->r[s->n] = '\0';
389 }
390 
391 void
392 getrhs(String *s, int delim, int cmd)
393 {
394 	int c;
395 
396 	while((c = getch())>0 && c!=delim && c!='\n'){
397 		if(c == '\\'){
398 			if((c=getch()) <= 0)
399 				error("bad right hand side");
400 			if(c == '\n'){
401 				ungetch();
402 				c='\\';
403 			}else if(c == 'n')
404 				c='\n';
405 			else if(c!=delim && (cmd=='s' || c!='\\'))	/* s does its own */
406 				Straddc(s, '\\');
407 		}
408 		Straddc(s, c);
409 	}
410 	ungetch();	/* let client read whether delimiter, '\n' or whatever */
411 }
412 
413 String *
414 collecttoken(char *end)
415 {
416 	String *s = newstring(0);
417 	int c;
418 
419 	while((c=nextc())==' ' || c=='\t')
420 		Straddc(s, getch()); /* blanks significant for getname() */
421 	while((c=getch())>0 && utfrune(end, c)==0)
422 		Straddc(s, c);
423 	if(c != '\n')
424 		atnl();
425 	return s;
426 }
427 
428 String *
429 collecttext(void)
430 {
431 	String *s;
432 	int begline, i, c, delim;
433 
434 	s = newstring(0);
435 	if(cmdskipbl()=='\n'){
436 		getch();
437 		i = 0;
438 		do{
439 			begline = i;
440 			while((c = getch())>0 && c!='\n')
441 				i++, Straddc(s, c);
442 			i++, Straddc(s, '\n');
443 			if(c < 0)
444 				goto Return;
445 		}while(s->r[begline]!='.' || s->r[begline+1]!='\n');
446 		s->r[s->n-2] = '\0';
447 	}else{
448 		okdelim(delim = getch());
449 		getrhs(s, delim, 'a');
450 		if(nextc()==delim)
451 			getch();
452 		atnl();
453 	}
454     Return:
455 	return s;
456 }
457 
458 int
459 cmdlookup(int c)
460 {
461 	int i;
462 
463 	for(i=0; cmdtab[i].cmdc; i++)
464 		if(cmdtab[i].cmdc == c)
465 			return i;
466 	return -1;
467 }
468 
469 Cmd*
470 parsecmd(int nest)
471 {
472 	int i, c;
473 	struct cmdtab *ct;
474 	Cmd *cp, *ncp;
475 	Cmd cmd;
476 
477 	cmd.next = cmd.u.cmd = 0;
478 	cmd.re = 0;
479 	cmd.flag = cmd.num = 0;
480 	cmd.addr = compoundaddr();
481 	if(cmdskipbl() == -1)
482 		return 0;
483 	if((c=getch())==-1)
484 		return 0;
485 	cmd.cmdc = c;
486 	if(cmd.cmdc=='c' && nextc()=='d'){	/* sleazy two-character case */
487 		getch();		/* the 'd' */
488 		cmd.cmdc='c'|0x100;
489 	}
490 	i = cmdlookup(cmd.cmdc);
491 	if(i >= 0){
492 		if(cmd.cmdc == '\n')
493 			goto Return;	/* let nl_cmd work it all out */
494 		ct = &cmdtab[i];
495 		if(ct->defaddr==aNo && cmd.addr)
496 			editerror("command takes no address");
497 		if(ct->count)
498 			cmd.num = getnum(ct->count);
499 		if(ct->regexp){
500 			/* x without pattern -> .*\n, indicated by cmd.re==0 */
501 			/* X without pattern is all files */
502 			if((ct->cmdc!='x' && ct->cmdc!='X') ||
503 			   ((c = nextc())!=' ' && c!='\t' && c!='\n')){
504 				cmdskipbl();
505 				if((c = getch())=='\n' || c<0)
506 					editerror("no address");
507 				okdelim(c);
508 				cmd.re = getregexp(c);
509 				if(ct->cmdc == 's'){
510 					cmd.u.text = newstring(0);
511 					getrhs(cmd.u.text, c, 's');
512 					if(nextc() == c){
513 						getch();
514 						if(nextc() == 'g')
515 							cmd.flag = getch();
516 					}
517 			
518 				}
519 			}
520 		}
521 		if(ct->addr && (cmd.u.mtaddr=simpleaddr())==0)
522 			editerror("bad address");
523 		if(ct->defcmd){
524 			if(cmdskipbl() == '\n'){
525 				getch();
526 				cmd.u.cmd = newcmd();
527 				cmd.u.cmd->cmdc = ct->defcmd;
528 			}else if((cmd.u.cmd = parsecmd(nest))==0)
529 				error("defcmd");
530 		}else if(ct->text)
531 			cmd.u.text = collecttext();
532 		else if(ct->token)
533 			cmd.u.text = collecttoken(ct->token);
534 		else
535 			atnl();
536 	}else
537 		switch(cmd.cmdc){
538 		case '{':
539 			cp = 0;
540 			do{
541 				if(cmdskipbl()=='\n')
542 					getch();
543 				ncp = parsecmd(nest+1);
544 				if(cp)
545 					cp->next = ncp;
546 				else
547 					cmd.u.cmd = ncp;
548 			}while(cp = ncp);
549 			break;
550 		case '}':
551 			atnl();
552 			if(nest==0)
553 				editerror("right brace with no left brace");
554 			return 0;
555 		default:
556 			editerror("unknown command %c", cmd.cmdc);
557 		}
558     Return:
559 	cp = newcmd();
560 	*cp = cmd;
561 	return cp;
562 }
563 
564 String*
565 getregexp(int delim)
566 {
567 	String *buf, *r;
568 	int i, c;
569 
570 	buf = allocstring(0);
571 	for(i=0; ; i++){
572 		if((c = getch())=='\\'){
573 			if(nextc()==delim)
574 				c = getch();
575 			else if(nextc()=='\\'){
576 				Straddc(buf, c);
577 				c = getch();
578 			}
579 		}else if(c==delim || c=='\n')
580 			break;
581 		if(i >= RBUFSIZE)
582 			editerror("regular expression too long");
583 		Straddc(buf, c);
584 	}
585 	if(c!=delim && c)
586 		ungetch();
587 	if(buf->n > 0){
588 		patset = TRUE;
589 		freestring(lastpat);
590 		lastpat = buf;
591 	}else
592 		freestring(buf);
593 	if(lastpat->n == 0)
594 		editerror("no regular expression defined");
595 	r = newstring(lastpat->n);
596 	runemove(r->r, lastpat->r, lastpat->n);	/* newstring put \0 at end */
597 	return r;
598 }
599 
600 Addr *
601 simpleaddr(void)
602 {
603 	Addr addr;
604 	Addr *ap, *nap;
605 
606 	addr.next = 0;
607 	addr.u.left = 0;
608 	switch(cmdskipbl()){
609 	case '#':
610 		addr.type = getch();
611 		addr.num = getnum(1);
612 		break;
613 	case '0': case '1': case '2': case '3': case '4':
614 	case '5': case '6': case '7': case '8': case '9': 
615 		addr.num = getnum(1);
616 		addr.type='l';
617 		break;
618 	case '/': case '?': case '"':
619 		addr.u.re = getregexp(addr.type = getch());
620 		break;
621 	case '.':
622 	case '$':
623 	case '+':
624 	case '-':
625 	case '\'':
626 		addr.type = getch();
627 		break;
628 	default:
629 		return 0;
630 	}
631 	if(addr.next = simpleaddr())
632 		switch(addr.next->type){
633 		case '.':
634 		case '$':
635 		case '\'':
636 			if(addr.type!='"')
637 		case '"':
638 				editerror("bad address syntax");
639 			break;
640 		case 'l':
641 		case '#':
642 			if(addr.type=='"')
643 				break;
644 			/* fall through */
645 		case '/':
646 		case '?':
647 			if(addr.type!='+' && addr.type!='-'){
648 				/* insert the missing '+' */
649 				nap = newaddr();
650 				nap->type='+';
651 				nap->next = addr.next;
652 				addr.next = nap;
653 			}
654 			break;
655 		case '+':
656 		case '-':
657 			break;
658 		default:
659 			error("simpleaddr");
660 		}
661 	ap = newaddr();
662 	*ap = addr;
663 	return ap;
664 }
665 
666 Addr *
667 compoundaddr(void)
668 {
669 	Addr addr;
670 	Addr *ap, *next;
671 
672 	addr.u.left = simpleaddr();
673 	if((addr.type = cmdskipbl())!=',' && addr.type!=';')
674 		return addr.u.left;
675 	getch();
676 	next = addr.next = compoundaddr();
677 	if(next && (next->type==',' || next->type==';') && next->u.left==0)
678 		editerror("bad address syntax");
679 	ap = newaddr();
680 	*ap = addr;
681 	return ap;
682 }