Runestr
dirname(Text *t, Rune *r, int n)
{
Rune *b, c;
uint m, nt;
int slash;
Runestr tmp;
b = nil;
if(t==nil || t->w==nil)
goto Rescue;
nt = t->w->tag.file->b.nc;
if(nt == 0)
goto Rescue;
if(n>=1 && r[0]=='/')
goto Rescue;
b = runemalloc(nt+n+1);
bufread(&t->w->tag.file->b, 0, b, nt);
slash = -1;
for(m=0; m<nt; m++){
c = b[m];
if(c == '/')
slash = m;
if(c==' ' || c=='\t')
break;
}
if(slash < 0)
goto Rescue;
runemove(b+slash+1, r, n);
free(r);
return cleanrname(runestr(b, slash+1+n));
Rescue:
free(b);
tmp = runestr(r, n);
if(r)
return cleanrname(tmp);
return tmp;
}
Runestr
includefile(Rune *dir, Rune *file, int nfile)
{
int m, n;
char *a;
Rune *r;
static Rune Lslash[] = { '/', 0 };
m = runestrlen(dir);
a = emalloc((m+1+nfile)*UTFmax+1);
sprint(a, "%S/%.*S", dir, nfile, file);
n = access(a, 0);
free(a);
if(n < 0)
return runestr(nil, 0);
r = runemalloc(m+1+nfile);
runemove(r, dir, m);
runemove(r+m, Lslash, 1);
runemove(r+m+1, file, nfile);
free(file);
return cleanrname(runestr(r, m+1+nfile));
}
Runestr
includename(Text *t, Rune *r, int n)
{
Window *w;
char buf[128];
Rune Lsysinclude[] = { '/', 's', 'y', 's', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
Rune Lusrinclude[] = { '/', 'u', 's', 'r', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
Rune Lusrlocalinclude[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l',
'/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
Rune Lusrlocalplan9include[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l',
'/', 'p', 'l', 'a', 'n', '9', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
Runestr file;
int i;
if(objdir==nil && objtype!=nil){
sprint(buf, "/%s/include", objtype);
objdir = bytetorune(buf, &i);
objdir = runerealloc(objdir, i+1);
objdir[i] = '\0';
}
w = t->w;
if(n==0 || r[0]=='/' || w==nil)
goto Rescue;
if(n>2 && r[0]=='.' && r[1]=='/')
goto Rescue;
file.r = nil;
file.nr = 0;
for(i=0; i<w->nincl && file.r==nil; i++)
file = includefile(w->incl[i], r, n);
if(file.r == nil)
file = includefile(Lsysinclude, r, n);
if(file.r == nil)
file = includefile(Lusrlocalplan9include, r, n);
if(file.r == nil)
file = includefile(Lusrlocalinclude, r, n);
if(file.r == nil)
file = includefile(Lusrinclude, r, n);
if(file.r==nil && objdir!=nil)
file = includefile(objdir, r, n);
if(file.r == nil)
goto Rescue;
return file;
Rescue:
return runestr(r, n);
}
void
plumbshow(Plumbmsg *m)
{
Window *w;
Rune rb[256], *r;
int nb, nr;
Runestr rs;
char *name, *p, namebuf[16];
drawtopwindow();
w = makenewwindow(nil);
name = plumblookup(m->attr, "filename");
if(name == nil){
name = namebuf;
nuntitled++;
snprint(namebuf, sizeof namebuf, "Untitled-%d", nuntitled);
}
p = nil;
if(name[0]!='/' && m->wdir!=nil && m->wdir[0]!='\0'){
nb = strlen(m->wdir) + 1 + strlen(name) + 1;
p = emalloc(nb);
snprint(p, nb, "%s/%s", m->wdir, name);
name = p;
}
cvttorunes(name, strlen(name), rb, &nb, &nr, nil);
free(p);
rs = cleanrname(runestr(rb, nr));
winsetname(w, rs.r, rs.nr);
r = runemalloc(m->ndata);
cvttorunes(m->data, m->ndata, r, &nb, &nr, nil);
textinsert(&w->body, 0, r, nr, TRUE);
free(r);
w->body.file->mod = FALSE;
w->dirty = FALSE;
winsettag(w);
textscrdraw(&w->body);
textsetselect(&w->tag, w->tag.file->b.nc, w->tag.file->b.nc);
xfidlog(w, "new");
}
void
readfile(Column *c, char *s)
{
Window *w;
Rune rb[256];
int nr;
Runestr rs;
w = coladd(c, nil, nil, -1);
if(s[0] != '/')
runesnprint(rb, sizeof rb, "%s/%s", wdir, s);
else
runesnprint(rb, sizeof rb, "%s", s);
nr = runestrlen(rb);
rs = cleanrname(runestr(rb, nr));
winsetname(w, rs.r, rs.nr);
textload(&w->body, 0, s, 1);
w->body.file->mod = FALSE;
w->dirty = FALSE;
winsettag(w);
winresize(w, w->r, FALSE, TRUE);
textscrdraw(&w->body);
textsetselect(&w->tag, w->tag.file->b.nc, w->tag.file->b.nc);
}
Window*
openfile(Text *t, Expand *e)
{
Range r;
Window *w, *ow;
int eval, i, n;
Rune *rp;
Runestr rs;
uint dummy;
r.q0 = 0;
r.q1 = 0;
if(e->nname == 0){
w = t->w;
if(w == nil)
return nil;
}else{
w = lookfile(e->name, e->nname);
if(w == nil && e->name[0] != '/'){
/*
* Unrooted path in new window.
* This can happen if we type a pwd-relative path
* in the topmost tag or the column tags.
* Most of the time plumber takes care of these,
* but plumber might not be running or might not
* be configured to accept plumbed directories.
* Make the name a full path, just like we would if
* opening via the plumber.
*/
n = utflen(wdir)+1+e->nname+1;
rp = runemalloc(n);
runesnprint(rp, n, "%s/%.*S", wdir, e->nname, e->name);
rs = cleanrname(runestr(rp, n-1));
free(e->name);
e->name = rs.r;
e->nname = rs.nr;
w = lookfile(e->name, e->nname);
}
}
if(w){
t = &w->body;
if(!t->col->safe && t->fr.maxlines==0) /* window is obscured by full-column window */
colgrow(t->col, t->col->w[0], 1);
}else{
ow = nil;
if(t)
ow = t->w;
w = makenewwindow(t);
t = &w->body;
winsetname(w, e->name, e->nname);
if(textload(t, 0, e->bname, 1) >= 0)
t->file->unread = FALSE;
t->file->mod = FALSE;
t->w->dirty = FALSE;
winsettag(t->w);
textsetselect(&t->w->tag, t->w->tag.file->b.nc, t->w->tag.file->b.nc);
if(ow != nil){
for(i=ow->nincl; --i>=0; ){
n = runestrlen(ow->incl[i]);
rp = runemalloc(n);
runemove(rp, ow->incl[i], n);
winaddincl(w, rp, n);
}
w->autoindent = ow->autoindent;
}else
w->autoindent = globalautoindent;
xfidlog(w, "new");
}
if(e->a1 == e->a0)
eval = FALSE;
else{
eval = TRUE;
r = address(TRUE, t, range(-1,-1), range(t->q0, t->q1), e->u.at, e->a0, e->a1, e->agetc, &eval, &dummy);
if(r.q0 > r.q1) {
eval = FALSE;
warning(nil, "addresses out of order\n");
}
if(eval == FALSE)
e->jump = FALSE; /* don't jump if invalid address */
}
if(eval == FALSE){
r.q0 = t->q0;
r.q1 = t->q1;
}
textshow(t, r.q0, r.q1, 1);
winsettag(t->w);
seltext = t;
if(e->jump)
moveto(mousectl, addpt(frptofchar(&t->fr, t->fr.p0), Pt(4, font->height-4)));
return w;
}
Rune*
textcomplete(Text *t)
{
int i, nstr, npath;
uint q;
Rune tmp[200];
Rune *str, *path;
Rune *rp;
Completion *c;
char *s, *dirs;
Runestr dir;
/* control-f: filename completion; works back to white space or / */
if(t->q0<t->file->b.nc && textreadc(t, t->q0)>' ') /* must be at end of word */
return nil;
nstr = textfilewidth(t, t->q0, TRUE);
str = runemalloc(nstr);
npath = textfilewidth(t, t->q0-nstr, FALSE);
path = runemalloc(npath);
c = nil;
rp = nil;
dirs = nil;
q = t->q0-nstr;
for(i=0; i<nstr; i++)
str[i] = textreadc(t, q++);
q = t->q0-nstr-npath;
for(i=0; i<npath; i++)
path[i] = textreadc(t, q++);
/* is path rooted? if not, we need to make it relative to window path */
if(npath>0 && path[0]=='/')
dir = runestr(path, npath);
else{
dir = dirname(t, nil, 0);
if(dir.nr + 1 + npath > nelem(tmp)){
free(dir.r);
goto Return;
}
if(dir.nr == 0){
dir.nr = 1;
dir.r = runestrdup(Ldot);
}
runemove(tmp, dir.r, dir.nr);
tmp[dir.nr] = '/';
runemove(tmp+dir.nr+1, path, npath);
free(dir.r);
dir.r = tmp;
dir.nr += 1+npath;
dir = cleanrname(dir);
}
s = smprint("%.*S", nstr, str);
dirs = smprint("%.*S", dir.nr, dir.r);
c = complete(dirs, s);
free(s);
if(c == nil){
warning(nil, "error attempting completion: %r\n");
goto Return;
}
if(!c->advance){
warning(nil, "%.*S%s%.*S*%s\n",
dir.nr, dir.r,
dir.nr>0 && dir.r[dir.nr-1]!='/' ? "/" : "",
nstr, str,
c->nmatch ? "" : ": no matches in:");
for(i=0; i<c->nfile; i++)
warning(nil, " %s\n", c->filename[i]);
}
if(c->advance)
rp = runesmprint("%s", c->string);
else
rp = nil;
Return:
freecompletion(c);
free(dirs);
free(str);
free(path);
return rp;
}
