shithub: riscv

ref: 46cf9d4eb02a3a7c2516be3053994d4fb69eb949
dir: /sys/src/cmd/samterm/rasp.c/

#include <u.h>
#include <libc.h>
#include <draw.h>
#include <thread.h>
#include <mouse.h>
#include <keyboard.h>
#include <frame.h>
#include "flayer.h"
#include "samterm.h"

void
rinit(Rasp *r)
{
	r->nrunes=0;
	r->sect=0;
}

void
rclear(Rasp *r)
{
	Section *s, *ns;

	for(s=r->sect; s; s=ns){
		ns = s->next;
		free(s->text);
		free(s);
	}
	r->sect = 0;
}

Section*
rsinsert(Rasp *r, Section *s)	/* insert before s */
{
	Section *t;
	Section *u;

	t = alloc(sizeof(Section));
	if(r->sect == s){	/* includes empty list case: r->sect==s==0 */
		r->sect = t;
		t->next = s;
	}else{
		u = r->sect;
		if(u == 0)
			panic("rsinsert 1");
		do{
			if(u->next == s){
				t->next = s;
				u->next = t;
				goto Return;
			}
			u=u->next;
		}while(u);
		panic("rsinsert 2");
	}
    Return:
	return t;
}

void
rsdelete(Rasp *r, Section *s)
{
	Section *t;

	if(s == 0)
		panic("rsdelete");
	if(r->sect == s){
		r->sect = s->next;
		goto Free;
	}
	for(t=r->sect; t; t=t->next)
		if(t->next == s){
			t->next = s->next;
	Free:
			if(s->text)
				free(s->text);
			free(s);
			return;
		}
	panic("rsdelete 2");
}

void
splitsect(Rasp *r, Section *s, long n0)
{
	if(s == 0)
		panic("splitsect");
	rsinsert(r, s->next);
	if(s->text == 0)
		s->next->text = 0;
	else{
		s->next->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
		Strcpy(s->next->text, s->text+n0);
		s->text[n0] = 0;
	}
	s->next->nrunes = s->nrunes-n0;
	s->nrunes = n0;
}

Section *
findsect(Rasp *r, Section *s, long p, long q)	/* find sect containing q and put q on a sect boundary */
{
	if(s==0 && p!=q)
		panic("findsect");
	for(; s && p+s->nrunes<=q; s=s->next)
		p += s->nrunes;
	if(p != q){
		splitsect(r, s, q-p);
		s = s->next;
	}
	return s;
}

void
rresize(Rasp *r, long a, long old, long new)
{
	Section *s, *t, *ns;

	s = findsect(r, r->sect, 0L, a);
	t = findsect(r, s, a, a+old);
	for(; s!=t; s=ns){
		ns=s->next;
		rsdelete(r, s);
	}
	/* now insert the new piece before t */
	if(new > 0){
		ns=rsinsert(r, t);
		ns->nrunes=new;
		ns->text=0;
	}
	r->nrunes += new-old;
}

void
rdata(Rasp *r, long p0, long p1, Rune *cp)
{
	Section *s, *t, *ns;

	s = findsect(r, r->sect, 0L, p0);
	t = findsect(r, s, p0, p1);
	for(; s!=t; s=ns){
		ns=s->next;
		if(s->text)
			panic("rdata");
		rsdelete(r, s);
	}
	p1 -= p0;
	s = rsinsert(r, t);
	s->text = alloc(RUNESIZE*(TBLOCKSIZE+1));
	memmove(s->text, cp, RUNESIZE*p1);
	s->text[p1] = 0;
	s->nrunes = p1;
}

void
rclean(Rasp *r)
{
	Section *s;

	for(s=r->sect; s; s=s->next)
		while(s->next && (s->text!=0)==(s->next->text!=0)){
			if(s->text){
				if(s->nrunes+s->next->nrunes>TBLOCKSIZE)
					break;
				Strcpy(s->text+s->nrunes, s->next->text);
			}
			s->nrunes += s->next->nrunes;
			rsdelete(r, s->next);
		}
}

void
Strcpy(Rune *to, Rune *from)
{
	do; while(*to++ = *from++);
}

Rune*
rload(Rasp *r, ulong p0, ulong p1, ulong *nrp)
{
	Section *s;
	long p;
	int n, nb;

	nb = 0;
	Strgrow(&scratch, &nscralloc, p1-p0+1);
	scratch[0] = 0;
	for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
		p += s->nrunes;
	while(p<p1 && s){
		/*
		 * Subtle and important.  If we are preparing to handle an 'rdata'
		 * call, it's because we have an 'rresize' hole here, so the
		 * screen doesn't have data for that space anyway (it got cut
		 * first).  So pretend it isn't there.
		 */
		if(s->text){
			n = s->nrunes-(p0-p);
			if(n>p1-p0)	/* all in this section */
				n = p1-p0;
			memmove(scratch+nb, s->text+(p0-p), n*RUNESIZE);
			nb += n;
			scratch[nb] = 0;
		}
		p += s->nrunes;
		p0 = p;
		s = s->next;
	}
	if(nrp)
		*nrp = nb;
	return scratch;
}

int
rmissing(Rasp *r, ulong p0, ulong p1)
{
	Section *s;
	long p;
	int n, nm=0;

	for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
		p += s->nrunes;
	while(p<p1 && s){
		if(s->text == 0){
			n = s->nrunes-(p0-p);
			if(n > p1-p0)	/* all in this section */
				n = p1-p0;
			nm += n;
		}
		p += s->nrunes;
		p0 = p;
		s = s->next;
	}
	return nm;
}

int
rcontig(Rasp *r, ulong p0, ulong p1, int text)
{
	Section *s;
	long p, n;
	int np=0;

	for(p=0,s=r->sect; s && p+s->nrunes<=p0; s=s->next)
		p += s->nrunes;
	while(p<p1 && s && (text? (s->text!=0) : (s->text==0))){
		n = s->nrunes-(p0-p);
		if(n > p1-p0)	/* all in this section */
			n = p1-p0;
		np += n;
		p += s->nrunes;
		p0 = p;
		s = s->next;
	}
	return np;
}

void
Strgrow(Rune **s, long *n, int want)	/* can always toss the old data when called */
{
	if(*n >= want)
		return;
	free(*s);
	*s = alloc(RUNESIZE*want);
	*n = want;
}