nilix/acme9k
1
0
Fork 0
mirror of https://hacklab.nilfm.cc/acme synced 2024-10-22 14:31:48 +00:00
Code Issues 1 Projects Releases Packages Wiki Activity

add gitignore, clang-format, build script; merge src's patch for spaces in filenames

Browse source
This commit is contained in:
Iris Lightshard 2021-06-12 23:54:54 -06:00
parent cf57dbe235
commit 5540d37849
Signed by: nilix
GPG key ID: 3B7FBC22144E6398
38 changed files with 15300 additions and 15770 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
.clang-format Normal file
View file

@ -0,0 +1,23 @@
TabWidth: 2
IndentWidth: 2
ContinuationIndentWidth: 2
UseTab: Never
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortEnumsOnASingleLine: true
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
PenaltyReturnTypeOnItsOwnLine: 255
IndentCaseLabels: true
SpaceBeforeParens: ControlStatements
AlignAfterOpenBracket: AlwaysBreak
BinPackArguments: false
BinPackArguments: false
PointerAlignment: Left
BreakBeforeBraces: Attach
SortIncludes: false
AllowAllArgumentsOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AlignEscapedNewlines: Left

1
.gitignore vendored
View file

@ -1,2 +1,3 @@
**/*.o
**/o.*
acme

679
acme.c
View file

File diff suppressed because it is too large Load diff

196
addr.c
View file

@ -12,39 +12,27 @@
#include "dat.h"
#include "fns.h"
enum
{
None = 0,
Fore = '+',
Back = '-'
};
enum { None = 0, Fore = '+', Back = '-' };
enum
{
Char,
Line
};
enum { Char, Line };
int
isaddrc(int r)
{
if(r && utfrune("0123456789+-/$.#,;?", r)!=nil)
int isaddrc(int r) {
if (r && utfrune("0123456789+-/$.#,;?", r) != nil)
return TRUE;
return FALSE;
}
/*
* quite hard: could be almost anything but white space, but we are a little conservative,
* aiming for regular expressions of alphanumerics and no white space
* quite hard: could be almost anything but white space, but we are a little
* conservative, aiming for regular expressions of alphanumerics and no white
* space
*/
int
isregexc(int r)
{
if(r == 0)
int isregexc(int r) {
if (r == 0)
return FALSE;
if(isalnum(r))
if (isalnum(r))
return TRUE;
if(utfrune("^+-.*?#,;[]()$", r)!=nil)
if (utfrune("^+-.*?#,;[]()$", r) != nil)
return TRUE;
return FALSE;
}
@ -54,130 +42,125 @@ isregexc(int r)
// and then nr chars, being careful not to walk past
// the end of the current line.
// It returns the final position.
long
nlcounttopos(Text *t, long q0, long nl, long nr)
{
while(nl > 0 && q0 < t->file->b.nc) {
if(textreadc(t, q0++) == '\n')
long nlcounttopos(Text* t, long q0, long nl, long nr) {
while (nl > 0 && q0 < t->file->b.nc) {
if (textreadc(t, q0++) == '\n')
nl--;
}
if(nl > 0)
if (nl > 0)
return q0;
while(nr > 0 && q0 < t->file->b.nc && textreadc(t, q0) != '\n') {
while (nr > 0 && q0 < t->file->b.nc && textreadc(t, q0) != '\n') {
q0++;
nr--;
}
return q0;
}
Range
number(uint showerr, Text *t, Range r, int line, int dir, int size, int *evalp)
{
Range number(
uint showerr, Text* t, Range r, int line, int dir, int size, int* evalp) {
uint q0, q1;
if(size == Char){
if(dir == Fore)
line = r.q1+line;
else if(dir == Back){
if(r.q0==0 && line>0)
if (size == Char) {
if (dir == Fore)
line = r.q1 + line;
else if (dir == Back) {
if (r.q0 == 0 && line > 0)
r.q0 = t->file->b.nc;
line = r.q0 - line;
}
if(line<0 || line>t->file->b.nc)
if (line < 0 || line > t->file->b.nc)
goto Rescue;
*evalp = TRUE;
return range(line, line);
}
q0 = r.q0;
q1 = r.q1;
switch(dir){
switch (dir) {
case None:
q0 = 0;
q1 = 0;
Forward:
while(line>0 && q1<t->file->b.nc)
if(textreadc(t, q1++) == '\n' || q1==t->file->b.nc)
if(--line > 0)
while (line > 0 && q1 < t->file->b.nc)
if (textreadc(t, q1++) == '\n' || q1 == t->file->b.nc)
if (--line > 0)
q0 = q1;
if(line==1 && q1==t->file->b.nc) // 6 goes to end of 5-line file
if (line == 1 && q1 == t->file->b.nc) // 6 goes to end of 5-line file
break;
if(line > 0)
if (line > 0)
goto Rescue;
break;
case Fore:
if(q1 > 0)
while(q1<t->file->b.nc && textreadc(t, q1-1) != '\n')
if (q1 > 0)
while (q1 < t->file->b.nc && textreadc(t, q1 - 1) != '\n')
q1++;
q0 = q1;
goto Forward;
case Back:
if(q0 < t->file->b.nc)
while(q0>0 && textreadc(t, q0-1)!='\n')
if (q0 < t->file->b.nc)
while (q0 > 0 && textreadc(t, q0 - 1) != '\n')
q0--;
q1 = q0;
while(line>0 && q0>0){
if(textreadc(t, q0-1) == '\n'){
if(--line >= 0)
while (line > 0 && q0 > 0) {
if (textreadc(t, q0 - 1) == '\n') {
if (--line >= 0)
q1 = q0;
}
--q0;
}
/* :1-1 is :0 = #0, but :1-2 is an error */
if(line > 1)
if (line > 1)
goto Rescue;
while(q0>0 && textreadc(t, q0-1)!='\n')
while (q0 > 0 && textreadc(t, q0 - 1) != '\n')
--q0;
}
*evalp = TRUE;
return range(q0, q1);
Rescue:
if(showerr)
Rescue:
if (showerr)
warning(nil, "address out of range\n");
*evalp = FALSE;
return r;
}
Range
regexp(uint showerr, Text *t, Range lim, Range r, Rune *pat, int dir, int *foundp)
{
Range regexp(
uint showerr, Text* t, Range lim, Range r, Rune* pat, int dir, int* foundp) {
int found;
Rangeset sel;
int q;
if(pat[0] == '\0' && rxnull()){
if(showerr)
if (pat[0] == '\0' && rxnull()) {
if (showerr)
warning(nil, "no previous regular expression\n");
*foundp = FALSE;
return r;
}
if(pat[0] && rxcompile(pat) == FALSE){
if (pat[0] && rxcompile(pat) == FALSE) {
*foundp = FALSE;
return r;
}
if(dir == Back)
if (dir == Back)
found = rxbexecute(t, r.q0, &sel);
else{
if(lim.q0 < 0)
else {
if (lim.q0 < 0)
q = Infinity;
else
q = lim.q1;
found = rxexecute(t, nil, r.q1, q, &sel);
}
if(!found && showerr)
if (!found && showerr)
warning(nil, "no match for regexp\n");
*foundp = found;
return sel.r[0];
}
Range
address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, int (*getc)(void*, uint), int *evalp, uint *qp)
{
Range address(
uint showerr, Text* t, Range lim, Range ar, void* a, uint q0, uint q1,
int (*getc)(void*, uint), int* evalp, uint* qp) {
int dir, size, npat;
int prevc, c, nc, n;
uint q;
Rune *pat;
Rune* pat;
Range r, nr;
r = ar;
@ -185,22 +168,22 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
dir = None;
size = Line;
c = 0;
while(q < q1){
while (q < q1) {
prevc = c;
c = (*getc)(a, q++);
switch(c){
switch (c) {
default:
*qp = q-1;
*qp = q - 1;
return r;
case ';':
ar = r;
/* fall through */
case ',':
if(prevc == 0) /* lhs defaults to 0 */
if (prevc == 0) /* lhs defaults to 0 */
r.q0 = 0;
if(q>=q1 && t!=nil && t->file!=nil) /* rhs defaults to $ */
if (q >= q1 && t != nil && t->file != nil) /* rhs defaults to $ */
r.q1 = t->file->b.nc;
else{
else {
nr = address(showerr, t, lim, ar, a, q, q1, getc, evalp, &q);
r.q1 = nr.q1;
}
@ -208,46 +191,55 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
return r;
case '+':
case '-':
if(*evalp && (prevc=='+' || prevc=='-'))
if((nc=(*getc)(a, q))!='#' && nc!='/' && nc!='?')
r = number(showerr, t, r, 1, prevc, Line, evalp); /* do previous one */
if (*evalp && (prevc == '+' || prevc == '-'))
if ((nc = (*getc)(a, q)) != '#' && nc != '/' && nc != '?')
r = number(showerr, t, r, 1, prevc, Line, evalp); /* do previous one
*/
dir = c;
break;
case '.':
case '$':
if(q != q0+1){
*qp = q-1;
if (q != q0 + 1) {
*qp = q - 1;
return r;
}
if(*evalp)
if(c == '.')
if (*evalp)
if (c == '.')
r = ar;
else
r = range(t->file->b.nc, t->file->b.nc);
if(q < q1)
if (q < q1)
dir = Fore;
else
dir = None;
break;
case '#':
if(q==q1 || (c=(*getc)(a, q++))<'0' || '9'<c){
*qp = q-1;
if (q == q1 || (c = (*getc)(a, q++)) < '0' || '9' < c) {
*qp = q - 1;
return r;
}
size = Char;
/* fall through */
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = c -'0';
while(q<q1){
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
n = c - '0';
while (q < q1) {
nc = (*getc)(a, q++);
if(nc<'0' || '9'<nc){
if (nc < '0' || '9' < nc) {
q--;
break;
}
n = n*10+(nc-'0');
n = n * 10 + (nc - '0');
}
if(*evalp)
if (*evalp)
r = number(showerr, t, r, n, dir, size, evalp);
dir = None;
size = Line;
@ -258,29 +250,29 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
case '/':
npat = 0;
pat = nil;
while(q<q1){
while (q < q1) {
c = (*getc)(a, q++);
switch(c){
switch (c) {
case '\n':
--q;
goto out;
case '\\':
pat = runerealloc(pat, npat+1);
pat = runerealloc(pat, npat + 1);
pat[npat++] = c;
if(q == q1)
if (q == q1)
goto out;
c = (*getc)(a, q++);
break;
case '/':
goto out;
}
pat = runerealloc(pat, npat+1);
pat = runerealloc(pat, npat + 1);
pat[npat++] = c;
}
out:
pat = runerealloc(pat, npat+1);
pat = runerealloc(pat, npat + 1);
pat[npat] = 0;
if(*evalp)
if (*evalp)
r = regexp(showerr, t, lim, r, pat, dir, evalp);
free(pat);
dir = None;
@ -288,7 +280,7 @@ address(uint showerr, Text *t, Range lim, Range ar, void *a, uint q0, uint q1, i
break;
}
}
if(*evalp && dir != None)
if (*evalp && dir != None)
r = number(showerr, t, r, 1, dir, Line, evalp); /* do previous one */
*qp = q;
return r;

194
buff.c
View file

@ -12,47 +12,37 @@
#include "dat.h"
#include "fns.h"
enum
{
enum {
Slop = 100 /* room to grow with reallocation */
};
static
void
sizecache(Buffer *b, uint n)
{
if(n <= b->cmax)
static void sizecache(Buffer* b, uint n) {
if (n <= b->cmax)
return;
b->cmax = n+Slop;
b->cmax = n + Slop;
b->c = runerealloc(b->c, b->cmax);
}
static
void
addblock(Buffer *b, uint i, uint n)
{
if(i > b->nbl)
static void addblock(Buffer* b, uint i, uint n) {
if (i > b->nbl)
error("internal error: addblock");
b->bl = realloc(b->bl, (b->nbl+1)*sizeof b->bl[0]);
if(i < b->nbl)
memmove(b->bl+i+1, b->bl+i, (b->nbl-i)*sizeof(Block*));
b->bl = realloc(b->bl, (b->nbl + 1) * sizeof b->bl[0]);
if (i < b->nbl)
memmove(b->bl + i + 1, b->bl + i, (b->nbl - i) * sizeof(Block*));
b->bl[i] = disknewblock(disk, n);
b->nbl++;
}
static
void
delblock(Buffer *b, uint i)
{
if(i >= b->nbl)
static void delblock(Buffer* b, uint i) {
if (i >= b->nbl)
error("internal error: delblock");
diskrelease(disk, b->bl[i]);
b->nbl--;
if(i < b->nbl)
memmove(b->bl+i, b->bl+i+1, (b->nbl-i)*sizeof(Block*));
b->bl = realloc(b->bl, b->nbl*sizeof b->bl[0]);
if (i < b->nbl)
memmove(b->bl + i, b->bl + i + 1, (b->nbl - i) * sizeof(Block*));
b->bl = realloc(b->bl, b->nbl * sizeof b->bl[0]);
}
/*
@ -60,12 +50,9 @@ delblock(Buffer *b, uint i)
* If at very end, q0 will fall on end of cache block.
*/
static
void
flush(Buffer *b)
{
if(b->cdirty || b->cnc==0){
if(b->cnc == 0)
static void flush(Buffer* b) {
if (b->cdirty || b->cnc == 0) {
if (b->cnc == 0)
delblock(b, b->cbi);
else
diskwrite(disk, &b->bl[b->cbi], b->c, b->cnc);
@ -73,40 +60,37 @@ flush(Buffer *b)
}
}
static
void
setcache(Buffer *b, uint q0)
{
static void setcache(Buffer* b, uint q0) {
Block **blp, *bl;
uint i, q;
if(q0 > b->nc)
if (q0 > b->nc)
error("internal error: setcache");
/*
* flush and reload if q0 is not in cache.
*/
if(b->nc == 0 || (b->cq<=q0 && q0<b->cq+b->cnc))
if (b->nc == 0 || (b->cq <= q0 && q0 < b->cq + b->cnc))
return;
/*
* if q0 is at end of file and end of cache, continue to grow this block
*/
if(q0==b->nc && q0==b->cq+b->cnc && b->cnc<Maxblock)
if (q0 == b->nc && q0 == b->cq + b->cnc && b->cnc < Maxblock)
return;
flush(b);
/* find block */
if(q0 < b->cq){
if (q0 < b->cq) {
q = 0;
i = 0;
}else{
} else {
q = b->cq;
i = b->cbi;
}
blp = &b->bl[i];
while(q+(*blp)->u.n <= q0 && q+(*blp)->u.n < b->nc){
while (q + (*blp)->u.n <= q0 && q + (*blp)->u.n < b->nc) {
q += (*blp)->u.n;
i++;
blp++;
if(i >= b->nbl)
if (i >= b->nbl)
error("block not found");
}
bl = *blp;
@ -119,30 +103,28 @@ setcache(Buffer *b, uint q0)
diskread(disk, bl, b->c, b->cnc);
}
void
bufinsert(Buffer *b, uint q0, Rune *s, uint n)
{
void bufinsert(Buffer* b, uint q0, Rune* s, uint n) {
uint i, m, t, off;
if(q0 > b->nc)
if (q0 > b->nc)
error("internal error: bufinsert");
while(n > 0){
while (n > 0) {
setcache(b, q0);
off = q0-b->cq;
if(b->cnc+n <= Maxblock){
off = q0 - b->cq;
if (b->cnc + n <= Maxblock) {
/* Everything fits in one block. */
t = b->cnc+n;
t = b->cnc + n;
m = n;
if(b->bl == nil){ /* allocate */
if(b->cnc != 0)
if (b->bl == nil) { /* allocate */
if (b->cnc != 0)
error("internal error: bufinsert1 cnc!=0");
addblock(b, 0, t);
b->cbi = 0;
}
sizecache(b, t);
runemove(b->c+off+m, b->c+off, b->cnc-off);
runemove(b->c+off, s, m);
runemove(b->c + off + m, b->c + off, b->cnc - off);
runemove(b->c + off, s, m);
b->cnc = t;
goto Tail;
}
@ -151,17 +133,17 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
* the very beginning or end of this block,
* just make a new block and fill it.
*/
if(q0==b->cq || q0==b->cq+b->cnc){
if(b->cdirty)
if (q0 == b->cq || q0 == b->cq + b->cnc) {
if (b->cdirty)
flush(b);
m = min(n, Maxblock);
if(b->bl == nil){ /* allocate */
if(b->cnc != 0)
if (b->bl == nil) { /* allocate */
if (b->cnc != 0)
error("internal error: bufinsert2 cnc!=0");
i = 0;
}else{
} else {
i = b->cbi;
if(q0 > b->cq)
if (q0 > b->cq)
i++;
}
addblock(b, i, m);
@ -176,20 +158,20 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
* Split the block; cut off the right side and
* let go of it.
*/
m = b->cnc-off;
if(m > 0){
i = b->cbi+1;
m = b->cnc - off;
if (m > 0) {
i = b->cbi + 1;
addblock(b, i, m);
diskwrite(disk, &b->bl[i], b->c+off, m);
diskwrite(disk, &b->bl[i], b->c + off, m);
b->cnc -= m;
}
/*
* Now at end of block. Take as much input
* as possible and tack it on end of block.
*/
m = min(n, Maxblock-b->cnc);
sizecache(b, b->cnc+m);
runemove(b->c+b->cnc, s, m);
m = min(n, Maxblock - b->cnc);
sizecache(b, b->cnc + m);
runemove(b->c + b->cnc, s, m);
b->cnc += m;
Tail:
b->nc += m;
@ -200,23 +182,21 @@ bufinsert(Buffer *b, uint q0, Rune *s, uint n)
}
}
void
bufdelete(Buffer *b, uint q0, uint q1)
{
void bufdelete(Buffer* b, uint q0, uint q1) {
uint m, n, off;
if(!(q0<=q1 && q0<=b->nc && q1<=b->nc))
if (!(q0 <= q1 && q0 <= b->nc && q1 <= b->nc))
error("internal error: bufdelete");
while(q1 > q0){
while (q1 > q0) {
setcache(b, q0);
off = q0-b->cq;
if(q1 > b->cq+b->cnc)
off = q0 - b->cq;
if (q1 > b->cq + b->cnc)
n = b->cnc - off;
else
n = q1-q0;
m = b->cnc - (off+n);
if(m > 0)
runemove(b->c+off, b->c+off+n, m);
n = q1 - q0;
m = b->cnc - (off + n);
if (m > 0)
runemove(b->c + off, b->c + off + n, m);
b->cnc -= n;
b->cdirty = TRUE;
q1 -= n;
@ -224,22 +204,20 @@ bufdelete(Buffer *b, uint q0, uint q1)
}
}
static int
bufloader(void *v, uint q0, Rune *r, int nr)
{
static int bufloader(void* v, uint q0, Rune* r, int nr) {
bufinsert(v, q0, r, nr);
return nr;
}
uint
loadfile(int fd, uint q0, int *nulls, int(*f)(void*, uint, Rune*, int), void *arg, DigestState *h)
{
char *p;
Rune *r;
uint loadfile(
int fd, uint q0, int* nulls, int (*f)(void*, uint, Rune*, int), void* arg,
DigestState* h) {
char* p;
Rune* r;
int l, m, n, nb, nr;
uint q1;
p = emalloc((Maxblock+UTFmax+1)*sizeof p[0]);
p = emalloc((Maxblock + UTFmax + 1) * sizeof p[0]);
r = runemalloc(Maxblock);
m = 0;
n = 1;
@ -248,58 +226,52 @@ loadfile(int fd, uint q0, int *nulls, int(*f)(void*, uint, Rune*, int), void *ar
* At top of loop, may have m bytes left over from
* last pass, possibly representing a partial rune.
*/
while(n > 0){
n = read(fd, p+m, Maxblock);
if(n < 0){
while (n > 0) {
n = read(fd, p + m, Maxblock);
if (n < 0) {
warning(nil, "read error in Buffer.load");
break;
}
if(h != nil)
sha1((uchar*)p+m, n, nil, h);
if (h != nil)
sha1((uchar*)p + m, n, nil, h);
m += n;
p[m] = 0;
l = m;
if(n > 0)
if (n > 0)
l -= UTFmax;
cvttorunes(p, l, r, &nb, &nr, nulls);
memmove(p, p+nb, m-nb);
memmove(p, p + nb, m - nb);
m -= nb;
q1 += (*f)(arg, q1, r, nr);
}
free(p);
free(r);
return q1-q0;
return q1 - q0;
}
uint
bufload(Buffer *b, uint q0, int fd, int *nulls, DigestState *h)
{
if(q0 > b->nc)
uint bufload(Buffer* b, uint q0, int fd, int* nulls, DigestState* h) {
if (q0 > b->nc)
error("internal error: bufload");
return loadfile(fd, q0, nulls, bufloader, b, h);
}
void
bufread(Buffer *b, uint q0, Rune *s, uint n)
{
void bufread(Buffer* b, uint q0, Rune* s, uint n) {
uint m;
if(!(q0<=b->nc && q0+n<=b->nc))
if (!(q0 <= b->nc && q0 + n <= b->nc))
error("bufread: internal error");
while(n > 0){
while (n > 0) {
setcache(b, q0);
m = min(n, b->cnc-(q0-b->cq));
runemove(s, b->c+(q0-b->cq), m);
m = min(n, b->cnc - (q0 - b->cq));
runemove(s, b->c + (q0 - b->cq), m);
q0 += m;
s += m;
n -= m;
}
}
void
bufreset(Buffer *b)
{
void bufreset(Buffer* b) {
int i;
b->nc = 0;
@ -308,13 +280,11 @@ bufreset(Buffer *b)
b->cdirty = 0;
b->cbi = 0;
/* delete backwards to avoid n² behavior */
for(i=b->nbl-1; --i>=0; )
for (i = b->nbl - 1; --i >= 0;)
delblock(b, i);
}
void
bufclose(Buffer *b)
{
void bufclose(Buffer* b) {
bufreset(b);
free(b->c);
b->c = nil;

8
build.sh Executable file
View file

@ -0,0 +1,8 @@
#!/bin/sh
clang-format -i ./*.c
clang-format -i ./mail/*.c
mk
mv o.acme acme

433
cols.c
View file

@ -12,24 +12,21 @@
#include "dat.h"
#include "fns.h"
static Rune Lheader[] = {
'N', 'e', 'w', ' ',
'C', 'u', 't', ' ',
'P', 'a', 's', 't', 'e', ' ',
'S', 'n', 'a', 'r', 'f', ' ',
'S', 'o', 'r', 't', ' ',
'Z', 'e', 'r', 'o', 'x', ' ',
'D', 'e', 'l', 'c', 'o', 'l', ' ',
0
};
static Rune Lheader[] = {'N', 'e', 'w', ' ', 'C', 'u', 't', ' ', 'P', 'a',
's', 't', 'e', ' ', 'S', 'n', 'a', 'r', 'f', ' ',
'S', 'o', 'r', 't', ' ', 'Z', 'e', 'r', 'o', 'x',
' ', 'D', 'e', 'l', 'c', 'o', 'l', ' ', 0};
void
colinit(Column *c, Rectangle r)
{
void colinit(Column* c, Rectangle r) {
Rectangle r1;
Text *t;
Text* t;
draw(screen, r, allocimage(display,Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
c->r = r;
c->w = nil;
c->nw = 0;
@ -42,44 +39,47 @@ colinit(Column *c, Rectangle r)
t->what = Columntag;
r1.min.y = r1.max.y;
r1.max.y += Border;
draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
draw(
screen,
r1,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
textinsert(t, 0, Lheader, 38, TRUE);
textsetselect(t, t->file->b.nc, t->file->b.nc);
draw(screen, t->scrollr, colbutton, nil, colbutton->r.min);
c->safe = TRUE;
}
Window*
coladd(Column *c, Window *w, Window *clone, int y)
{
Window* coladd(Column* c, Window* w, Window* clone, int y) {
Rectangle r, r1;
Window *v;
Window* v;
int i, j, minht, ymax, buggered;
v = nil;
r = c->r;
r.min.y = c->tag.fr.r.max.y+Border;
if(y<r.min.y && c->nw>0){ /* steal half of last window by default */
v = c->w[c->nw-1];
y = v->body.fr.r.min.y+Dy(v->body.fr.r)/2;
r.min.y = c->tag.fr.r.max.y + Border;
if (y < r.min.y && c->nw > 0) { /* steal half of last window by default */
v = c->w[c->nw - 1];
y = v->body.fr.r.min.y + Dy(v->body.fr.r) / 2;
}
/* look for window we'll land on */
for(i=0; i<c->nw; i++){
for (i = 0; i < c->nw; i++) {
v = c->w[i];
if(y < v->r.max.y)
if (y < v->r.max.y)
break;
}
buggered = 0;
if(c->nw > 0){
if(i < c->nw)
if (c->nw > 0) {
if (i < c->nw)
i++; /* new window will go after v */
/*
* if landing window (v) is too small, grow it first.
*/
minht = v->tag.fr.font->height+Border+1;
minht = v->tag.fr.font->height + Border + 1;
j = 0;
while(!c->safe || v->body.fr.maxlines<=3 || Dy(v->body.all) <= minht){
if(++j > 10){
while (!c->safe || v->body.fr.maxlines <= 3 || Dy(v->body.all) <= minht) {
if (++j > 10) {
buggered = 1; /* too many windows in column */
break;
}
@ -91,19 +91,19 @@ coladd(Column *c, Window *w, Window *clone, int y)
*/
/* new window stops where next window begins */
if(i < c->nw)
ymax = c->w[i]->r.min.y-Border;
if (i < c->nw)
ymax = c->w[i]->r.min.y - Border;
else
ymax = c->r.max.y;
/* new window must start after v's tag ends */
y = max(y, v->tagtop.max.y+Border);
y = max(y, v->tagtop.max.y + Border);
/* new window must start early enough to end before ymax */
y = min(y, ymax - minht);
/* if y is too small, too many windows in column */
if(y < v->tagtop.max.y+Border)
if (y < v->tagtop.max.y + Border)
buggered = 1;
/*
@ -113,23 +113,32 @@ coladd(Column *c, Window *w, Window *clone, int y)
r.max.y = ymax;
draw(screen, r, textcols[BACK], nil, ZP);
r1 = r;
y = min(y, ymax-(v->tag.fr.font->height*v->taglines+v->body.fr.font->height+Border+1));
r1.max.y = min(y, v->body.fr.r.min.y+v->body.fr.nlines*v->body.fr.font->height);
y = min(
y,
ymax - (v->tag.fr.font->height * v->taglines + v->body.fr.font->height +
Border + 1));
r1.max.y =
min(y, v->body.fr.r.min.y + v->body.fr.nlines * v->body.fr.font->height);
r1.min.y = winresize(v, r1, FALSE, FALSE);
r1.max.y = r1.min.y+Border;
draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
r1.max.y = r1.min.y + Border;
draw(
screen,
r1,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
/*
* leave r with w's coordinates
*/
r.min.y = r1.max.y;
}
if(w == nil){
if (w == nil) {
w = emalloc(sizeof(Window));
w->col = c;
draw(screen, r, textcols[BACK], nil, ZP);
wininit(w, clone, r);
}else{
} else {
w->col = c;
winresize(w, r, FALSE, TRUE);
}
@ -137,14 +146,14 @@ coladd(Column *c, Window *w, Window *clone, int y)
w->tag.row = c->row;
w->body.col = c;
w->body.row = c->row;
c->w = realloc(c->w, (c->nw+1)*sizeof(Window*));
memmove(c->w+i+1, c->w+i, (c->nw-i)*sizeof(Window*));
c->w = realloc(c->w, (c->nw + 1) * sizeof(Window*));
memmove(c->w + i + 1, c->w + i, (c->nw - i) * sizeof(Window*));
c->nw++;
c->w[i] = w;
c->safe = TRUE;
/* if there were too many windows, redraw the whole column */
if(buggered)
if (buggered)
colresize(c, c->r);
savemouse(w);
@ -154,66 +163,67 @@ coladd(Column *c, Window *w, Window *clone, int y)
return w;
}
void
colclose(Column *c, Window *w, int dofree)
{
void colclose(Column* c, Window* w, int dofree) {
Rectangle r;
int i, didmouse, up;
/* w is locked */
if(!c->safe)
if (!c->safe)
colgrow(c, w, 1);
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
for (i = 0; i < c->nw; i++)
if (c->w[i] == w)
goto Found;
error("can't find window");
Found:
Found:
r = w->r;
w->tag.col = nil;
w->body.col = nil;
w->col = nil;
didmouse = restoremouse(w);
if(dofree){
if (dofree) {
windelete(w);
winclose(w);
}
c->nw--;
memmove(c->w+i, c->w+i+1, (c->nw-i)*sizeof(Window*));
c->w = realloc(c->w, c->nw*sizeof(Window*));
if(c->nw == 0){
draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
memmove(c->w + i, c->w + i + 1, (c->nw - i) * sizeof(Window*));
c->w = realloc(c->w, c->nw * sizeof(Window*));
if (c->nw == 0) {
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
return;
}
up = 0;
if(i == c->nw){ /* extend last window down */
w = c->w[i-1];
if (i == c->nw) { /* extend last window down */
w = c->w[i - 1];
r.min.y = w->r.min.y;
r.max.y = c->r.max.y;
}else{ /* extend next window up */
} else { /* extend next window up */
up = 1;
w = c->w[i];
r.max.y = w->r.max.y;
}
draw(screen, r, textcols[BACK], nil, ZP);
if(c->safe) {
if(!didmouse && up)
if (c->safe) {
if (!didmouse && up)
w->showdel = TRUE;
winresize(w, r, FALSE, TRUE);
if(!didmouse && up)
if (!didmouse && up)
movetodel(w);
}
}
void
colcloseall(Column *c)
{
void colcloseall(Column* c) {
int i;
Window *w;
Window* w;
if(c == activecol)
if (c == activecol)
activecol = nil;
textclose(&c->tag);
for(i=0; i<c->nw; i++){
for (i = 0; i < c->nw; i++) {
w = c->w[i];
winclose(w);
}
@ -223,18 +233,14 @@ colcloseall(Column *c)
clearmouse();
}
void
colmousebut(Column *c)
{
void colmousebut(Column* c) {
moveto(mousectl, divpt(addpt(c->tag.scrollr.min, c->tag.scrollr.max), 2));
}
void
colresize(Column *c, Rectangle r)
{
void colresize(Column* c, Rectangle r) {
int i;
Rectangle r1, r2;
Window *w;
Window* w;
clearmouse();
r1 = r;
@ -243,33 +249,40 @@ colresize(Column *c, Rectangle r)
draw(screen, c->tag.scrollr, colbutton, nil, colbutton->r.min);
r1.min.y = r1.max.y;
r1.max.y += Border;
draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
draw(
screen,
r1,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
r1.max.y = r.max.y;
for(i=0; i<c->nw; i++){
for (i = 0; i < c->nw; i++) {
w = c->w[i];
w->maxlines = 0;
if(i == c->nw-1)
if (i == c->nw - 1)
r1.max.y = r.max.y;
else{
else {
r1.max.y = r1.min.y;
if(Dy(c->r) != 0){
r1.max.y += (Dy(w->r)+Border)*Dy(r)/Dy(c->r);
if (Dy(c->r) != 0) {
r1.max.y += (Dy(w->r) + Border) * Dy(r) / Dy(c->r);
}
}
r1.max.y = max(r1.max.y, r1.min.y + Border+font->height);
r1.max.y = max(r1.max.y, r1.min.y + Border + font->height);
r2 = r1;
r2.max.y = r2.min.y+Border;
draw(screen, r2, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
r2.max.y = r2.min.y + Border;
draw(
screen,
r2,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
r1.min.y = r2.max.y;
r1.min.y = winresize(w, r1, FALSE, i==c->nw-1);
r1.min.y = winresize(w, r1, FALSE, i == c->nw - 1);
}
c->r = r;
}
static
int
colcmp(const void *a, const void *b)
{
static int colcmp(const void* a, const void* b) {
Rune *r1, *r2;
int i, nr1, nr2;
@ -277,86 +290,87 @@ colcmp(const void *a, const void *b)
nr1 = (*(Window**)a)->body.file->nname;
r2 = (*(Window**)b)->body.file->name;
nr2 = (*(Window**)b)->body.file->nname;
for(i=0; i<nr1 && i<nr2; i++){
if(*r1 != *r2)
return *r1-*r2;
for (i = 0; i < nr1 && i < nr2; i++) {
if (*r1 != *r2)
return *r1 - *r2;
r1++;
r2++;
}
return nr1-nr2;
return nr1 - nr2;
}
void
colsort(Column *c)
{
void colsort(Column* c) {
int i, y;
Rectangle r, r1, *rp;
Window **wp, *w;
if(c->nw == 0)
if (c->nw == 0)
return;
clearmouse();
rp = emalloc(c->nw*sizeof(Rectangle));
wp = emalloc(c->nw*sizeof(Window*));
memmove(wp, c->w, c->nw*sizeof(Window*));
rp = emalloc(c->nw * sizeof(Rectangle));
wp = emalloc(c->nw * sizeof(Window*));
memmove(wp, c->w, c->nw * sizeof(Window*));
qsort(wp, c->nw, sizeof(Window*), colcmp);
for(i=0; i<c->nw; i++)
for (i = 0; i < c->nw; i++)
rp[i] = wp[i]->r;
r = c->r;
r.min.y = c->tag.fr.r.max.y;
draw(screen, r, textcols[BACK], nil, ZP);
y = r.min.y;
for(i=0; i<c->nw; i++){
for (i = 0; i < c->nw; i++) {
w = wp[i];
r.min.y = y;
if(i == c->nw-1)
if (i == c->nw - 1)
r.max.y = c->r.max.y;
else
r.max.y = r.min.y+Dy(w->r)+Border;
r.max.y = r.min.y + Dy(w->r) + Border;
r1 = r;
r1.max.y = r1.min.y+Border;
draw(screen, r1, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
r1.max.y = r1.min.y + Border;
draw(
screen,
r1,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
r.min.y = r1.max.y;
y = winresize(w, r, FALSE, i==c->nw-1);
y = winresize(w, r, FALSE, i == c->nw - 1);
}
free(rp);
free(c->w);
c->w = wp;
}
void
colgrow(Column *c, Window *w, int but)
{
void colgrow(Column* c, Window* w, int but) {
Rectangle r, cr;
int i, j, k, l, y1, y2, *nl, *ny, tot, nnl, onl, dnl, h;
Window *v;
Window* v;
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
for (i = 0; i < c->nw; i++)
if (c->w[i] == w)
goto Found;
error("can't find window");
Found:
Found:
cr = c->r;
if(but < 0){ /* make sure window fills its own space properly */
if (but < 0) { /* make sure window fills its own space properly */
r = w->r;
if(i==c->nw-1 || c->safe==FALSE)
if (i == c->nw - 1 || c->safe == FALSE)
r.max.y = cr.max.y;
else
r.max.y = c->w[i+1]->r.min.y - Border;
r.max.y = c->w[i + 1]->r.min.y - Border;
winresize(w, r, FALSE, TRUE);
return;
}
cr.min.y = c->w[0]->r.min.y;
if(but == 3){ /* full size */
if(i != 0){
if (but == 3) { /* full size */
if (i != 0) {
v = c->w[0];
c->w[0] = w;
c->w[i] = v;
}
draw(screen, cr, textcols[BACK], nil, ZP);
winresize(w, cr, FALSE, TRUE);
for(i=1; i<c->nw; i++)
for (i = 1; i < c->nw; i++)
c->w[i]->body.fr.maxlines = 0;
c->safe = FALSE;
return;
@ -366,64 +380,69 @@ colgrow(Column *c, Window *w, int but)
nl = emalloc(c->nw * sizeof(int));
ny = emalloc(c->nw * sizeof(int));
tot = 0;
for(j=0; j<c->nw; j++){
l = c->w[j]->taglines-1 + c->w[j]->body.fr.maxlines;
for (j = 0; j < c->nw; j++) {
l = c->w[j]->taglines - 1 + c->w[j]->body.fr.maxlines;
nl[j] = l;
tot += l;
}
/* approximate new #lines for this window */
if(but == 2){ /* as big as can be */
if (but == 2) { /* as big as can be */
memset(nl, 0, c->nw * sizeof(int));
goto Pack;
}
nnl = min(onl + max(min(5, w->taglines-1+w->maxlines), onl/2), tot);
if(nnl < w->taglines-1+w->maxlines)
nnl = (w->taglines-1+w->maxlines + nnl)/2;
if(nnl == 0)
nnl = min(onl + max(min(5, w->taglines - 1 + w->maxlines), onl / 2), tot);
if (nnl < w->taglines - 1 + w->maxlines)
nnl = (w->taglines - 1 + w->maxlines + nnl) / 2;
if (nnl == 0)
nnl = 2;
dnl = nnl - onl;
/* compute new #lines for each window */
for(k=1; k<c->nw; k++){
for (k = 1; k < c->nw; k++) {
/* prune from later window */
j = i+k;
if(j<c->nw && nl[j]){
l = min(dnl, max(1, nl[j]/2));
j = i + k;
if (j < c->nw && nl[j]) {
l = min(dnl, max(1, nl[j] / 2));
nl[j] -= l;
nl[i] += l;
dnl -= l;
}
/* prune from earlier window */
j = i-k;
if(j>=0 && nl[j]){
l = min(dnl, max(1, nl[j]/2));
j = i - k;
if (j >= 0 && nl[j]) {
l = min(dnl, max(1, nl[j] / 2));
nl[j] -= l;
nl[i] += l;
dnl -= l;
}
}
Pack:
Pack:
/* pack everyone above */
y1 = cr.min.y;
for(j=0; j<i; j++){
for (j = 0; j < i; j++) {
v = c->w[j];
r = v->r;
r.min.y = y1;
r.max.y = y1+Dy(v->tagtop);
if(nl[j])
r.max.y += 1 + nl[j]*v->body.fr.font->height;
r.max.y = y1 + Dy(v->tagtop);
if (nl[j])
r.max.y += 1 + nl[j] * v->body.fr.font->height;
r.min.y = winresize(v, r, c->safe, FALSE);
r.max.y += Border;
draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
y1 = r.max.y;
}
/* scan to see new size of everyone below */
y2 = c->r.max.y;
for(j=c->nw-1; j>i; j--){
for (j = c->nw - 1; j > i; j--) {
v = c->w[j];
r = v->r;
r.min.y = y2-Dy(v->tagtop);
if(nl[j])
r.min.y -= 1 + nl[j]*v->body.fr.font->height;
r.min.y = y2 - Dy(v->tagtop);
if (nl[j])
r.min.y -= 1 + nl[j] * v->body.fr.font->height;
r.min.y -= Border;
ny[j] = r.min.y;
y2 = r.min.y;
@ -433,31 +452,41 @@ colgrow(Column *c, Window *w, int but)
r.min.y = y1;
r.max.y = y2;
h = w->body.fr.font->height;
if(Dy(r) < Dy(w->tagtop)+1+h+Border)
r.max.y = r.min.y + Dy(w->tagtop)+1+h+Border;
if (Dy(r) < Dy(w->tagtop) + 1 + h + Border)
r.max.y = r.min.y + Dy(w->tagtop) + 1 + h + Border;
/* draw window */
r.max.y = winresize(w, r, c->safe, TRUE);
if(i < c->nw-1){
if (i < c->nw - 1) {
r.min.y = r.max.y;
r.max.y += Border;
draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
for(j=i+1; j<c->nw; j++)
ny[j] -= (y2-r.max.y);
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
for (j = i + 1; j < c->nw; j++)
ny[j] -= (y2 - r.max.y);
}
/* pack everyone below */
y1 = r.max.y;
for(j=i+1; j<c->nw; j++){
for (j = i + 1; j < c->nw; j++) {
v = c->w[j];
r = v->r;
r.min.y = y1;
r.max.y = y1+Dy(v->tagtop);
if(nl[j])
r.max.y += 1 + nl[j]*v->body.fr.font->height;
y1 = winresize(v, r, c->safe, j==c->nw-1);
if(j < c->nw-1){ /* no border on last window */
r.max.y = y1 + Dy(v->tagtop);
if (nl[j])
r.max.y += 1 + nl[j] * v->body.fr.font->height;
y1 = winresize(v, r, c->safe, j == c->nw - 1);
if (j < c->nw - 1) { /* no border on last window */
r.min.y = y1;
r.max.y += Border;
draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
y1 = r.max.y;
}
}
@ -467,106 +496,108 @@ colgrow(Column *c, Window *w, int but)
winmousebut(w);
}
void
coldragwin(Column *c, Window *w, int but)
{
void coldragwin(Column* c, Window* w, int but) {
Rectangle r;
int i, b;
Point p, op;
Window *v;
Column *nc;
Window* v;
Column* nc;
clearmouse();
setcursor2(mousectl, &boxcursor, &boxcursor2);
b = mouse->buttons;
op = mouse->xy;
while(mouse->buttons == b)
while (mouse->buttons == b)
readmouse(mousectl);
setcursor(mousectl, nil);
if(mouse->buttons){
while(mouse->buttons)
if (mouse->buttons) {
while (mouse->buttons)
readmouse(mousectl);
return;
}
for(i=0; i<c->nw; i++)
if(c->w[i] == w)
for (i = 0; i < c->nw; i++)
if (c->w[i] == w)
goto Found;
error("can't find window");
Found:
if(w->tagexpand) /* force recomputation of window tag size */
Found:
if (w->tagexpand) /* force recomputation of window tag size */
w->taglines = 1;
p = mouse->xy;
if(abs(p.x-op.x)<5 && abs(p.y-op.y)<5){
if (abs(p.x - op.x) < 5 && abs(p.y - op.y) < 5) {
colgrow(c, w, but);
winmousebut(w);
return;
}
/* is it a flick to the right? */
if(abs(p.y-op.y)<10 && p.x>op.x+30 && rowwhichcol(c->row, p)==c)
p.x = op.x+Dx(w->r); /* yes: toss to next column */
if (abs(p.y - op.y) < 10 && p.x > op.x + 30 && rowwhichcol(c->row, p) == c)
p.x = op.x + Dx(w->r); /* yes: toss to next column */
nc = rowwhichcol(c->row, p);
if(nc!=nil && nc!=c){
if (nc != nil && nc != c) {
colclose(c, w, FALSE);
coladd(nc, w, nil, p.y);
winmousebut(w);
return;
}
if(i==0 && c->nw==1)
if (i == 0 && c->nw == 1)
return; /* can't do it */
if((i>0 && p.y<c->w[i-1]->r.min.y) || (i<c->nw-1 && p.y>w->r.max.y)
|| (i==0 && p.y>w->r.max.y)){
if (
(i > 0 && p.y < c->w[i - 1]->r.min.y) ||
(i < c->nw - 1 && p.y > w->r.max.y) || (i == 0 && p.y > w->r.max.y)) {
/* shuffle */
colclose(c, w, FALSE);
coladd(c, w, nil, p.y);
winmousebut(w);
return;
}
if(i == 0)
if (i == 0)
return;
v = c->w[i-1];
if(p.y < v->tagtop.max.y)
v = c->w[i - 1];
if (p.y < v->tagtop.max.y)
p.y = v->tagtop.max.y;
if(p.y > w->r.max.y-Dy(w->tagtop)-Border)
p.y = w->r.max.y-Dy(w->tagtop)-Border;
if (p.y > w->r.max.y - Dy(w->tagtop) - Border)
p.y = w->r.max.y - Dy(w->tagtop) - Border;
r = v->r;
r.max.y = p.y;
if(r.max.y > v->body.fr.r.min.y){
r.max.y -= (r.max.y-v->body.fr.r.min.y)%v->body.fr.font->height;
if(v->body.fr.r.min.y == v->body.fr.r.max.y)
if (r.max.y > v->body.fr.r.min.y) {
r.max.y -= (r.max.y - v->body.fr.r.min.y) % v->body.fr.font->height;
if (v->body.fr.r.min.y == v->body.fr.r.max.y)
r.max.y++;
}
r.min.y = winresize(v, r, c->safe, FALSE);
r.max.y = r.min.y+Border;
draw(screen, r, allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0x222222FF), nil, ZP);
r.max.y = r.min.y + Border;
draw(
screen,
r,
allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, 0x222222FF),
nil,
ZP);
r.min.y = r.max.y;
if(i == c->nw-1)
if (i == c->nw - 1)
r.max.y = c->r.max.y;
else
r.max.y = c->w[i+1]->r.min.y-Border;
r.max.y = c->w[i + 1]->r.min.y - Border;
winresize(w, r, c->safe, TRUE);
c->safe = TRUE;
winmousebut(w);
}
Text*
colwhich(Column *c, Point p)
{
Text* colwhich(Column* c, Point p) {
int i;
Window *w;
Window* w;
if(!ptinrect(p, c->r))
if (!ptinrect(p, c->r))
return nil;
if(ptinrect(p, c->tag.all))
if (ptinrect(p, c->tag.all))
return &c->tag;
for(i=0; i<c->nw; i++){
for (i = 0; i < c->nw; i++) {
w = c->w[i];
if(ptinrect(p, w->r)){
if(ptinrect(p, w->tagtop) || ptinrect(p, w->tag.all))
if (ptinrect(p, w->r)) {
if (ptinrect(p, w->tagtop) || ptinrect(p, w->tag.all))
return &w->tag;
/* exclude partial line at bottom */
if(p.x >= w->body.scrollr.max.x && p.y >= w->body.fr.r.max.y)
if (p.x >= w->body.scrollr.max.x && p.y >= w->body.fr.r.max.y)
return nil;
return &w->body;
}
@ -574,13 +605,11 @@ colwhich(Column *c, Point p)
return nil;
}
int
colclean(Column *c)
{
int colclean(Column* c) {
int i, clean;
clean = TRUE;
for(i=0; i<c->nw; i++)
for (i = 0; i < c->nw; i++)
clean &= winclean(c->w[i], TRUE);
return clean;
}

79
disk.c
View file

@ -12,78 +12,69 @@
#include "dat.h"
#include "fns.h"
static Block *blist;
static Block* blist;
int
tempfile(void)
{
int tempfile(void) {
char buf[128];
int i, fd;
snprint(buf, sizeof buf, "/tmp/X%d.%.4sacme", getpid(), getuser());
for(i='A'; i<='Z'; i++){
for (i = 'A'; i <= 'Z'; i++) {
buf[5] = i;
if(access(buf, AEXIST) == 0)
if (access(buf, AEXIST) == 0)
continue;
fd = create(buf, ORDWR|ORCLOSE|OCEXEC, 0600);
if(fd >= 0)
fd = create(buf, ORDWR | ORCLOSE | OCEXEC, 0600);
if (fd >= 0)
return fd;
}
return -1;
}
Disk*
diskinit()
{
Disk *d;
Disk* diskinit() {
Disk* d;
d = emalloc(sizeof(Disk));
d->fd = tempfile();
if(d->fd < 0){
if (d->fd < 0) {
fprint(2, "acme: can't create temp file: %r\n");
threadexitsall("diskinit");
}
return d;
}
static
uint
ntosize(uint n, uint *ip)
{
static uint ntosize(uint n, uint* ip) {
uint size;
if(n > Maxblock)
if (n > Maxblock)
error("internal error: ntosize");
size = n;
if(size & (Blockincr-1))
size += Blockincr - (size & (Blockincr-1));
if (size & (Blockincr - 1))
size += Blockincr - (size & (Blockincr - 1));
/* last bucket holds blocks of exactly Maxblock */
if(ip)
*ip = size/Blockincr;
if (ip)
*ip = size / Blockincr;
return size * sizeof(Rune);
}
Block*
disknewblock(Disk *d, uint n)
{
Block* disknewblock(Disk* d, uint n) {
uint i, j, size;
Block *b;
Block* b;
size = ntosize(n, &i);
b = d->free[i];
if(b)
if (b)
d->free[i] = b->u.next;
else{
else {
/* allocate in chunks to reduce malloc overhead */
if(blist == nil){
blist = emalloc(100*sizeof(Block));
for(j=0; j<100-1; j++)
blist[j].u.next = &blist[j+1];
if (blist == nil) {
blist = emalloc(100 * sizeof(Block));
for (j = 0; j < 100 - 1; j++)
blist[j].u.next = &blist[j + 1];
}
b = blist;
blist = b->u.next;
b->addr = d->addr;
if(d->addr+size < d->addr){
if (d->addr + size < d->addr) {
error("temp file overflow");
}
d->addr += size;
@ -92,9 +83,7 @@ disknewblock(Disk *d, uint n)
return b;
}
void
diskrelease(Disk *d, Block *b)
{
void diskrelease(Disk* d, Block* b) {
uint i;
ntosize(b->u.n, &i);
@ -102,32 +91,28 @@ diskrelease(Disk *d, Block *b)
d->free[i] = b;
}
void
diskwrite(Disk *d, Block **bp, Rune *r, uint n)
{
void diskwrite(Disk* d, Block** bp, Rune* r, uint n) {
int size, nsize;
Block *b;
Block* b;
b = *bp;
size = ntosize(b->u.n, nil);
nsize = ntosize(n, nil);
if(size != nsize){
if (size != nsize) {
diskrelease(d, b);
b = disknewblock(d, n);
*bp = b;
}
if(pwrite(d->fd, r, n*sizeof(Rune), b->addr) != n*sizeof(Rune))
if (pwrite(d->fd, r, n * sizeof(Rune), b->addr) != n * sizeof(Rune))
error("write error to temp file");
b->u.n = n;
}
void
diskread(Disk *d, Block *b, Rune *r, uint n)
{
if(n > b->u.n)
void diskread(Disk* d, Block* b, Rune* r, uint n) {
if (n > b->u.n)
error("internal error: diskread");
ntosize(b->u.n, nil);
if(pread(d->fd, r, n*sizeof(Rune), b->addr) != n*sizeof(Rune))
if (pread(d->fd, r, n * sizeof(Rune), b->addr) != n * sizeof(Rune))
error("read error from temp file");
}

878
ecmd.c
View file

File diff suppressed because it is too large Load diff

710
edit.c
View file

File diff suppressed because it is too large Load diff

211
elog.c
View file

@ -27,65 +27,52 @@ static int warned = FALSE;
*/
typedef struct Buflog Buflog;
struct Buflog
{
struct Buflog {
short type; /* Replace, Filename */
uint q0; /* location of change (unused in f) */
uint nd; /* # runes to delete */
uint nr; /* # runes in string or file name */
};
enum
{
Buflogsize = sizeof(Buflog)/sizeof(Rune)
};
enum { Buflogsize = sizeof(Buflog) / sizeof(Rune) };
/*
* Minstring shouldn't be very big or we will do lots of I/O for small changes.
* Maxstring is RBUFSIZE so we can fbufalloc() once and not realloc elog.r.
*/
enum
{
enum {
Minstring = 16, /* distance beneath which we merge changes */
Maxstring = RBUFSIZE /* maximum length of change we will merge into one */
};
void
eloginit(File *f)
{
if(f->elog.type != Empty)
void eloginit(File* f) {
if (f->elog.type != Empty)
return;
f->elog.type = Null;
if(f->elogbuf == nil)
if (f->elogbuf == nil)
f->elogbuf = emalloc(sizeof(Buffer));
if(f->elog.r == nil)
if (f->elog.r == nil)
f->elog.r = fbufalloc();
bufreset(f->elogbuf);
}
void
elogclose(File *f)
{
if(f->elogbuf){
void elogclose(File* f) {
if (f->elogbuf) {
bufclose(f->elogbuf);
free(f->elogbuf);
f->elogbuf = nil;
}
}
void
elogreset(File *f)
{
void elogreset(File* f) {
f->elog.type = Null;
f->elog.nd = 0;
f->elog.nr = 0;
}
void
elogterm(File *f)
{
void elogterm(File* f) {
elogreset(f);
if(f->elogbuf)
if (f->elogbuf)
bufreset(f->elogbuf);
f->elog.type = Empty;
fbuffree(f->elog.r);
@ -93,16 +80,14 @@ elogterm(File *f)
warned = FALSE;
}
void
elogflush(File *f)
{
void elogflush(File* f) {
Buflog b;
b.type = f->elog.type;
b.q0 = f->elog.q0;
b.nd = f->elog.nd;
b.nr = f->elog.nr;
switch(f->elog.type){
switch (f->elog.type) {
default:
warning(nil, "unknown elog type 0x%ux\n", f->elog.type);
break;
@ -110,7 +95,7 @@ elogflush(File *f)
break;
case Insert:
case Replace:
if(f->elog.nr > 0)
if (f->elog.nr > 0)
bufinsert(f->elogbuf, f->elogbuf->nc, f->elog.r, f->elog.nr);
/* fall through */
case Delete:
@ -120,29 +105,27 @@ elogflush(File *f)
elogreset(f);
}
void
elogreplace(File *f, int q0, int q1, Rune *r, int nr)
{
void elogreplace(File* f, int q0, int q1, Rune* r, int nr) {
uint gap;
if(q0==q1 && nr==0)
if (q0 == q1 && nr == 0)
return;
eloginit(f);
if(f->elog.type!=Null && q0<f->elog.q0){
if(warned++ == 0)
if (f->elog.type != Null && q0 < f->elog.q0) {
if (warned++ == 0)
warning(nil, Wsequence);
elogflush(f);
}
/* try to merge with previous */
gap = q0 - (f->elog.q0+f->elog.nd); /* gap between previous and this */
if(f->elog.type==Replace && f->elog.nr+gap+nr<Maxstring){
if(gap < Minstring){
if(gap > 0){
bufread(&f->b, f->elog.q0+f->elog.nd, f->elog.r+f->elog.nr, gap);
gap = q0 - (f->elog.q0 + f->elog.nd); /* gap between previous and this */
if (f->elog.type == Replace && f->elog.nr + gap + nr < Maxstring) {
if (gap < Minstring) {
if (gap > 0) {
bufread(&f->b, f->elog.q0 + f->elog.nd, f->elog.r + f->elog.nr, gap);
f->elog.nr += gap;
}
f->elog.nd += gap + q1-q0;
runemove(f->elog.r+f->elog.nr, r, nr);
f->elog.nd += gap + q1 - q0;
runemove(f->elog.r + f->elog.nr, r, nr);
f->elog.nr += nr;
return;
}
@ -150,38 +133,37 @@ elogreplace(File *f, int q0, int q1, Rune *r, int nr)
elogflush(f);
f->elog.type = Replace;
f->elog.q0 = q0;
f->elog.nd = q1-q0;
f->elog.nd = q1 - q0;
f->elog.nr = nr;
if(nr > RBUFSIZE)
if (nr > RBUFSIZE)
editerror("internal error: replacement string too large(%d)", nr);
runemove(f->elog.r, r, nr);
}
void
eloginsert(File *f, int q0, Rune *r, int nr)
{
void eloginsert(File* f, int q0, Rune* r, int nr) {
int n;
if(nr == 0)
if (nr == 0)
return;
eloginit(f);
if(f->elog.type!=Null && q0<f->elog.q0){
if(warned++ == 0)
if (f->elog.type != Null && q0 < f->elog.q0) {
if (warned++ == 0)
warning(nil, Wsequence);
elogflush(f);
}
/* try to merge with previous */
if(f->elog.type==Insert && q0==f->elog.q0 && f->elog.nr+nr<Maxstring){
runemove(f->elog.r+f->elog.nr, r, nr);
if (
f->elog.type == Insert && q0 == f->elog.q0 && f->elog.nr + nr < Maxstring) {
runemove(f->elog.r + f->elog.nr, r, nr);
f->elog.nr += nr;
return;
}
while(nr > 0){
while (nr > 0) {
elogflush(f);
f->elog.type = Insert;
f->elog.q0 = q0;
n = nr;
if(n > RBUFSIZE)
if (n > RBUFSIZE)
n = RBUFSIZE;
f->elog.nr = n;
runemove(f->elog.r, r, n);
@ -190,38 +172,34 @@ eloginsert(File *f, int q0, Rune *r, int nr)
}
}
void
elogdelete(File *f, int q0, int q1)
{
if(q0 == q1)
void elogdelete(File* f, int q0, int q1) {
if (q0 == q1)
return;
eloginit(f);
if(f->elog.type!=Null && q0<f->elog.q0+f->elog.nd){
if(warned++ == 0)
if (f->elog.type != Null && q0 < f->elog.q0 + f->elog.nd) {
if (warned++ == 0)
warning(nil, Wsequence);
elogflush(f);
}
/* try to merge with previous */
if(f->elog.type==Delete && f->elog.q0+f->elog.nd==q0){
f->elog.nd += q1-q0;
if (f->elog.type == Delete && f->elog.q0 + f->elog.nd == q0) {
f->elog.nd += q1 - q0;
return;
}
elogflush(f);
f->elog.type = Delete;
f->elog.q0 = q0;
f->elog.nd = q1-q0;
f->elog.nd = q1 - q0;
}
#define tracelog 0
void
elogapply(File *f)
{
void elogapply(File* f) {
Buflog b;
Rune *buf;
Rune* buf;
uint i, n, up, mod;
uint tq0, tq1;
Buffer *log;
Text *t;
Buffer* log;
Text* t;
int owner;
elogflush(f);
@ -232,19 +210,19 @@ elogapply(File *f)
mod = FALSE;
owner = 0;
if(t->w){
if (t->w) {
owner = t->w->owner;
if(owner == 0)
if (owner == 0)
t->w->owner = 'E';
}
/*
* The edit commands have already updated the selection in t->q0, t->q1,
* but using coordinates relative to the unmodified buffer. As we apply the log,
* we have to update the coordinates to be relative to the modified buffer.
* Textinsert and textdelete will do this for us; our only work is to apply the
* convention that an insertion at t->q0==t->q1 is intended to select the
* inserted text.
* but using coordinates relative to the unmodified buffer. As we apply the
* log, we have to update the coordinates to be relative to the modified
* buffer. Textinsert and textdelete will do this for us; our only work is to
* apply the convention that an insertion at t->q0==t->q1 is intended to
* select the inserted text.
*/
/*
@ -254,71 +232,86 @@ elogapply(File *f)
* keep things in range.
*/
while(log->nc > 0){
up = log->nc-Buflogsize;
while (log->nc > 0) {
up = log->nc - Buflogsize;
bufread(log, up, (Rune*)&b, Buflogsize);
switch(b.type){
switch (b.type) {
default:
fprint(2, "elogapply: 0x%ux\n", b.type);
abort();
break;
case Replace:
if(tracelog)
warning(nil, "elog replace %d %d (%d %d)\n",
b.q0, b.q0+b.nd, t->q0, t->q1);
if(!mod){
if (tracelog)
warning(
nil,
"elog replace %d %d (%d %d)\n",
b.q0,
b.q0 + b.nd,
t->q0,
t->q1);
if (!mod) {
mod = TRUE;
filemark(f);
}
textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
textconstrain(t, b.q0, b.q0 + b.nd, &tq0, &tq1);
textdelete(t, tq0, tq1, TRUE);
up -= b.nr;
for(i=0; i<b.nr; i+=n){
for (i = 0; i < b.nr; i += n) {
n = b.nr - i;
if(n > RBUFSIZE)
if (n > RBUFSIZE)
n = RBUFSIZE;
bufread(log, up+i, buf, n);
textinsert(t, tq0+i, buf, n, TRUE);
bufread(log, up + i, buf, n);
textinsert(t, tq0 + i, buf, n, TRUE);
}
if(t->q0 == b.q0 && t->q1 == b.q0)
if (t->q0 == b.q0 && t->q1 == b.q0)
t->q1 += b.nr;
break;
case Delete:
if(tracelog)
warning(nil, "elog delete %d %d (%d %d)\n",
b.q0, b.q0+b.nd, t->q0, t->q1);
if(!mod){
if (tracelog)
warning(
nil,
"elog delete %d %d (%d %d)\n",
b.q0,
b.q0 + b.nd,
t->q0,
t->q1);
if (!mod) {
mod = TRUE;
filemark(f);
}
textconstrain(t, b.q0, b.q0+b.nd, &tq0, &tq1);
textconstrain(t, b.q0, b.q0 + b.nd, &tq0, &tq1);
textdelete(t, tq0, tq1, TRUE);
break;
case Insert:
if(tracelog)
warning(nil, "elog insert %d %d (%d %d)\n",
b.q0, b.q0+b.nr, t->q0, t->q1);
if(!mod){
if (tracelog)
warning(
nil,
"elog insert %d %d (%d %d)\n",
b.q0,
b.q0 + b.nr,
t->q0,
t->q1);
if (!mod) {
mod = TRUE;
filemark(f);
}
textconstrain(t, b.q0, b.q0, &tq0, &tq1);
up -= b.nr;
for(i=0; i<b.nr; i+=n){
for (i = 0; i < b.nr; i += n) {
n = b.nr - i;
if(n > RBUFSIZE)
if (n > RBUFSIZE)
n = RBUFSIZE;
bufread(log, up+i, buf, n);
textinsert(t, tq0+i, buf, n, TRUE);
bufread(log, up + i, buf, n);
textinsert(t, tq0 + i, buf, n, TRUE);
}
if(t->q0 == b.q0 && t->q1 == b.q0)
if (t->q0 == b.q0 && t->q1 == b.q0)
t->q1 += b.nr;
break;
/* case Filename:
/* case Filename:
f->seq = u.seq;
fileunsetname(f, epsilon);
f->mod = u.mod;
@ -331,7 +324,7 @@ elogapply(File *f)
bufread(delta, up, f->name, u.n);
f->nname = u.n;
break;
*/
*/
}
bufdelete(log, up, log->nc);
}
@ -342,13 +335,13 @@ elogapply(File *f)
* Bad addresses will cause bufload to crash, so double check.
* If changes were out of order, we expect problems so don't complain further.
*/
if(t->q0 > f->b.nc || t->q1 > f->b.nc || t->q0 > t->q1){
if(!warned)
if (t->q0 > f->b.nc || t->q1 > f->b.nc || t->q0 > t->q1) {
if (!warned)
warning(nil, "elogapply: can't happen %d %d %d\n", t->q0, t->q1, f->b.nc);
t->q1 = min(t->q1, f->b.nc);
t->q0 = min(t->q0, t->q1);
}
if(t->w)
if (t->w)
t->w->owner = owner;
}

1128
exec.c
View file

File diff suppressed because it is too large Load diff

165
file.c
View file

@ -23,8 +23,7 @@
*/
typedef struct Undo Undo;
struct Undo
{
struct Undo {
short type; /* Delete, Insert, Filename */
short mod; /* modify bit */
uint seq; /* sequence number */
@ -32,60 +31,49 @@ struct Undo
uint n; /* # runes in string or file name */
};
enum
{
Undosize = sizeof(Undo)/sizeof(Rune)
};
enum { Undosize = sizeof(Undo) / sizeof(Rune) };
File*
fileaddtext(File *f, Text *t)
{
if(f == nil){
File* fileaddtext(File* f, Text* t) {
if (f == nil) {
f = emalloc(sizeof(File));
f->unread = TRUE;
}
f->text = realloc(f->text, (f->ntext+1)*sizeof(Text*));
f->text = realloc(f->text, (f->ntext + 1) * sizeof(Text*));
f->text[f->ntext++] = t;
f->curtext = t;
return f;
}
void
filedeltext(File *f, Text *t)
{
void filedeltext(File* f, Text* t) {
int i;
for(i=0; i<f->ntext; i++)
if(f->text[i] == t)
for (i = 0; i < f->ntext; i++)
if (f->text[i] == t)
goto Found;
error("can't find text in filedeltext");
Found:
Found:
f->ntext--;
if(f->ntext == 0){
if (f->ntext == 0) {
fileclose(f);
return;
}
memmove(f->text+i, f->text+i+1, (f->ntext-i)*sizeof(Text*));
if(f->curtext == t)
memmove(f->text + i, f->text + i + 1, (f->ntext - i) * sizeof(Text*));
if (f->curtext == t)
f->curtext = f->text[0];
}
void
fileinsert(File *f, uint p0, Rune *s, uint ns)
{
if(p0 > f->b.nc)
void fileinsert(File* f, uint p0, Rune* s, uint ns) {
if (p0 > f->b.nc)
error("internal error: fileinsert");
if(f->seq > 0)
if (f->seq > 0)
fileuninsert(f, &f->delta, p0, ns);
bufinsert(&f->b, p0, s, ns);
if(ns)
if (ns)
f->mod = TRUE;
}
void
fileuninsert(File *f, Buffer *delta, uint p0, uint ns)
{
void fileuninsert(File* f, Buffer* delta, uint p0, uint ns) {
Undo u;
/* undo an insertion by deleting */
@ -97,23 +85,19 @@ fileuninsert(File *f, Buffer *delta, uint p0, uint ns)
bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}
void
filedelete(File *f, uint p0, uint p1)
{
if(!(p0<=p1 && p0<=f->b.nc && p1<=f->b.nc))
void filedelete(File* f, uint p0, uint p1) {
if (!(p0 <= p1 && p0 <= f->b.nc && p1 <= f->b.nc))
error("internal error: filedelete");
if(f->seq > 0)
if (f->seq > 0)
fileundelete(f, &f->delta, p0, p1);
bufdelete(&f->b, p0, p1);
if(p1 > p0)
if (p1 > p0)
f->mod = TRUE;
}
void
fileundelete(File *f, Buffer *delta, uint p0, uint p1)
{
void fileundelete(File* f, Buffer* delta, uint p0, uint p1) {
Undo u;
Rune *buf;
Rune* buf;
uint i, n;
/* undo a deletion by inserting */
@ -121,24 +105,21 @@ fileundelete(File *f, Buffer *delta, uint p0, uint p1)
u.mod = f->mod;
u.seq = f->seq;
u.p0 = p0;
u.n = p1-p0;
u.n = p1 - p0;
buf = fbufalloc();
for(i=p0; i<p1; i+=n){
for (i = p0; i < p1; i += n) {
n = p1 - i;
if(n > RBUFSIZE)
if (n > RBUFSIZE)
n = RBUFSIZE;
bufread(&f->b, i, buf, n);
bufinsert(delta, delta->nc, buf, n);
}
fbuffree(buf);
bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}
void
filesetname(File *f, Rune *name, int n)
{
if(f->seq > 0)
void filesetname(File* f, Rune* name, int n) {
if (f->seq > 0)
fileunsetname(f, &f->delta);
free(f->name);
f->name = runemalloc(n);
@ -147,9 +128,7 @@ filesetname(File *f, Rune *name, int n)
f->unread = TRUE;
}
void
fileunsetname(File *f, Buffer *delta)
{
void fileunsetname(File* f, Buffer* delta) {
Undo u;
/* undo a file name change by restoring old name */
@ -158,48 +137,42 @@ fileunsetname(File *f, Buffer *delta)
u.seq = f->seq;
u.p0 = 0; /* unused */
u.n = f->nname;
if(f->nname)
if (f->nname)
bufinsert(delta, delta->nc, f->name, f->nname);
bufinsert(delta, delta->nc, (Rune*)&u, Undosize);
}
uint
fileload(File *f, uint p0, int fd, int *nulls, DigestState *h)
{
if(f->seq > 0)
uint fileload(File* f, uint p0, int fd, int* nulls, DigestState* h) {
if (f->seq > 0)
error("undo in file.load unimplemented");
return bufload(&f->b, p0, fd, nulls, h);
}
/* return sequence number of pending redo */
uint
fileredoseq(File *f)
{
uint fileredoseq(File* f) {
Undo u;
Buffer *delta;
Buffer* delta;
delta = &f->epsilon;
if(delta->nc == 0)
if (delta->nc == 0)
return 0;
bufread(delta, delta->nc-Undosize, (Rune*)&u, Undosize);
bufread(delta, delta->nc - Undosize, (Rune*)&u, Undosize);
return u.seq;
}
void
fileundo(File *f, int isundo, uint *q0p, uint *q1p)
{
void fileundo(File* f, int isundo, uint* q0p, uint* q1p) {
Undo u;
Rune *buf;
Rune* buf;
uint i, j, n, up;
uint stop;
Buffer *delta, *epsilon;
if(isundo){
if (isundo) {
/* undo; reverse delta onto epsilon, seq decreases */
delta = &f->delta;
epsilon = &f->epsilon;
stop = f->seq;
}else{
} else {
/* redo; reverse epsilon onto delta, seq increases */
delta = &f->epsilon;
epsilon = &f->delta;
@ -207,21 +180,21 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
}
buf = fbufalloc();
while(delta->nc > 0){
up = delta->nc-Undosize;
while (delta->nc > 0) {
up = delta->nc - Undosize;
bufread(delta, up, (Rune*)&u, Undosize);
if(isundo){
if(u.seq < stop){
if (isundo) {
if (u.seq < stop) {
f->seq = u.seq;
goto Return;
}
}else{
if(stop == 0)
} else {
if (stop == 0)
stop = u.seq;
if(u.seq > stop)
if (u.seq > stop)
goto Return;
}
switch(u.type){
switch (u.type) {
default:
fprint(2, "undo: 0x%ux\n", u.type);
abort();
@ -229,11 +202,11 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
case Delete:
f->seq = u.seq;
fileundelete(f, epsilon, u.p0, u.p0+u.n);
fileundelete(f, epsilon, u.p0, u.p0 + u.n);
f->mod = u.mod;
bufdelete(&f->b, u.p0, u.p0+u.n);
for(j=0; j<f->ntext; j++)
textdelete(f->text[j], u.p0, u.p0+u.n, FALSE);
bufdelete(&f->b, u.p0, u.p0 + u.n);
for (j = 0; j < f->ntext; j++)
textdelete(f->text[j], u.p0, u.p0 + u.n, FALSE);
*q0p = u.p0;
*q1p = u.p0;
break;
@ -243,17 +216,17 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
fileuninsert(f, epsilon, u.p0, u.n);
f->mod = u.mod;
up -= u.n;
for(i=0; i<u.n; i+=n){
for (i = 0; i < u.n; i += n) {
n = u.n - i;
if(n > RBUFSIZE)
if (n > RBUFSIZE)
n = RBUFSIZE;
bufread(delta, up+i, buf, n);
bufinsert(&f->b, u.p0+i, buf, n);
for(j=0; j<f->ntext; j++)
textinsert(f->text[j], u.p0+i, buf, n, FALSE);
bufread(delta, up + i, buf, n);
bufinsert(&f->b, u.p0 + i, buf, n);
for (j = 0; j < f->ntext; j++)
textinsert(f->text[j], u.p0 + i, buf, n, FALSE);
}
*q0p = u.p0;
*q1p = u.p0+u.n;
*q1p = u.p0 + u.n;
break;
case Filename:
@ -262,7 +235,7 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
f->mod = u.mod;
up -= u.n;
free(f->name);
if(u.n == 0)
if (u.n == 0)
f->name = nil;
else
f->name = runemalloc(u.n);
@ -272,23 +245,19 @@ fileundo(File *f, int isundo, uint *q0p, uint *q1p)
}
bufdelete(delta, up, delta->nc);
}
if(isundo)
if (isundo)
f->seq = 0;
Return:
Return:
fbuffree(buf);
}
void
filereset(File *f)
{
void filereset(File* f) {
bufreset(&f->delta);
bufreset(&f->epsilon);
f->seq = 0;
}
void
fileclose(File *f)
{
void fileclose(File* f) {
free(f->name);
f->nname = 0;
f->name = nil;
@ -302,10 +271,8 @@ fileclose(File *f)
free(f);
}
void
filemark(File *f)
{
if(f->epsilon.nc)
void filemark(File* f) {
if (f->epsilon.nc)
bufdelete(&f->epsilon, 0, f->epsilon.nc);
f->seq = seq;
}

1
fns.h
View file

@ -95,6 +95,7 @@ void flushwarnings(void);
void startplumbing(void);
long nlcount(Text*, long, long, long*);
long nlcounttopos(Text*, long, long, long);
Rune* parsetag(Window*, int*);
Runestr runestr(Rune*, uint);
Range range(int, int);

411
fsys.c
View file

@ -14,15 +14,11 @@
static int sfd;
enum
{
Nhash = 16,
DEBUG = 0
};
enum { Nhash = 16, DEBUG = 0 };
static Fid *fids[Nhash];
static Fid* fids[Nhash];
Fid *newfid(int);
Fid* newfid(int);
static Xfid* fsysflush(Xfid*, Fid*);
static Xfid* fsysauth(Xfid*, Fid*);
@ -40,9 +36,7 @@ static Xfid* fsyswstat(Xfid*, Fid*);
Xfid* (*fcall[Tmax])(Xfid*, Fid*);
static void
initfcall(void)
{
static void initfcall(void) {
fcall[Tflush] = fsysflush;
fcall[Tversion] = fsysversion;
fcall[Tauth] = fsysauth;
@ -53,7 +47,7 @@ initfcall(void)
fcall[Tread] = fsysread;
fcall[Twrite] = fsyswrite;
fcall[Tclunk] = fsysclunk;
fcall[Tremove]= fsysremove;
fcall[Tremove] = fsysremove;
fcall[Tstat] = fsysstat;
fcall[Twstat] = fsyswstat;
}
@ -62,44 +56,46 @@ char Eperm[] = "permission denied";
char Eexist[] = "file does not exist";
char Enotdir[] = "not a directory";
Dirtab dirtab[]=
{
{ ".", QTDIR, Qdir, 0500|DMDIR },
{ "acme", QTDIR, Qacme, 0500|DMDIR },
{ "cons", QTFILE, Qcons, 0600 },
{ "consctl", QTFILE, Qconsctl, 0000 },
{ "draw", QTDIR, Qdraw, 0000|DMDIR }, /* to suppress graphics progs started in acme */
{ "editout", QTFILE, Qeditout, 0200 },
{ "index", QTFILE, Qindex, 0400 },
{ "label", QTFILE, Qlabel, 0600 },
{ "log", QTFILE, Qlog, 0400 },
{ "new", QTDIR, Qnew, 0500|DMDIR },
{ nil, }
};
Dirtab dirtab[] = {
{".", QTDIR, Qdir, 0500 | DMDIR},
{"acme", QTDIR, Qacme, 0500 | DMDIR},
{"cons", QTFILE, Qcons, 0600},
{"consctl", QTFILE, Qconsctl, 0000},
{"draw",
QTDIR,
Qdraw,
0000 | DMDIR}, /* to suppress graphics progs started in acme */
{"editout", QTFILE, Qeditout, 0200},
{"index", QTFILE, Qindex, 0400},
{"label", QTFILE, Qlabel, 0600},
{"log", QTFILE, Qlog, 0400},
{"new", QTDIR, Qnew, 0500 | DMDIR},
{
nil,
}};
Dirtab dirtabw[]=
{
{ ".", QTDIR, Qdir, 0500|DMDIR },
{ "addr", QTFILE, QWaddr, 0600 },
{ "body", QTAPPEND, QWbody, 0600|DMAPPEND },
{ "ctl", QTFILE, QWctl, 0600 },
{ "data", QTFILE, QWdata, 0600 },
{ "editout", QTFILE, QWeditout, 0200 },
{ "errors", QTFILE, QWerrors, 0200 },
{ "event", QTFILE, QWevent, 0600 },
{ "rdsel", QTFILE, QWrdsel, 0400 },
{ "wrsel", QTFILE, QWwrsel, 0200 },
{ "tag", QTAPPEND, QWtag, 0600|DMAPPEND },
{ "xdata", QTFILE, QWxdata, 0600 },
{ nil, }
};
Dirtab dirtabw[] = {
{".", QTDIR, Qdir, 0500 | DMDIR},
{"addr", QTFILE, QWaddr, 0600},
{"body", QTAPPEND, QWbody, 0600 | DMAPPEND},
{"ctl", QTFILE, QWctl, 0600},
{"data", QTFILE, QWdata, 0600},
{"editout", QTFILE, QWeditout, 0200},
{"errors", QTFILE, QWerrors, 0200},
{"event", QTFILE, QWevent, 0600},
{"rdsel", QTFILE, QWrdsel, 0400},
{"wrsel", QTFILE, QWwrsel, 0200},
{"tag", QTAPPEND, QWtag, 0600 | DMAPPEND},
{"xdata", QTFILE, QWxdata, 0600},
{
nil,
}};
typedef struct Mnt Mnt;
struct Mnt
{
struct Mnt {
QLock lk;
int id;
Mntdir *md;
Mntdir* md;
};
Mnt mnt;
@ -108,64 +104,62 @@ Xfid* respond(Xfid*, Fcall*, char*);
int dostat(int, Dirtab*, uchar*, int, uint);
uint getclock(void);
char *user = "Wile E. Coyote";
char* user = "Wile E. Coyote";
static int closing = 0;
int messagesize = Maxblock+IOHDRSZ; /* good start */
int messagesize = Maxblock + IOHDRSZ; /* good start */
void fsysproc(void *);
void fsysproc(void*);
void
fsysinit(void)
{
void fsysinit(void) {
int p[2];
char *u;
char* u;
initfcall();
if(pipe(p) < 0)
if (pipe(p) < 0)
error("can't create pipe");
if(post9pservice(p[0], "acme", mtpt) < 0)
if (post9pservice(p[0], "acme", mtpt) < 0)
error("can't post service");
sfd = p[1];
fmtinstall('F', fcallfmt);
if((u = getuser()) != nil)
if ((u = getuser()) != nil)
user = estrdup(u);
proccreate(fsysproc, nil, STACK);
}
void
fsysproc(void *v)
{
void fsysproc(void* v) {
int n;
Xfid *x;
Fid *f;
Xfid* x;
Fid* f;
Fcall t;
uchar *buf;
uchar* buf;
threadsetname("fsysproc");
USED(v);
x = nil;
for(;;){
buf = emalloc(messagesize+UTFmax); /* overflow for appending partial rune in xfidwrite */
for (;;) {
buf = emalloc(
messagesize +
UTFmax); /* overflow for appending partial rune in xfidwrite */
n = read9pmsg(sfd, buf, messagesize);
if(n <= 0){
if(closing)
if (n <= 0) {
if (closing)
break;
error("i/o error on server channel");
}
if(x == nil){
if (x == nil) {
sendp(cxfidalloc, nil);
x = recvp(cxfidalloc);
}
x->buf = buf;
if(convM2S(buf, n, &x->fcall) != n)
if (convM2S(buf, n, &x->fcall) != n)
error("convert error in convM2S");
if(DEBUG)
if (DEBUG)
fprint(2, "%F\n", &x->fcall);
if(fcall[x->fcall.type] == nil)
if (fcall[x->fcall.type] == nil)
x = respond(x, &t, "bad fcall type");
else{
switch(x->fcall.type){
else {
switch (x->fcall.type) {
case Tversion:
case Tauth:
case Tflush:
@ -176,7 +170,7 @@ fsysproc(void *v)
break;
default:
f = newfid(x->fcall.fid);
if(!f->busy){
if (!f->busy) {
x->f = f;
x = respond(x, &t, "fid not in use");
continue;
@ -189,10 +183,8 @@ fsysproc(void *v)
}
}
Mntdir*
fsysaddid(Rune *dir, int ndir, Rune **incl, int nincl)
{
Mntdir *m;
Mntdir* fsysaddid(Rune* dir, int ndir, Rune** incl, int nincl) {
Mntdir* m;
int id;
qlock(&mnt.lk);
@ -210,36 +202,32 @@ fsysaddid(Rune *dir, int ndir, Rune **incl, int nincl)
return m;
}
void
fsysincid(Mntdir *m)
{
void fsysincid(Mntdir* m) {
qlock(&mnt.lk);
m->ref++;
qunlock(&mnt.lk);
}
void
fsysdelid(Mntdir *idm)
{
void fsysdelid(Mntdir* idm) {
Mntdir *m, *prev;
int i;
char buf[64];
if(idm == nil)
if (idm == nil)
return;
qlock(&mnt.lk);
if(--idm->ref > 0){
if (--idm->ref > 0) {
qunlock(&mnt.lk);
return;
}
prev = nil;
for(m=mnt.md; m; m=m->next){
if(m == idm){
if(prev)
for (m = mnt.md; m; m = m->next) {
if (m == idm) {
if (prev)
prev->next = m->next;
else
mnt.md = m->next;
for(i=0; i<m->nincl; i++)
for (i = 0; i < m->nincl; i++)
free(m->incl[i]);
free(m->incl);
free(m->dir);
@ -257,15 +245,11 @@ fsysdelid(Mntdir *idm)
/*
* Called only in exec.c:/^run(), from a different FD group
*/
Mntdir*
fsysmount(Rune *dir, int ndir, Rune **incl, int nincl)
{
Mntdir* fsysmount(Rune* dir, int ndir, Rune** incl, int nincl) {
return fsysaddid(dir, ndir, incl, nincl);
}
void
fsysclose(void)
{
void fsysclose(void) {
closing = 1;
/*
* apparently this is not kosher on openbsd.
@ -275,78 +259,64 @@ fsysclose(void)
*/
}
Xfid*
respond(Xfid *x, Fcall *t, char *err)
{
Xfid* respond(Xfid* x, Fcall* t, char* err) {
int n;
if(err){
if (err) {
t->type = Rerror;
t->ename = err;
}else
t->type = x->fcall.type+1;
} else
t->type = x->fcall.type + 1;
t->fid = x->fcall.fid;
t->tag = x->fcall.tag;
if(x->buf == nil)
if (x->buf == nil)
x->buf = emalloc(messagesize);
n = convS2M(t, x->buf, messagesize);
if(n <= 0)
if (n <= 0)
error("convert error in convS2M");
if(write(sfd, x->buf, n) != n)
if (write(sfd, x->buf, n) != n)
error("write error in respond");
free(x->buf);
x->buf = nil;
if(DEBUG)
if (DEBUG)
fprint(2, "r: %F\n", t);
return x;
}
static
Xfid*
fsysversion(Xfid *x, Fid *f)
{
static Xfid* fsysversion(Xfid* x, Fid* f) {
Fcall t;
USED(f);
if(x->fcall.msize < 256)
if (x->fcall.msize < 256)
return respond(x, &t, "version: message size too small");
messagesize = x->fcall.msize;
t.msize = messagesize;
if(strncmp(x->fcall.version, "9P2000", 6) != 0)
if (strncmp(x->fcall.version, "9P2000", 6) != 0)
return respond(x, &t, "unrecognized 9P version");
t.version = "9P2000";
return respond(x, &t, nil);
}
static
Xfid*
fsysauth(Xfid *x, Fid *f)
{
static Xfid* fsysauth(Xfid* x, Fid* f) {
Fcall t;
USED(f);
return respond(x, &t, "acme: authentication not required");
}
static
Xfid*
fsysflush(Xfid *x, Fid *f)
{
static Xfid* fsysflush(Xfid* x, Fid* f) {
USED(f);
sendp(x->c, (void*)xfidflush);
return nil;
}
static
Xfid*
fsysattach(Xfid *x, Fid *f)
{
static Xfid* fsysattach(Xfid* x, Fid* f) {
Fcall t;
int id;
Mntdir *m;
Mntdir* m;
char buf[128];
if(strcmp(x->fcall.uname, user) != 0)
if (strcmp(x->fcall.uname, user) != 0)
return respond(x, &t, Eperm);
f->busy = TRUE;
f->open = FALSE;
@ -360,13 +330,13 @@ fsysattach(Xfid *x, Fid *f)
f->mntdir = nil;
id = atoi(x->fcall.aname);
qlock(&mnt.lk);
for(m=mnt.md; m; m=m->next)
if(m->id == id){
for (m = mnt.md; m; m = m->next)
if (m->id == id) {
f->mntdir = m;
m->ref++;
break;
}
if(m == nil && x->fcall.aname[0]){
if (m == nil && x->fcall.aname[0]) {
snprint(buf, sizeof buf, "unknown id '%s' in attach", x->fcall.aname);
sendp(cerr, estrdup(buf));
}
@ -374,38 +344,35 @@ fsysattach(Xfid *x, Fid *f)
return respond(x, &t, nil);
}
static
Xfid*
fsyswalk(Xfid *x, Fid *f)
{
static Xfid* fsyswalk(Xfid* x, Fid* f) {
Fcall t;
int c, i, j, id;
Qid q;
uchar type;
ulong path;
Fid *nf;
Fid* nf;
Dirtab *d, *dir;
Window *w;
char *err;
Window* w;
char* err;
nf = nil;
w = nil;
if(f->open)
if (f->open)
return respond(x, &t, "walk of open file");
if(x->fcall.fid != x->fcall.newfid){
if (x->fcall.fid != x->fcall.newfid) {
nf = newfid(x->fcall.newfid);
if(nf->busy)
if (nf->busy)
return respond(x, &t, "newfid already in use");
nf->busy = TRUE;
nf->open = FALSE;
nf->mntdir = f->mntdir;
if(f->mntdir)
if (f->mntdir)
f->mntdir->ref++;
nf->dir = f->dir;
nf->qid = f->qid;
nf->w = f->w;
nf->nrpart = 0; /* not open, so must be zero */
if(nf->w)
if (nf->w)
incref(&nf->w->ref);
f = nf; /* walk f */
}
@ -416,23 +383,23 @@ fsyswalk(Xfid *x, Fid *f)
id = WIN(f->qid);
q = f->qid;
if(x->fcall.nwname > 0){
for(i=0; i<x->fcall.nwname; i++){
if((q.type & QTDIR) == 0){
if (x->fcall.nwname > 0) {
for (i = 0; i < x->fcall.nwname; i++) {
if ((q.type & QTDIR) == 0) {
err = Enotdir;
break;
}
if(strcmp(x->fcall.wname[i], "..") == 0){
if (strcmp(x->fcall.wname[i], "..") == 0) {
type = QTDIR;
path = Qdir;
id = 0;
if(w){
if (w) {
winclose(w);
w = nil;
}
Accept:
if(i == MAXWELEM){
if (i == MAXWELEM) {
err = "name too long";
break;
}
@ -444,16 +411,16 @@ fsyswalk(Xfid *x, Fid *f)
}
/* is it a numeric name? */
for(j=0; (c=x->fcall.wname[i][j]); j++)
if(c<'0' || '9'<c)
for (j = 0; (c = x->fcall.wname[i][j]); j++)
if (c < '0' || '9' < c)
goto Regular;
/* yes: it's a directory */
if(w) /* name has form 27/23; get out before losing w */
if (w) /* name has form 27/23; get out before losing w */
break;
id = atoi(x->fcall.wname[i]);
qlock(&row.lk);
w = lookid(id, FALSE);
if(w == nil){
if (w == nil) {
qunlock(&row.lk);
break;
}
@ -465,8 +432,8 @@ fsyswalk(Xfid *x, Fid *f)
goto Accept;
Regular:
if(strcmp(x->fcall.wname[i], "new") == 0){
if(w)
if (strcmp(x->fcall.wname[i], "new") == 0) {
if (w)
error("w set in walk to new");
sendp(cnewwindow, nil); /* signal newwindowthread */
w = recvp(cnewwindow); /* receive new window */
@ -478,13 +445,13 @@ fsyswalk(Xfid *x, Fid *f)
goto Accept;
}
if(id == 0)
if (id == 0)
d = dirtab;
else
d = dirtabw;
d++; /* skip '.' */
for(; d->name; d++)
if(strcmp(x->fcall.wname[i], d->name) == 0){
for (; d->name; d++)
if (strcmp(x->fcall.wname[i], d->name) == 0) {
path = d->qid;
type = d->type;
dir = d;
@ -494,44 +461,41 @@ fsyswalk(Xfid *x, Fid *f)
break; /* file not found */
}
if(i==0 && err == nil)
if (i == 0 && err == nil)
err = Eexist;
}
if(err!=nil || t.nwqid<x->fcall.nwname){
if(nf){
if (err != nil || t.nwqid < x->fcall.nwname) {
if (nf) {
nf->busy = FALSE;
fsysdelid(nf->mntdir);
}
}else if(t.nwqid == x->fcall.nwname){
if(w){
} else if (t.nwqid == x->fcall.nwname) {
if (w) {
f->w = w;
w = nil; /* don't drop the reference */
}
if(dir)
if (dir)
f->dir = dir;
f->qid = q;
}
if(w != nil)
if (w != nil)
winclose(w);
return respond(x, &t, err);
}
static
Xfid*
fsysopen(Xfid *x, Fid *f)
{
static Xfid* fsysopen(Xfid* x, Fid* f) {
Fcall t;
int m;
/* can't truncate anything, so just disregard */
x->fcall.mode &= ~(OTRUNC|OCEXEC);
x->fcall.mode &= ~(OTRUNC | OCEXEC);
/* can't execute or remove anything */
if(x->fcall.mode==OEXEC || (x->fcall.mode&ORCLOSE))
if (x->fcall.mode == OEXEC || (x->fcall.mode & ORCLOSE))
goto Deny;
switch(x->fcall.mode){
switch (x->fcall.mode) {
default:
goto Deny;
case OREAD:
@ -544,79 +508,68 @@ fsysopen(Xfid *x, Fid *f)
m = 0600;
break;
}
if(((f->dir->perm&~(DMDIR|DMAPPEND))&m) != m)
if (((f->dir->perm & ~(DMDIR | DMAPPEND)) & m) != m)
goto Deny;
sendp(x->c, (void*)xfidopen);
return nil;
Deny:
Deny:
return respond(x, &t, Eperm);
}
static
Xfid*
fsyscreate(Xfid *x, Fid *f)
{
static Xfid* fsyscreate(Xfid* x, Fid* f) {
Fcall t;
USED(f);
return respond(x, &t, Eperm);
}
static
int
idcmp(const void *a, const void *b)
{
return *(int*)a - *(int*)b;
}
static int idcmp(const void* a, const void* b) { return *(int*)a - *(int*)b; }
static
Xfid*
fsysread(Xfid *x, Fid *f)
{
static Xfid* fsysread(Xfid* x, Fid* f) {
Fcall t;
uchar *b;
uchar* b;
int i, id, n, o, e, j, k, *ids, nids;
Dirtab *d, dt;
Column *c;
Column* c;
uint clock, len;
char buf[16];
if(f->qid.type & QTDIR){
if(FILE(f->qid) == Qacme){ /* empty dir */
if (f->qid.type & QTDIR) {
if (FILE(f->qid) == Qacme) { /* empty dir */
t.data = nil;
t.count = 0;
respond(x, &t, nil);
return x;
}
o = x->fcall.offset;
e = x->fcall.offset+x->fcall.count;
e = x->fcall.offset + x->fcall.count;
clock = getclock();
b = emalloc(messagesize);
id = WIN(f->qid);
n = 0;
if(id > 0)
if (id > 0)
d = dirtabw;
else
d = dirtab;
d++; /* first entry is '.' */
for(i=0; d->name!=nil && i<e; i+=len){
len = dostat(WIN(x->f->qid), d, b+n, x->fcall.count-n, clock);
if(len <= BIT16SZ)
for (i = 0; d->name != nil && i < e; i += len) {
len = dostat(WIN(x->f->qid), d, b + n, x->fcall.count - n, clock);
if (len <= BIT16SZ)
break;
if(i >= o)
if (i >= o)
n += len;
d++;
}
if(id == 0){
if (id == 0) {
qlock(&row.lk);
nids = 0;
ids = nil;
for(j=0; j<row.ncol; j++){
for (j = 0; j < row.ncol; j++) {
c = row.col[j];
for(k=0; k<c->nw; k++){
ids = realloc(ids, (nids+1)*sizeof(int));
for (k = 0; k < c->nw; k++) {
ids = realloc(ids, (nids + 1) * sizeof(int));
ids[nids++] = c->w[k]->id;
}
}
@ -624,16 +577,16 @@ fsysread(Xfid *x, Fid *f)
qsort(ids, nids, sizeof ids[0], idcmp);
j = 0;
dt.name = buf;
for(; j<nids && i<e; i+=len){
for (; j < nids && i < e; i += len) {
k = ids[j];
sprint(dt.name, "%d", k);
dt.qid = QID(k, Qdir);
dt.type = QTDIR;
dt.perm = DMDIR|0700;
len = dostat(k, &dt, b+n, x->fcall.count-n, clock);
if(len == 0)
dt.perm = DMDIR | 0700;
len = dostat(k, &dt, b + n, x->fcall.count - n, clock);
if (len == 0)
break;
if(i >= o)
if (i >= o)
n += len;
j++;
}
@ -649,70 +602,54 @@ fsysread(Xfid *x, Fid *f)
return nil;
}
static
Xfid*
fsyswrite(Xfid *x, Fid *f)
{
static Xfid* fsyswrite(Xfid* x, Fid* f) {
USED(f);
sendp(x->c, (void*)xfidwrite);
return nil;
}
static
Xfid*
fsysclunk(Xfid *x, Fid *f)
{
static Xfid* fsysclunk(Xfid* x, Fid* f) {
fsysdelid(f->mntdir);
sendp(x->c, (void*)xfidclose);
return nil;
}
static
Xfid*
fsysremove(Xfid *x, Fid *f)
{
static Xfid* fsysremove(Xfid* x, Fid* f) {
Fcall t;
USED(f);
return respond(x, &t, Eperm);
}
static
Xfid*
fsysstat(Xfid *x, Fid *f)
{
static Xfid* fsysstat(Xfid* x, Fid* f) {
Fcall t;
t.stat = emalloc(messagesize-IOHDRSZ);
t.nstat = dostat(WIN(x->f->qid), f->dir, t.stat, messagesize-IOHDRSZ, getclock());
t.stat = emalloc(messagesize - IOHDRSZ);
t.nstat =
dostat(WIN(x->f->qid), f->dir, t.stat, messagesize - IOHDRSZ, getclock());
x = respond(x, &t, nil);
free(t.stat);
return x;
}
static
Xfid*
fsyswstat(Xfid *x, Fid *f)
{
static Xfid* fsyswstat(Xfid* x, Fid* f) {
Fcall t;
USED(f);
return respond(x, &t, Eperm);
}
Fid*
newfid(int fid)
{
Fid* newfid(int fid) {
Fid *f, *ff, **fh;
ff = nil;
fh = &fids[fid&(Nhash-1)];
for(f=*fh; f; f=f->next)
if(f->fid == fid)
fh = &fids[fid & (Nhash - 1)];
for (f = *fh; f; f = f->next)
if (f->fid == fid)
return f;
else if(ff==nil && f->busy==FALSE)
else if (ff == nil && f->busy == FALSE)
ff = f;
if(ff){
if (ff) {
ff->fid = fid;
return ff;
}
@ -723,15 +660,9 @@ newfid(int fid)
return f;
}
uint
getclock(void)
{
return time(0);
}
uint getclock(void) { return time(0); }
int
dostat(int id, Dirtab *dir, uchar *buf, int nbuf, uint clock)
{
int dostat(int id, Dirtab* dir, uchar* buf, int nbuf, uint clock) {
Dir d;
d.qid.path = QID(id, dir->qid);

99
logf.c
View file

@ -14,40 +14,37 @@
// State for global log file.
typedef struct Log Log;
struct Log
{
struct Log {
QLock lk;
Rendez r;
vlong start; // msg[0] corresponds to 'start' in the global sequence of events
// queued events (nev=entries in ev, mev=capacity of p)
char **ev;
char** ev;
int nev;
int mev;
// open acme/put files that need to read events
Fid **f;
Fid** f;
int nf;
int mf;
// active (blocked) reads waiting for events
Xfid **read;
Xfid** read;
int nread;
int mread;
};
static Log eventlog;
void
xfidlogopen(Xfid *x)
{
void xfidlogopen(Xfid* x) {
qlock(&eventlog.lk);
if(eventlog.nf >= eventlog.mf) {
eventlog.mf = eventlog.mf*2;
if(eventlog.mf == 0)
if (eventlog.nf >= eventlog.mf) {
eventlog.mf = eventlog.mf * 2;
if (eventlog.mf == 0)
eventlog.mf = 8;
eventlog.f = erealloc(eventlog.f, eventlog.mf*sizeof eventlog.f[0]);
eventlog.f = erealloc(eventlog.f, eventlog.mf * sizeof eventlog.f[0]);
}
eventlog.f[eventlog.nf++] = x->f;
x->f->logoff = eventlog.start + eventlog.nev;
@ -55,14 +52,12 @@ xfidlogopen(Xfid *x)
qunlock(&eventlog.lk);
}
void
xfidlogclose(Xfid *x)
{
void xfidlogclose(Xfid* x) {
int i;
qlock(&eventlog.lk);
for(i=0; i<eventlog.nf; i++) {
if(eventlog.f[i] == x->f) {
for (i = 0; i < eventlog.nf; i++) {
if (eventlog.f[i] == x->f) {
eventlog.f[i] = eventlog.f[--eventlog.nf];
break;
}
@ -70,36 +65,35 @@ xfidlogclose(Xfid *x)
qunlock(&eventlog.lk);
}
void
xfidlogread(Xfid *x)
{
char *p;
void xfidlogread(Xfid* x) {
char* p;
int i;
Fcall fc;
qlock(&eventlog.lk);
if(eventlog.nread >= eventlog.mread) {
eventlog.mread = eventlog.mread*2;
if(eventlog.mread == 0)
if (eventlog.nread >= eventlog.mread) {
eventlog.mread = eventlog.mread * 2;
if (eventlog.mread == 0)
eventlog.mread = 8;
eventlog.read = erealloc(eventlog.read, eventlog.mread*sizeof eventlog.read[0]);
eventlog.read =
erealloc(eventlog.read, eventlog.mread * sizeof eventlog.read[0]);
}
eventlog.read[eventlog.nread++] = x;
if(eventlog.r.l == nil)
if (eventlog.r.l == nil)
eventlog.r.l = &eventlog.lk;
x->flushed = FALSE;
while(x->f->logoff >= eventlog.start+eventlog.nev && !x->flushed)
while (x->f->logoff >= eventlog.start + eventlog.nev && !x->flushed)
rsleep(&eventlog.r);
for(i=0; i<eventlog.nread; i++) {
if(eventlog.read[i] == x) {
for (i = 0; i < eventlog.nread; i++) {
if (eventlog.read[i] == x) {
eventlog.read[i] = eventlog.read[--eventlog.nread];
break;
}
}
if(x->flushed) {
if (x->flushed) {
qunlock(&eventlog.lk);
return;
}
@ -115,16 +109,14 @@ xfidlogread(Xfid *x)
free(p);
}
void
xfidlogflush(Xfid *x)
{
void xfidlogflush(Xfid* x) {
int i;
Xfid *rx;
Xfid* rx;
qlock(&eventlog.lk);
for(i=0; i<eventlog.nread; i++) {
for (i = 0; i < eventlog.nread; i++) {
rx = eventlog.read[i];
if(rx->fcall.tag == x->fcall.oldtag) {
if (rx->fcall.tag == x->fcall.oldtag) {
rx->flushed = TRUE;
rwakeupall(&eventlog.r);
}
@ -153,46 +145,47 @@ xfidlogflush(Xfid *x)
* op == "del" for deleted window
* - called from winclose
*/
void
xfidlog(Window *w, char *op)
{
void xfidlog(Window* w, char* op) {
int i, n;
vlong min;
File *f;
char *name;
File* f;
char* name;
qlock(&eventlog.lk);
if(eventlog.nev >= eventlog.mev) {
if (eventlog.nev >= eventlog.mev) {
// Remove and free any entries that all readers have read.
min = eventlog.start + eventlog.nev;
for(i=0; i<eventlog.nf; i++) {
if(min > eventlog.f[i]->logoff)
for (i = 0; i < eventlog.nf; i++) {
if (min > eventlog.f[i]->logoff)
min = eventlog.f[i]->logoff;
}
if(min > eventlog.start) {
if (min > eventlog.start) {
n = min - eventlog.start;
for(i=0; i<n; i++)
for (i = 0; i < n; i++)
free(eventlog.ev[i]);
eventlog.nev -= n;
eventlog.start += n;
memmove(eventlog.ev, eventlog.ev+n, eventlog.nev*sizeof eventlog.ev[0]);
memmove(
eventlog.ev,
eventlog.ev + n,
eventlog.nev * sizeof eventlog.ev[0]);
}
// Otherwise grow.
if(eventlog.nev >= eventlog.mev) {
eventlog.mev = eventlog.mev*2;
if(eventlog.mev == 0)
if (eventlog.nev >= eventlog.mev) {
eventlog.mev = eventlog.mev * 2;
if (eventlog.mev == 0)
eventlog.mev = 8;
eventlog.ev = erealloc(eventlog.ev, eventlog.mev*sizeof eventlog.ev[0]);
eventlog.ev = erealloc(eventlog.ev, eventlog.mev * sizeof eventlog.ev[0]);
}
}
f = w->body.file;
name = runetobyte(f->name, f->nname);
if(name == nil)
if (name == nil)
name = estrdup("");
eventlog.ev[eventlog.nev++] = smprint("%d %s %s\n", w->id, op, name);
free(name);
if(eventlog.r.l == nil)
if (eventlog.r.l == nil)
eventlog.r.l = &eventlog.lk;
rwakeupall(&eventlog.r);
qunlock(&eventlog.lk);

599
look.c
View file

File diff suppressed because it is too large Load diff

32
mail/html.c
View file

@ -7,23 +7,21 @@
#include <9pclient.h>
#include "dat.h"
char*
formathtml(char *body, int *np)
{
char* formathtml(char* body, int* np) {
int i, j, p[2], q[2];
Exec *e;
Exec* e;
char buf[1024];
Channel *sync;
Channel* sync;
e = emalloc(sizeof(struct Exec));
if(pipe(p) < 0 || pipe(q) < 0)
if (pipe(p) < 0 || pipe(q) < 0)
error("can't create pipe: %r");
e->p[0] = p[0];
e->p[1] = p[1];
e->q[0] = q[0];
e->q[1] = q[1];
e->argv = emalloc(3*sizeof(char*));
e->argv = emalloc(3 * sizeof(char*));
e->argv[0] = estrdup("htmlfmt");
e->argv[1] = estrdup("-cutf-8");
e->argv[2] = nil;
@ -35,7 +33,7 @@ formathtml(char *body, int *np)
close(p[0]);
close(q[1]);
if((i=write(p[1], body, *np)) != *np){
if ((i = write(p[1], body, *np)) != *np) {
fprint(2, "Mail: warning: htmlfmt failed: wrote %d of %d: %r\n", i, *np);
close(p[1]);
close(q[0]);
@ -46,14 +44,14 @@ formathtml(char *body, int *np)
free(body);
body = nil;
i = 0;
for(;;){
for (;;) {
j = read(q[0], buf, sizeof buf);
if(j <= 0)
if (j <= 0)
break;
body = realloc(body, i+j+1);
if(body == nil)
body = realloc(body, i + j + 1);
if (body == nil)
error("realloc failed: %r");
memmove(body+i, buf, j);
memmove(body + i, buf, j);
i += j;
body[i] = '\0';
}
@ -63,13 +61,11 @@ formathtml(char *body, int *np)
return body;
}
char*
readbody(char *type, char *dir, int *np)
{
char *body;
char* readbody(char* type, char* dir, int* np) {
char* body;
body = readfile(dir, "body", np);
if(body != nil && strcmp(type, "text/html") == 0)
if (body != nil && strcmp(type, "text/html") == 0)
return formathtml(body, np);
return body;
}

BIN
mail/html.o
View file

Binary file not shown.

392
mail/mail.c
View file

@ -7,25 +7,25 @@
#include <ctype.h>
#include "dat.h"
char *maildir = "Mail/"; /* mountpoint of mail file system */
char *mboxname = "mbox"; /* mailboxdir/mboxname is mail spool file */
char *mailboxdir = nil; /* nil == /mail/box/$user */
char *fsname; /* filesystem for mailboxdir/mboxname is at maildir/fsname */
char *user;
char *outgoing;
char *srvname;
char* maildir = "Mail/"; /* mountpoint of mail file system */
char* mboxname = "mbox"; /* mailboxdir/mboxname is mail spool file */
char* mailboxdir = nil; /* nil == /mail/box/$user */
char* fsname; /* filesystem for mailboxdir/mboxname is at maildir/fsname */
char* user;
char* outgoing;
char* srvname;
Window *wbox;
Window* wbox;
Message mbox;
Message replies;
char *home;
CFid *plumbsendfd;
CFid *plumbseemailfd;
CFid *plumbshowmailfd;
CFid *plumbsendmailfd;
Channel *cplumb;
Channel *cplumbshow;
Channel *cplumbsend;
char* home;
CFid* plumbsendfd;
CFid* plumbseemailfd;
CFid* plumbshowmailfd;
CFid* plumbsendmailfd;
Channel* cplumb;
Channel* cplumbshow;
Channel* cplumbsend;
int wctlfd;
void mainctl(void*);
void plumbproc(void*);
@ -37,44 +37,39 @@ void plumbsendthread(void*);
int shortmenu;
CFsys *mailfs;
CFsys *acmefs;
CFsys* mailfs;
CFsys* acmefs;
void
usage(void)
{
fprint(2, "usage: Mail [-sS] [-n srvname] [-o outgoing] [mailboxname [directoryname]]\n");
void usage(void) {
fprint(
2,
"usage: Mail [-sS] [-n srvname] [-o outgoing] [mailboxname "
"[directoryname]]\n");
threadexitsall("usage");
}
void
removeupasfs(void)
{
void removeupasfs(void) {
char buf[256];
if(strcmp(mboxname, "mbox") == 0)
if (strcmp(mboxname, "mbox") == 0)
return;
snprint(buf, sizeof buf, "close %s", mboxname);
fswrite(mbox.ctlfd, buf, strlen(buf));
}
int
ismaildir(char *s)
{
Dir *d;
int ismaildir(char* s) {
Dir* d;
int ret;
d = fsdirstat(mailfs, s);
if(d == nil)
if (d == nil)
return 0;
ret = d->qid.type & QTDIR;
free(d);
return ret;
}
void
threadmain(int argc, char *argv[])
{
void threadmain(int argc, char* argv[]) {
char *s, *name;
char err[ERRMAX], *cmd;
int i, newdir;
@ -83,17 +78,18 @@ threadmain(int argc, char *argv[])
doquote = needsrcquote;
quotefmtinstall();
/* open these early so we won't miss notification of new mail messages while we read mbox */
if((plumbsendfd = plumbopenfid("send", OWRITE|OCEXEC)) == nil)
/* open these early so we won't miss notification of new mail messages while
* we read mbox */
if ((plumbsendfd = plumbopenfid("send", OWRITE | OCEXEC)) == nil)
fprint(2, "warning: open plumb/send: %r\n");
if((plumbseemailfd = plumbopenfid("seemail", OREAD|OCEXEC)) == nil)
if ((plumbseemailfd = plumbopenfid("seemail", OREAD | OCEXEC)) == nil)
fprint(2, "warning: open plumb/seemail: %r\n");
if((plumbshowmailfd = plumbopenfid("showmail", OREAD|OCEXEC)) == nil)
if ((plumbshowmailfd = plumbopenfid("showmail", OREAD | OCEXEC)) == nil)
fprint(2, "warning: open plumb/showmail: %r\n");
shortmenu = 0;
srvname = "mail";
ARGBEGIN{
ARGBEGIN {
case 's':
shortmenu = 1;
break;
@ -111,41 +107,42 @@ threadmain(int argc, char *argv[])
break;
default:
usage();
}ARGEND
}
ARGEND
acmefs = nsmount("acme",nil);
if(acmefs == nil)
acmefs = nsmount("acme", nil);
if (acmefs == nil)
error("cannot mount acme: %r");
mailfs = nsmount(srvname, nil);
if(mailfs == nil)
if (mailfs == nil)
error("cannot mount %s: %r", srvname);
name = "mbox";
newdir = 1;
if(argc > 0){
if (argc > 0) {
i = strlen(argv[0]);
if(argc>2 || i==0)
if (argc > 2 || i == 0)
usage();
/* see if the name is that of an existing /mail/fs directory */
if(argc==1 && argv[0][0] != '/' && ismaildir(argv[0])){
if (argc == 1 && argv[0][0] != '/' && ismaildir(argv[0])) {
name = argv[0];
mboxname = estrdup(name);
newdir = 0;
}else{
if(argv[0][i-1] == '/')
argv[0][i-1] = '\0';
} else {
if (argv[0][i - 1] == '/')
argv[0][i - 1] = '\0';
s = strrchr(argv[0], '/');
if(s == nil)
if (s == nil)
mboxname = estrdup(argv[0]);
else{
else {
*s++ = '\0';
if(*s == '\0')
if (*s == '\0')
usage();
mailboxdir = argv[0];
mboxname = estrdup(s);
}
if(argc > 1)
if (argc > 1)
name = argv[1];
else
name = mboxname;
@ -153,64 +150,65 @@ threadmain(int argc, char *argv[])
}
user = getenv("user");
if(user == nil)
if (user == nil)
user = "none";
home = getenv("home");
if(home == nil)
if (home == nil)
home = getenv("HOME");
if(home == nil)
if (home == nil)
error("can't find $home");
if(mailboxdir == nil)
if (mailboxdir == nil)
mailboxdir = estrstrdup(home, "/mail");
if(outgoing == nil)
if (outgoing == nil)
outgoing = estrstrdup(mailboxdir, "/outgoing");
mbox.ctlfd = fsopen(mailfs, estrstrdup(mboxname, "/ctl"), OWRITE);
if(mbox.ctlfd == nil)
if (mbox.ctlfd == nil)
error("can't open %s: %r", estrstrdup(mboxname, "/ctl"));
fsname = estrdup(name);
if(newdir && argc > 0){
s = emalloc(5+strlen(mailboxdir)+strlen(mboxname)+strlen(name)+10+1);
for(i=0; i<10; i++){
if (newdir && argc > 0) {
s = emalloc(
5 + strlen(mailboxdir) + strlen(mboxname) + strlen(name) + 10 + 1);
for (i = 0; i < 10; i++) {
sprint(s, "open %s/%s %s", mailboxdir, mboxname, fsname);
if(fswrite(mbox.ctlfd, s, strlen(s)) >= 0)
if (fswrite(mbox.ctlfd, s, strlen(s)) >= 0)
break;
err[0] = '\0';
errstr(err, sizeof err);
if(strstr(err, "mbox name in use") == nil)
if (strstr(err, "mbox name in use") == nil)
error("can't create directory %s for mail: %s", name, err);
free(fsname);
fsname = emalloc(strlen(name)+10);
fsname = emalloc(strlen(name) + 10);
sprint(fsname, "%s-%d", name, i);
}
if(i == 10)
if (i == 10)
error("can't open %s/%s: %r", mailboxdir, mboxname);
free(s);
}
s = estrstrdup(fsname, "/");
mbox.name = estrstrdup(maildir, s);
mbox.level= 0;
mbox.level = 0;
readmbox(&mbox, maildir, s);
home = getenv("home");
if(home == nil)
if (home == nil)
home = "/";
wbox = newwindow();
winname(wbox, mbox.name);
wintagwrite(wbox, "Put Mail Delmesg ", 3+1+4+1+7+1);
wintagwrite(wbox, "Put Mail Delmesg ", 3 + 1 + 4 + 1 + 7 + 1);
threadcreate(mainctl, wbox, STACK);
fmtstrinit(&fmt);
fmtprint(&fmt, "Mail");
if(shortmenu)
fmtprint(&fmt, " -%c", "sS"[shortmenu-1]);
if(outgoing)
if (shortmenu)
fmtprint(&fmt, " -%c", "sS"[shortmenu - 1]);
if (outgoing)
fmtprint(&fmt, " -o %s", outgoing);
fmtprint(&fmt, " %s", name);
cmd = fmtstrflush(&fmt);
if(cmd == nil)
if (cmd == nil)
sysfatal("out of memory");
winsetdump(wbox, "/acme/mail", cmd);
mbox.w = wbox;
@ -218,16 +216,16 @@ threadmain(int argc, char *argv[])
mesgmenu(wbox, &mbox);
winclean(wbox);
/* wctlfd = open("/dev/wctl", OWRITE|OCEXEC); /* for acme window */
/* wctlfd = open("/dev/wctl", OWRITE|OCEXEC); /* for acme window */
wctlfd = -1;
cplumb = chancreate(sizeof(Plumbmsg*), 0);
cplumbshow = chancreate(sizeof(Plumbmsg*), 0);
if(strcmp(name, "mbox") == 0){
if (strcmp(name, "mbox") == 0) {
/*
* Avoid creating multiple windows to send mail by only accepting
* sendmail plumb messages if we're reading the main mailbox.
*/
plumbsendmailfd = plumbopenfid("sendmail", OREAD|OCEXEC);
plumbsendmailfd = plumbopenfid("sendmail", OREAD | OCEXEC);
cplumbsend = chancreate(sizeof(Plumbmsg*), 0);
proccreate(plumbsendproc, nil, STACK);
threadcreate(plumbsendthread, nil, STACK);
@ -241,120 +239,106 @@ threadmain(int argc, char *argv[])
plumbthread();
}
void
plumbproc(void* v)
{
Plumbmsg *m;
void plumbproc(void* v) {
Plumbmsg* m;
threadsetname("plumbproc");
for(;;){
for (;;) {
m = plumbrecvfid(plumbseemailfd);
sendp(cplumb, m);
if(m == nil)
if (m == nil)
threadexits(nil);
}
}
void
plumbshowproc(void* v)
{
Plumbmsg *m;
void plumbshowproc(void* v) {
Plumbmsg* m;
threadsetname("plumbshowproc");
for(;;){
for (;;) {
m = plumbrecvfid(plumbshowmailfd);
sendp(cplumbshow, m);
if(m == nil)
if (m == nil)
threadexits(nil);
}
}
void
plumbsendproc(void* v)
{
Plumbmsg *m;
void plumbsendproc(void* v) {
Plumbmsg* m;
threadsetname("plumbsendproc");
for(;;){
for (;;) {
m = plumbrecvfid(plumbsendmailfd);
sendp(cplumbsend, m);
if(m == nil)
if (m == nil)
threadexits(nil);
}
}
void
newmesg(char *name, char *digest)
{
Dir *d;
void newmesg(char* name, char* digest) {
Dir* d;
if(strncmp(name, mbox.name, strlen(mbox.name)) != 0)
if (strncmp(name, mbox.name, strlen(mbox.name)) != 0)
return; /* message is about another mailbox */
if(mesglookupfile(&mbox, name, digest) != nil)
if (mesglookupfile(&mbox, name, digest) != nil)
return;
if(strncmp(name, "Mail/", 5) == 0)
if (strncmp(name, "Mail/", 5) == 0)
name += 5;
d = fsdirstat(mailfs, name);
if(d == nil)
if (d == nil)
return;
if(mesgadd(&mbox, mbox.name, d, digest))
if (mesgadd(&mbox, mbox.name, d, digest))
mesgmenunew(wbox, &mbox);
free(d);
}
void
showmesg(char *name, char *digest)
{
char *n;
char *mb;
void showmesg(char* name, char* digest) {
char* n;
char* mb;
mb = mbox.name;
if(strncmp(name, mb, strlen(mb)) != 0)
if (strncmp(name, mb, strlen(mb)) != 0)
return; /* message is about another mailbox */
n = estrdup(name+strlen(mb));
if(n[strlen(n)-1] != '/')
n = estrdup(name + strlen(mb));
if (n[strlen(n) - 1] != '/')
n = egrow(n, "/", nil);
mesgopen(&mbox, mbox.name, name+strlen(mb), nil, 1, digest);
mesgopen(&mbox, mbox.name, name + strlen(mb), nil, 1, digest);
free(n);
}
void
delmesg(char *name, char *digest, int dodel, char *save)
{
Message *m;
void delmesg(char* name, char* digest, int dodel, char* save) {
Message* m;
m = mesglookupfile(&mbox, name, digest);
if(m != nil){
if(save)
if (m != nil) {
if (save)
mesgcommand(m, estrstrdup("Save ", save));
if(dodel)
if (dodel)
mesgmenumarkdel(wbox, &mbox, m, 1);
else{
else {
/* notification came from plumber - message is gone */
mesgmenudel(wbox, &mbox, m);
if(!m->opened)
if (!m->opened)
mesgdel(&mbox, m);
}
}
}
void
plumbthread(void)
{
Plumbmsg *m;
Plumbattr *a;
void plumbthread(void) {
Plumbmsg* m;
Plumbattr* a;
char *type, *digest;
threadsetname("plumbthread");
while((m = recvp(cplumb)) != nil){
while ((m = recvp(cplumb)) != nil) {
a = m->attr;
digest = plumblookup(a, "digest");
type = plumblookup(a, "mailtype");
if(type == nil)
if (type == nil)
fprint(2, "Mail: plumb message with no mailtype attribute\n");
else if(strcmp(type, "new") == 0)
else if (strcmp(type, "new") == 0)
newmesg(m->data, digest);
else if(strcmp(type, "delete") == 0)
else if (strcmp(type, "delete") == 0)
delmesg(m->data, digest, 0, nil);
else
fprint(2, "Mail: unknown plumb attribute %s\n", type);
@ -363,116 +347,111 @@ plumbthread(void)
threadexits(nil);
}
void
plumbshowthread(void *v)
{
Plumbmsg *m;
void plumbshowthread(void* v) {
Plumbmsg* m;
USED(v);
threadsetname("plumbshowthread");
while((m = recvp(cplumbshow)) != nil){
while ((m = recvp(cplumbshow)) != nil) {
showmesg(m->data, plumblookup(m->attr, "digest"));
plumbfree(m);
}
threadexits(nil);
}
void
plumbsendthread(void *v)
{
Plumbmsg *m;
void plumbsendthread(void* v) {
Plumbmsg* m;
USED(v);
threadsetname("plumbsendthread");
while((m = recvp(cplumbsend)) != nil){
while ((m = recvp(cplumbsend)) != nil) {
mkreply(nil, "Mail", m->data, m->attr, nil);
plumbfree(m);
}
threadexits(nil);
}
int
mboxcommand(Window *w, char *s)
{
int mboxcommand(Window* w, char* s) {
char *args[10], **targs, *save;
Window *sbox;
Window* sbox;
Message *m, *next;
int ok, nargs, i, j;
CFid *searchfd;
CFid* searchfd;
char buf[128], *res;
nargs = tokenize(s, args, nelem(args));
if(nargs == 0)
if (nargs == 0)
return 0;
if(strcmp(args[0], "Mail") == 0){
if(nargs == 1)
if (strcmp(args[0], "Mail") == 0) {
if (nargs == 1)
mkreply(nil, "Mail", "", nil, nil);
else
mkreply(nil, "Mail", args[1], nil, nil);
return 1;
}
if(strcmp(s, "Del") == 0){
if(mbox.dirty){
if (strcmp(s, "Del") == 0) {
if (mbox.dirty) {
mbox.dirty = 0;
fprint(2, "mail: mailbox not written\n");
return 1;
}
if(w != mbox.w){
if (w != mbox.w) {
windel(w, 1);
return 1;
}
ok = 1;
for(m=mbox.head; m!=nil; m=next){
for (m = mbox.head; m != nil; m = next) {
next = m->next;
if(m->w){
if(windel(m->w, 0))
if (m->w) {
if (windel(m->w, 0))
m->w = nil;
else
ok = 0;
}
}
for(m=replies.head; m!=nil; m=next){
for (m = replies.head; m != nil; m = next) {
next = m->next;
if(m->w){
if(windel(m->w, 0))
if (m->w) {
if (windel(m->w, 0))
m->w = nil;
else
ok = 0;
}
}
if(ok){
if (ok) {
windel(w, 1);
removeupasfs();
threadexitsall(nil);
}
return 1;
}
if(strcmp(s, "Put") == 0){
if (strcmp(s, "Put") == 0) {
rewritembox(wbox, &mbox);
return 1;
}
if(strcmp(s, "Get") == 0){
if (strcmp(s, "Get") == 0) {
fswrite(mbox.ctlfd, "refresh", 7);
return 1;
}
if(strcmp(s, "Delmesg") == 0){
if (strcmp(s, "Delmesg") == 0) {
save = nil;
if(nargs > 1)
if (nargs > 1)
save = args[1];
s = winselection(w);
if(s == nil)
if (s == nil)
return 1;
nargs = 1;
for(i=0; s[i]; i++)
if(s[i] == '\n')
for (i = 0; s[i]; i++)
if (s[i] == '\n')
nargs++;
targs = emalloc(nargs*sizeof(char*)); /* could be too many for a local array */
targs =
emalloc(nargs * sizeof(char*)); /* could be too many for a local array */
nargs = getfields(s, targs, nargs, 1, "\n");
for(i=0; i<nargs; i++){
if(!isdigit(targs[i][0]))
for (i = 0; i < nargs; i++) {
if (!isdigit(targs[i][0]))
continue;
j = atoi(targs[i]); /* easy way to parse the number! */
if(j == 0)
if (j == 0)
continue;
snprint(buf, sizeof buf, "%s%d", mbox.name, j);
delmesg(buf, nil, 1, save);
@ -481,20 +460,20 @@ mboxcommand(Window *w, char *s)
free(targs);
return 1;
}
if(strcmp(s, "Search") == 0){
if(nargs <= 1)
if (strcmp(s, "Search") == 0) {
if (nargs <= 1)
return 1;
s = estrstrdup(mboxname, "/search");
searchfd = fsopen(mailfs, s, ORDWR);
if(searchfd == nil)
if (searchfd == nil)
return 1;
save = estrdup(args[1]);
for(i=2; i<nargs; i++)
for (i = 2; i < nargs; i++)
save = eappend(save, " ", args[i]);
fswrite(searchfd, save, strlen(save));
fsseek(searchfd, 0, 0);
j = fsread(searchfd, buf, sizeof buf - 1);
if(j == 0){
if (j == 0) {
fprint(2, "[%s] search %s: no results found\n", mboxname, save);
fsclose(searchfd);
free(save);
@ -504,7 +483,7 @@ mboxcommand(Window *w, char *s)
buf[j] = '\0';
res = estrdup(buf);
j = fsread(searchfd, buf, sizeof buf - 1);
for(; j != 0; j = fsread(searchfd, buf, sizeof buf - 1), buf[j] = '\0')
for (; j != 0; j = fsread(searchfd, buf, sizeof buf - 1), buf[j] = '\0')
res = eappend(res, "", buf);
fsclose(searchfd);
@ -517,16 +496,18 @@ mboxcommand(Window *w, char *s)
/* show results in reverse order */
m = mbox.tail;
save = nil;
for(s=strrchr(res, ' '); s!=nil || save!=res; s=strrchr(res, ' ')){
if(s != nil){
save = s+1;
for (s = strrchr(res, ' '); s != nil || save != res;
s = strrchr(res, ' ')) {
if (s != nil) {
save = s + 1;
*s = '\0';
}
else save = res;
} else
save = res;
save = estrstrdup(save, "/");
for(; m && strcmp(save, m->name) != 0; m=m->prev);
for (; m && strcmp(save, m->name) != 0; m = m->prev)
;
free(save);
if(m == nil)
if (m == nil)
break;
fsprint(sbox->body, "%s%s\n", m->name, info(m, 0, 0));
m = m->prev;
@ -539,10 +520,8 @@ mboxcommand(Window *w, char *s)
return 0;
}
void
mainctl(void *v)
{
Window *w;
void mainctl(void* v) {
Window* w;
Event *e, *e2, *eq, *ea;
int na, nopen;
char *s, *t, *buf;
@ -551,9 +530,9 @@ mainctl(void *v)
winincref(w);
proccreate(wineventproc, w, STACK);
for(;;){
for (;;) {
e = recvp(w->cevent);
switch(e->c1){
switch (e->c1) {
default:
Unknown:
print("unknown message %c%c\n", e->c1, e->c2);
@ -569,32 +548,32 @@ mainctl(void *v)
break;
case 'M':
switch(e->c2){
switch (e->c2) {
case 'x':
case 'X':
ea = nil;
e2 = nil;
if(e->flag & 2)
if (e->flag & 2)
e2 = recvp(w->cevent);
if(e->flag & 8){
if (e->flag & 8) {
ea = recvp(w->cevent);
na = ea->nb;
recvp(w->cevent);
}else
} else
na = 0;
s = e->b;
/* if it's a known command, do it */
if((e->flag&2) && e->nb==0)
if ((e->flag & 2) && e->nb == 0)
s = e2->b;
if(na){
t = emalloc(strlen(s)+1+na+1);
if (na) {
t = emalloc(strlen(s) + 1 + na + 1);
sprint(t, "%s %s", s, ea->b);
s = t;
}
/* if it's a long message, it can't be for us anyway */
if(!mboxcommand(w, s)) /* send it back */
if (!mboxcommand(w, s)) /* send it back */
winwriteevent(w, e);
if(na)
if (na)
free(s);
break;
@ -602,29 +581,29 @@ mainctl(void *v)
case 'L':
buf = nil;
eq = e;
if(e->flag & 2){
if (e->flag & 2) {
e2 = recvp(w->cevent);
eq = e2;
}
s = eq->b;
if(eq->q1>eq->q0 && eq->nb==0){
buf = emalloc((eq->q1-eq->q0)*UTFmax+1);
if (eq->q1 > eq->q0 && eq->nb == 0) {
buf = emalloc((eq->q1 - eq->q0) * UTFmax + 1);
winread(w, eq->q0, eq->q1, buf);
s = buf;
}
nopen = 0;
do{
do {
/* skip 'deleted' string if present' */
if(strncmp(s, deleted, strlen(deleted)) == 0)
if (strncmp(s, deleted, strlen(deleted)) == 0)
s += strlen(deleted);
/* skip mail box name if present */
if(strncmp(s, mbox.name, strlen(mbox.name)) == 0)
if (strncmp(s, mbox.name, strlen(mbox.name)) == 0)
s += strlen(mbox.name);
nopen += mesgopen(&mbox, mbox.name, s, nil, 0, nil);
while(*s!='\0' && *s++!='\n')
while (*s != '\0' && *s++ != '\n')
;
}while(*s);
if(nopen == 0) /* send it back */
} while (*s);
if (nopen == 0) /* send it back */
winwriteevent(w, e);
free(buf);
break;
@ -641,4 +620,3 @@ mainctl(void *v)
}
}
}

BIN
mail/mail.o
View file

Binary file not shown.

958
mail/mesg.c
View file

File diff suppressed because it is too large Load diff

BIN
mail/mesg.o
View file

Binary file not shown.

BIN
mail/o.Mail
View file

Binary file not shown.

354
mail/reply.c
View file

@ -9,56 +9,56 @@
static int replyid;
int
quote(Message *m, CFid *fid, char *dir, char *quotetext)
{
int quote(Message* m, CFid* fid, char* dir, char* quotetext) {
char *body, *type;
int i, n, nlines;
char **lines;
char** lines;
if(quotetext){
if (quotetext) {
body = quotetext;
n = strlen(body);
type = nil;
}else{
} else {
/* look for first textual component to quote */
type = readfile(dir, "type", &n);
if(type == nil){
if (type == nil) {
print("no type in %s\n", dir);
return 0;
}
if(strncmp(type, "multipart/", 10)==0 || strncmp(type, "message/", 8)==0){
if (
strncmp(type, "multipart/", 10) == 0 ||
strncmp(type, "message/", 8) == 0) {
dir = estrstrdup(dir, "1/");
if(quote(m, fid, dir, nil)){
if (quote(m, fid, dir, nil)) {
free(type);
free(dir);
return 1;
}
free(dir);
}
if(strncmp(type, "text", 4) != 0){
if (strncmp(type, "text", 4) != 0) {
free(type);
return 0;
}
body = readbody(m->type, dir, &n);
if(body == nil)
if (body == nil)
return 0;
}
nlines = 0;
for(i=0; i<n; i++)
if(body[i] == '\n')
for (i = 0; i < n; i++)
if (body[i] == '\n')
nlines++;
nlines++;
lines = emalloc(nlines*sizeof(char*));
lines = emalloc(nlines * sizeof(char*));
nlines = getfields(body, lines, nlines, 0, "\n");
/* delete leading and trailing blank lines */
i = 0;
while(i<nlines && lines[i][0]=='\0')
while (i < nlines && lines[i][0] == '\0')
i++;
while(i<nlines && lines[nlines-1][0]=='\0')
while (i < nlines && lines[nlines - 1][0] == '\0')
nlines--;
while(i < nlines){
fsprint(fid, ">%s%s\n", lines[i][0]=='>'? "" : " ", lines[i]);
while (i < nlines) {
fsprint(fid, ">%s%s\n", lines[i][0] == '>' ? "" : " ", lines[i]);
i++;
}
free(lines);
@ -67,21 +67,20 @@ quote(Message *m, CFid *fid, char *dir, char *quotetext)
return 1;
}
void
mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
{
void mkreply(
Message* m, char* label, char* to, Plumbattr* attr, char* quotetext) {
char buf[100];
CFid *fd;
Message *r;
CFid* fd;
Message* r;
char *dir, *t;
int quotereply;
Plumbattr *a;
Plumbattr* a;
quotereply = (label[0] == 'Q');
if(quotereply && m && m->replywinid > 0){
if (quotereply && m && m->replywinid > 0) {
snprint(buf, sizeof buf, "%d/body", m->replywinid);
if((fd = fsopen(acmefs, buf, OWRITE)) != nil){
if ((fd = fsopen(acmefs, buf, OWRITE)) != nil) {
dir = estrstrdup(mbox.name, m->name);
quote(m, fd, dir, quotetext);
free(dir);
@ -91,67 +90,69 @@ mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
r = emalloc(sizeof(Message));
r->isreply = 1;
if(m != nil)
if (m != nil)
r->replyname = estrdup(m->name);
r->next = replies.head;
r->prev = nil;
if(replies.head != nil)
if (replies.head != nil)
replies.head->prev = r;
replies.head = r;
if(replies.tail == nil)
if (replies.tail == nil)
replies.tail = r;
r->name = emalloc(strlen(mbox.name)+strlen(label)+10);
r->name = emalloc(strlen(mbox.name) + strlen(label) + 10);
sprint(r->name, "%s%s%d", mbox.name, label, ++replyid);
r->w = newwindow();
if(m)
if (m)
m->replywinid = r->w->id;
winname(r->w, r->name);
ctlprint(r->w->ctl, "cleartag");
wintagwrite(r->w, "fmt Look Post Undo", 4+5+5+4);
wintagwrite(r->w, "fmt Look Post Undo", 4 + 5 + 5 + 4);
r->tagposted = 1;
threadcreate(mesgctl, r, STACK);
winopenbody(r->w, OWRITE);
if(to!=nil && to[0]!='\0')
if (to != nil && to[0] != '\0')
fsprint(r->w->body, "%s\n", to);
for(a=attr; a; a=a->next)
for (a = attr; a; a = a->next)
fsprint(r->w->body, "%s: %s\n", a->name, a->value);
dir = nil;
if(m != nil){
if (m != nil) {
dir = estrstrdup(mbox.name, m->name);
if(to == nil && attr == nil){
if (to == nil && attr == nil) {
/* Reply goes to replyto; Reply all goes to From and To and CC */
if(strstr(label, "all") == nil)
if (strstr(label, "all") == nil)
fsprint(r->w->body, "To: %s\n", m->replyto);
else{ /* Replyall */
if(strlen(m->from) > 0)
else { /* Replyall */
if (strlen(m->from) > 0)
fsprint(r->w->body, "To: %s\n", m->from);
if(strlen(m->to) > 0)
if (strlen(m->to) > 0)
fsprint(r->w->body, "To: %s\n", m->to);
if(strlen(m->cc) > 0)
if (strlen(m->cc) > 0)
fsprint(r->w->body, "CC: %s\n", m->cc);
}
}
if(strlen(m->subject) > 0){
if (strlen(m->subject) > 0) {
t = "Subject: Re: ";
if(strlen(m->subject) >= 3)
if(tolower(m->subject[0])=='r' && tolower(m->subject[1])=='e' && m->subject[2]==':')
if (strlen(m->subject) >= 3)
if (
tolower(m->subject[0]) == 'r' && tolower(m->subject[1]) == 'e' &&
m->subject[2] == ':')
t = "Subject: ";
fsprint(r->w->body, "%s%s\n", t, m->subject);
}
if(!quotereply){
if (!quotereply) {
fsprint(r->w->body, "Include: %sraw\n", dir);
free(dir);
}
}
fsprint(r->w->body, "\n");
if(m == nil)
if (m == nil)
fsprint(r->w->body, "\n");
else if(quotereply){
else if (quotereply) {
quote(m, r->w->body, dir, quotetext);
free(dir);
}
winclosebody(r->w);
if(m==nil && (to==nil || to[0]=='\0'))
if (m == nil && (to == nil || to[0] == '\0'))
winselect(r->w, "0", 0);
else
winselect(r->w, "$", 0);
@ -159,14 +160,12 @@ mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
windormant(r->w);
}
void
delreply(Message *m)
{
if(m->next == nil)
void delreply(Message* m) {
if (m->next == nil)
replies.tail = m->prev;
else
m->next->prev = m->prev;
if(m->prev == nil)
if (m->prev == nil)
replies.head = m->next;
else
m->prev->next = m->next;
@ -174,20 +173,19 @@ delreply(Message *m)
free(m);
}
/* copy argv to stack and free the incoming strings, so we don't leak argument vectors */
void
buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
{
/* copy argv to stack and free the incoming strings, so we don't leak argument
* vectors */
void buildargv(char** inargv, char* argv[NARGS + 1], char args[NARGCHAR]) {
int i, n;
char *s, *a;
s = args;
for(i=0; i<NARGS; i++){
for (i = 0; i < NARGS; i++) {
a = inargv[i];
if(a == nil)
if (a == nil)
break;
n = strlen(a)+1;
if((s-args)+n >= NARGCHAR) /* too many characters */
n = strlen(a) + 1;
if ((s - args) + n >= NARGCHAR) /* too many characters */
break;
argv[i] = s;
memmove(s, a, n);
@ -197,13 +195,11 @@ buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
argv[i] = nil;
}
void
execproc(void *v)
{
struct Exec *e;
void execproc(void* v) {
struct Exec* e;
int p[2], q[2];
char *prog;
char *argv[NARGS+1], args[NARGCHAR];
char* prog;
char *argv[NARGS + 1], args[NARGCHAR];
int fd[3];
e = v;
@ -214,7 +210,7 @@ execproc(void *v)
prog = e->prog; /* known not to be malloc'ed */
fd[0] = dup(p[0], -1);
if(q[0])
if (q[0])
fd[1] = dup(q[1], -1);
else
fd[1] = dup(1, -1);
@ -234,76 +230,53 @@ execproc(void *v)
threadexits("can't exec");
}
enum{
ATTACH,
BCC,
CC,
FROM,
INCLUDE,
TO
};
enum { ATTACH, BCC, CC, FROM, INCLUDE, TO };
char *headers[] = {
"attach:",
"bcc:",
"cc:",
"from:",
"include:",
"to:",
nil
};
char* headers[] = {"attach:", "bcc:", "cc:", "from:", "include:", "to:", nil};
int
whichheader(char *h)
{
int whichheader(char* h) {
int i;
for(i=0; headers[i]!=nil; i++)
if(cistrcmp(h, headers[i]) == 0)
for (i = 0; headers[i] != nil; i++)
if (cistrcmp(h, headers[i]) == 0)
return i;
return -1;
}
char *tolist[200];
char *cclist[200];
char *bcclist[200];
char* tolist[200];
char* cclist[200];
char* bcclist[200];
int ncc, nbcc, nto;
char *attlist[200];
char* attlist[200];
char included[200];
int
addressed(char *name)
{
int addressed(char* name) {
int i;
for(i=0; i<nto; i++)
if(strcmp(name, tolist[i]) == 0)
for (i = 0; i < nto; i++)
if (strcmp(name, tolist[i]) == 0)
return 1;
for(i=0; i<ncc; i++)
if(strcmp(name, cclist[i]) == 0)
for (i = 0; i < ncc; i++)
if (strcmp(name, cclist[i]) == 0)
return 1;
for(i=0; i<nbcc; i++)
if(strcmp(name, bcclist[i]) == 0)
for (i = 0; i < nbcc; i++)
if (strcmp(name, bcclist[i]) == 0)
return 1;
return 0;
}
char*
skipbl(char *s, char *e)
{
while(s < e){
if(*s!=' ' && *s!='\t' && *s!=',')
char* skipbl(char* s, char* e) {
while (s < e) {
if (*s != ' ' && *s != '\t' && *s != ',')
break;
s++;
}
return s;
}
char*
findbl(char *s, char *e)
{
while(s < e){
if(*s==' ' || *s=='\t' || *s==',')
char* findbl(char* s, char* e) {
while (s < e) {
if (*s == ' ' || *s == '\t' || *s == ',')
break;
s++;
}
@ -311,75 +284,70 @@ findbl(char *s, char *e)
}
/*
* comma-separate possibly blank-separated strings in line; e points before newline
* comma-separate possibly blank-separated strings in line; e points before
* newline
*/
void
commas(char *s, char *e)
{
char *t;
void commas(char* s, char* e) {
char* t;
/* may have initial blanks */
s = skipbl(s, e);
while(s < e){
while (s < e) {
s = findbl(s, e);
if(s == e)
if (s == e)
break;
t = skipbl(s, e);
if(t == e) /* no more words */
if (t == e) /* no more words */
break;
/* patch comma */
*s++ = ',';
while(s < t)
while (s < t)
*s++ = ' ';
}
}
int
print2(int fd, int ofd, char *fmt, ...)
{
int print2(int fd, int ofd, char* fmt, ...) {
int m, n;
char *s;
char* s;
va_list arg;
va_start(arg, fmt);
s = vsmprint(fmt, arg);
va_end(arg);
if(s == nil)
if (s == nil)
return -1;
m = strlen(s);
n = write(fd, s, m);
if(ofd > 0)
if (ofd > 0)
write(ofd, s, m);
return n;
}
void
write2(int fd, int ofd, char *buf, int n, int nofrom)
{
void write2(int fd, int ofd, char* buf, int n, int nofrom) {
char *from, *p;
int m;
write(fd, buf, n);
if(ofd <= 0)
if (ofd <= 0)
return;
if(nofrom == 0){
if (nofrom == 0) {
write(ofd, buf, n);
return;
}
/* need to escape leading From lines to avoid corrupting 'outgoing' mailbox */
for(p=buf; *p; p+=m){
for (p = buf; *p; p += m) {
from = cistrstr(p, "from");
if(from == nil)
if (from == nil)
m = n;
else
m = from - p;
if(m > 0)
if (m > 0)
write(ofd, p, m);
if(from){
if(p==buf || from[-1]=='\n')
if (from) {
if (p == buf || from[-1] == '\n')
write(ofd, " ", 1); /* escape with space if From is at start of line */
write(ofd, from, 4);
m += 4;
@ -388,13 +356,11 @@ write2(int fd, int ofd, char *buf, int n, int nofrom)
}
}
void
mesgsend(Message *m)
{
void mesgsend(Message* m) {
char *s, *body, *to;
int i, j, h, n, natt, p[2];
struct Exec *e;
Channel *sync;
struct Exec* e;
Channel* sync;
int first, nfld, delit, ofd;
char *copy, *fld[100], *now;
@ -406,83 +372,83 @@ mesgsend(Message *m)
nbcc = 0;
first = 1;
to = body;
for(;;){
for(s=to; *s!='\n'; s++)
if(*s == '\0'){
for (;;) {
for (s = to; *s != '\n'; s++)
if (*s == '\0') {
free(body);
return;
}
if(s++ == to) /* blank line */
if (s++ == to) /* blank line */
break;
/* make copy of line to tokenize */
copy = emalloc(s-to);
memmove(copy, to, s-to);
copy[s-to-1] = '\0';
copy = emalloc(s - to);
memmove(copy, to, s - to);
copy[s - to - 1] = '\0';
nfld = tokenizec(copy, fld, nelem(fld), ", \t");
if(nfld == 0){
if (nfld == 0) {
free(copy);
break;
}
n -= s-to;
switch(h = whichheader(fld[0])){
n -= s - to;
switch (h = whichheader(fld[0])) {
case TO:
case FROM:
delit = 1;
commas(to+strlen(fld[0]), s-1);
for(i=1; i<nfld && nto<nelem(tolist); i++)
if(!addressed(fld[i]))
commas(to + strlen(fld[0]), s - 1);
for (i = 1; i < nfld && nto < nelem(tolist); i++)
if (!addressed(fld[i]))
tolist[nto++] = estrdup(fld[i]);
break;
case BCC:
delit = 1;
commas(to+strlen(fld[0]), s-1);
for(i=1; i<nfld && nbcc<nelem(bcclist); i++)
if(!addressed(fld[i]))
commas(to + strlen(fld[0]), s - 1);
for (i = 1; i < nfld && nbcc < nelem(bcclist); i++)
if (!addressed(fld[i]))
bcclist[nbcc++] = estrdup(fld[i]);
break;
case CC:
delit = 1;
commas(to+strlen(fld[0]), s-1);
for(i=1; i<nfld && ncc<nelem(cclist); i++)
if(!addressed(fld[i]))
commas(to + strlen(fld[0]), s - 1);
for (i = 1; i < nfld && ncc < nelem(cclist); i++)
if (!addressed(fld[i]))
cclist[ncc++] = estrdup(fld[i]);
break;
case ATTACH:
case INCLUDE:
delit = 1;
for(i=1; i<nfld && natt<nelem(attlist); i++){
for (i = 1; i < nfld && natt < nelem(attlist); i++) {
attlist[natt] = estrdup(fld[i]);
included[natt++] = (h == INCLUDE);
}
break;
default:
if(first){
if (first) {
delit = 1;
for(i=0; i<nfld && nto<nelem(tolist); i++)
for (i = 0; i < nfld && nto < nelem(tolist); i++)
tolist[nto++] = estrdup(fld[i]);
}else /* ignore it */
} else /* ignore it */
delit = 0;
break;
}
if(delit){
if (delit) {
/* delete line from body */
memmove(to, s, n+1);
}else
memmove(to, s, n + 1);
} else
to = s;
free(copy);
first = 0;
}
ofd = open(outgoing, OWRITE|OCEXEC); /* no error check necessary */
if(ofd > 0){
ofd = open(outgoing, OWRITE | OCEXEC); /* no error check necessary */
if (ofd > 0) {
/* From dhog Fri Aug 24 22:13:00 EDT 2001 */
now = ctime(time(0));
seek(ofd, 0, 2);
fprint(ofd, "From %s %s", user, now);
fprint(ofd, "From: %s\n", user);
fprint(ofd, "Date: %s", now);
for(i=0; i<natt; i++)
if(included[i])
for (i = 0; i < natt; i++)
if (included[i])
fprint(ofd, "Include: %s\n", attlist[i]);
else
fprint(ofd, "Attach: %s\n", attlist[i]);
@ -492,21 +458,21 @@ mesgsend(Message *m)
}
e = emalloc(sizeof(struct Exec));
if(pipe(p) < 0)
if (pipe(p) < 0)
error("can't create pipe: %r");
e->p[0] = p[0];
e->p[1] = p[1];
e->prog = unsharp("#9/bin/upas/marshal");
e->argv = emalloc((1+1+2+4*natt+1)*sizeof(char*));
e->argv = emalloc((1 + 1 + 2 + 4 * natt + 1) * sizeof(char*));
e->argv[0] = estrdup("marshal");
e->argv[1] = estrdup("-8");
j = 2;
if(m->replyname){
if (m->replyname) {
e->argv[j++] = estrdup("-R");
e->argv[j++] = estrstrdup(mbox.name, m->replyname);
}
for(i=0; i<natt; i++){
if(included[i])
for (i = 0; i < natt; i++) {
if (included[i])
e->argv[j++] = estrdup("-A");
else
e->argv[j++] = estrdup("-a");
@ -519,55 +485,55 @@ mesgsend(Message *m)
/* close(p[0]); */
/* using marshal -8, so generate rfc822 headers */
if(nto > 0){
if (nto > 0) {
print2(p[1], ofd, "To: ");
for(i=0; i<nto-1; i++)
for (i = 0; i < nto - 1; i++)
print2(p[1], ofd, "%s, ", tolist[i]);
print2(p[1], ofd, "%s\n", tolist[i]);
}
if(ncc > 0){
if (ncc > 0) {
print2(p[1], ofd, "CC: ");
for(i=0; i<ncc-1; i++)
for (i = 0; i < ncc - 1; i++)
print2(p[1], ofd, "%s, ", cclist[i]);
print2(p[1], ofd, "%s\n", cclist[i]);
}
if(nbcc > 0){
if (nbcc > 0) {
print2(p[1], ofd, "BCC: ");
for(i=0; i<nbcc-1; i++)
for (i = 0; i < nbcc - 1; i++)
print2(p[1], ofd, "%s, ", bcclist[i]);
print2(p[1], ofd, "%s\n", bcclist[i]);
}
i = strlen(body);
if(i > 0)
if (i > 0)
write2(p[1], ofd, body, i, 1);
/* guarantee a blank line, to ensure attachments are separated from body */
if(i==0 || body[i-1]!='\n')
if (i == 0 || body[i - 1] != '\n')
write2(p[1], ofd, "\n\n", 2, 0);
else if(i>1 && body[i-2]!='\n')
else if (i > 1 && body[i - 2] != '\n')
write2(p[1], ofd, "\n", 1, 0);
/* these look like pseudo-attachments in the "outgoing" box */
if(ofd>0 && natt>0){
for(i=0; i<natt; i++)
if(included[i])
if (ofd > 0 && natt > 0) {
for (i = 0; i < natt; i++)
if (included[i])
fprint(ofd, "=====> Include: %s\n", attlist[i]);
else
fprint(ofd, "=====> Attach: %s\n", attlist[i]);
}
if(ofd > 0)
if (ofd > 0)
write(ofd, "\n", 1);
for(i=0; i<natt; i++)
for (i = 0; i < natt; i++)
free(attlist[i]);
close(ofd);
close(p[1]);
free(body);
if(m->replyname != nil)
if (m->replyname != nil)
mesgmenumark(mbox.w, m->replyname, "\t[replied]");
if(m->name[0] == '/')
if (m->name[0] == '/')
s = estrdup(m->name);
else
s = estrstrdup(mbox.name, m->name);

BIN
mail/reply.o
View file

Binary file not shown.

57
mail/util.c
View file

@ -6,59 +6,49 @@
#include <9pclient.h>
#include "dat.h"
void*
emalloc(uint n)
{
void *p;
void* emalloc(uint n) {
void* p;
p = malloc(n);
if(p == nil)
if (p == nil)
error("can't malloc: %r");
memset(p, 0, n);
setmalloctag(p, getcallerpc(&n));
return p;
}
void*
erealloc(void *p, uint n)
{
void* erealloc(void* p, uint n) {
p = realloc(p, n);
if(p == nil)
if (p == nil)
error("can't realloc: %r");
setmalloctag(p, getcallerpc(&n));
return p;
}
char*
estrdup(char *s)
{
char *t;
char* estrdup(char* s) {
char* t;
t = emalloc(strlen(s)+1);
t = emalloc(strlen(s) + 1);
strcpy(t, s);
return t;
}
char*
estrstrdup(char *s, char *t)
{
char *u;
char* estrstrdup(char* s, char* t) {
char* u;
u = emalloc(strlen(s)+strlen(t)+1);
u = emalloc(strlen(s) + strlen(t) + 1);
strcpy(u, s);
strcat(u, t);
return u;
}
char*
eappend(char *s, char *sep, char *t)
{
char *u;
char* eappend(char* s, char* sep, char* t) {
char* u;
if(t == nil)
if (t == nil)
u = estrstrdup(s, sep);
else{
u = emalloc(strlen(s)+strlen(sep)+strlen(t)+1);
else {
u = emalloc(strlen(s) + strlen(sep) + strlen(t) + 1);
strcpy(u, s);
strcat(u, sep);
strcat(u, t);
@ -67,17 +57,13 @@ eappend(char *s, char *sep, char *t)
return u;
}
char*
egrow(char *s, char *sep, char *t)
{
char* egrow(char* s, char* sep, char* t) {
s = eappend(s, sep, t);
free(t);
return s;
}
void
error(char *fmt, ...)
{
void error(char* fmt, ...) {
Fmt f;
char buf[64];
va_list arg;
@ -92,16 +78,13 @@ error(char *fmt, ...)
threadexitsall(fmt);
}
void
ctlprint(CFid *fd, char *fmt, ...)
{
void ctlprint(CFid* fd, char* fmt, ...) {
int n;
va_list arg;
va_start(arg, fmt);
n = fsvprint(fd, fmt, arg);
va_end(arg);
if(n <= 0)
if (n <= 0)
error("control file write error: %r");
}

BIN
mail/util.o
View file

Binary file not shown.

237
mail/win.c
View file

@ -6,15 +6,13 @@
#include <9pclient.h>
#include "dat.h"
Window*
newwindow(void)
{
Window* newwindow(void) {
char buf[12];
Window *w;
Window* w;
w = emalloc(sizeof(Window));
w->ctl = fsopen(acmefs, "new/ctl", ORDWR|OCEXEC);
if(w->ctl == nil || fsread(w->ctl, buf, 12)!=12)
w->ctl = fsopen(acmefs, "new/ctl", ORDWR | OCEXEC);
if (w->ctl == nil || fsread(w->ctl, buf, 12) != 12)
error("can't open window ctl file: %r");
w->id = atoi(buf);
@ -27,19 +25,15 @@ newwindow(void)
return w;
}
void
winincref(Window *w)
{
void winincref(Window* w) {
qlock(&w->lk);
++w->ref;
qunlock(&w->lk);
}
void
windecref(Window *w)
{
void windecref(Window* w) {
qlock(&w->lk);
if(--w->ref > 0){
if (--w->ref > 0) {
qunlock(&w->lk);
return;
}
@ -48,119 +42,98 @@ windecref(Window *w)
free(w);
}
void
winsetdump(Window *w, char *dir, char *cmd)
{
if(dir != nil)
void winsetdump(Window* w, char* dir, char* cmd) {
if (dir != nil)
ctlprint(w->ctl, "dumpdir %s\n", dir);
if(cmd != nil)
if (cmd != nil)
ctlprint(w->ctl, "dump %s\n", cmd);
}
void
wineventproc(void *v)
{
Window *w;
void wineventproc(void* v) {
Window* w;
int i;
w = v;
for(i=0; ; i++){
if(i >= NEVENT)
for (i = 0;; i++) {
if (i >= NEVENT)
i = 0;
wingetevent(w, &w->e[i]);
sendp(w->cevent, &w->e[i]);
}
}
static CFid*
winopenfile1(Window *w, char *f, int m)
{
static CFid* winopenfile1(Window* w, char* f, int m) {
char buf[64];
CFid* fd;
sprint(buf, "%d/%s", w->id, f);
fd = fsopen(acmefs, buf, m|OCEXEC);
if(fd == nil)
fd = fsopen(acmefs, buf, m | OCEXEC);
if (fd == nil)
error("can't open window file %s: %r", f);
return fd;
}
CFid*
winopenfile(Window *w, char *f)
{
return winopenfile1(w, f, ORDWR);
}
CFid* winopenfile(Window* w, char* f) { return winopenfile1(w, f, ORDWR); }
void
wintagwrite(Window *w, char *s, int n)
{
void wintagwrite(Window* w, char* s, int n) {
CFid* fid;
fid = winopenfile(w, "tag");
if(fswrite(fid, s, n) != n)
if (fswrite(fid, s, n) != n)
error("tag write: %r");
fsclose(fid);
}
void
winname(Window *w, char *s)
{
void winname(Window* w, char* s) {
int len;
char *ns, *sp;
Rune r = L'␣'; /* visible space */
len = 0;
ns = emalloc(strlen(s)*runelen(r) + 1);
for(sp = s; *sp != '\0'; sp++, len++){
if(isspace(*sp)){
len += runetochar(ns+len, &r)-1;
ns = emalloc(strlen(s) * runelen(r) + 1);
for (sp = s; *sp != '\0'; sp++, len++) {
if (isspace(*sp)) {
len += runetochar(ns + len, &r) - 1;
continue;
}
*(ns+len) = *sp;
*(ns + len) = *sp;
}
ctlprint(w->ctl, "name %s\n", ns);
free(ns);
return;
}
void
winopenbody(Window *w, int mode)
{
void winopenbody(Window* w, int mode) {
char buf[256];
CFid* fid;
sprint(buf, "%d/body", w->id);
fid = fsopen(acmefs, buf, mode|OCEXEC);
fid = fsopen(acmefs, buf, mode | OCEXEC);
w->body = fid;
if(w->body == nil)
if (w->body == nil)
error("can't open window body file: %r");
}
void
winclosebody(Window *w)
{
if(w->body != nil){
void winclosebody(Window* w) {
if (w->body != nil) {
fsclose(w->body);
w->body = nil;
}
}
void
winwritebody(Window *w, char *s, int n)
{
if(w->body == nil)
void winwritebody(Window* w, char* s, int n) {
if (w->body == nil)
winopenbody(w, OWRITE);
if(fswrite(w->body, s, n) != n)
if (fswrite(w->body, s, n) != n)
error("write error to window: %r");
}
int
wingetec(Window *w)
{
if(w->nbuf == 0){
int wingetec(Window* w) {
if (w->nbuf == 0) {
w->nbuf = fsread(w->event, w->buf, sizeof w->buf);
if(w->nbuf <= 0){
/* probably because window has exited, and only called by wineventproc, so just shut down */
if (w->nbuf <= 0) {
/* probably because window has exited, and only called by wineventproc, so
* just shut down */
windecref(w);
threadexits(nil);
}
@ -170,30 +143,26 @@ wingetec(Window *w)
return *w->bufp++;
}
int
wingeten(Window *w)
{
int wingeten(Window* w) {
int n, c;
n = 0;
while('0'<=(c=wingetec(w)) && c<='9')
n = n*10+(c-'0');
if(c != ' ')
while ('0' <= (c = wingetec(w)) && c <= '9')
n = n * 10 + (c - '0');
if (c != ' ')
error("event number syntax");
return n;
}
int
wingeter(Window *w, char *buf, int *nb)
{
int wingeter(Window* w, char* buf, int* nb) {
Rune r;
int n;
r = wingetec(w);
buf[0] = r;
n = 1;
if(r >= Runeself) {
while(!fullrune(buf, n))
if (r >= Runeself) {
while (!fullrune(buf, n))
buf[n++] = wingetec(w);
chartorune(&r, buf);
}
@ -201,9 +170,7 @@ wingeter(Window *w, char *buf, int *nb)
return r;
}
void
wingetevent(Window *w, Event *e)
{
void wingetevent(Window* w, Event* e) {
int i, nb;
e->c1 = wingetec(w);
@ -212,49 +179,47 @@ wingetevent(Window *w, Event *e)
e->q1 = wingeten(w);
e->flag = wingeten(w);
e->nr = wingeten(w);
if(e->nr > EVENTSIZE)
if (e->nr > EVENTSIZE)
error("event string too long");
e->nb = 0;
for(i=0; i<e->nr; i++){
e->r[i] = wingeter(w, e->b+e->nb, &nb);
for (i = 0; i < e->nr; i++) {
e->r[i] = wingeter(w, e->b + e->nb, &nb);
e->nb += nb;
}
e->r[e->nr] = 0;
e->b[e->nb] = 0;
if(wingetec(w) != '\n')
if (wingetec(w) != '\n')
error("event syntax error");
}
void
winwriteevent(Window *w, Event *e)
{
void winwriteevent(Window* w, Event* e) {
fsprint(w->event, "%c%c%d %d\n", e->c1, e->c2, e->q0, e->q1);
}
void
winread(Window *w, uint q0, uint q1, char *data)
{
void winread(Window* w, uint q0, uint q1, char* data) {
int m, n, nr;
char buf[256];
if(w->addr == nil)
if (w->addr == nil)
w->addr = winopenfile(w, "addr");
if(w->data == nil)
if (w->data == nil)
w->data = winopenfile(w, "data");
m = q0;
while(m < q1){
while (m < q1) {
n = sprint(buf, "#%d", m);
if(fswrite(w->addr, buf, n) != n)
if (fswrite(w->addr, buf, n) != n)
error("error writing addr: %r");
n = fsread(w->data, buf, sizeof buf);
if(n <= 0)
if (n <= 0)
error("reading data: %r");
nr = utfnlen(buf, n);
while(m+nr >q1){
do; while(n>0 && (buf[--n]&0xC0)==0x80);
while (m + nr > q1) {
do
;
while (n > 0 && (buf[--n] & 0xC0) == 0x80);
--nr;
}
if(n == 0)
if (n == 0)
break;
memmove(data, buf, n);
data += n;
@ -263,30 +228,25 @@ winread(Window *w, uint q0, uint q1, char *data)
}
}
void
windormant(Window *w)
{
if(w->addr != nil){
void windormant(Window* w) {
if (w->addr != nil) {
fsclose(w->addr);
w->addr = nil;
}
if(w->body != nil){
if (w->body != nil) {
fsclose(w->body);
w->body = nil;
}
if(w->data != nil){
if (w->data != nil) {
fsclose(w->data);
w->data = nil;
}
}
int
windel(Window *w, int sure)
{
if(sure)
int windel(Window* w, int sure) {
if (sure)
fswrite(w->ctl, "delete\n", 7);
else if(fswrite(w->ctl, "del\n", 4) != 4)
else if (fswrite(w->ctl, "del\n", 4) != 4)
return 0;
/* event proc will die due to read error from event file */
windormant(w);
@ -295,54 +255,47 @@ windel(Window *w, int sure)
return 1;
}
void
winclean(Window *w)
{
ctlprint(w->ctl, "clean\n");
}
void winclean(Window* w) { ctlprint(w->ctl, "clean\n"); }
int
winsetaddr(Window *w, char *addr, int errok)
{
if(w->addr == nil)
int winsetaddr(Window* w, char* addr, int errok) {
if (w->addr == nil)
w->addr = winopenfile(w, "addr");
if(fswrite(w->addr, addr, strlen(addr)) < 0){
if(!errok)
if (fswrite(w->addr, addr, strlen(addr)) < 0) {
if (!errok)
error("error writing addr(%s): %r", addr);
return 0;
}
return 1;
}
int
winselect(Window *w, char *addr, int errok)
{
if(winsetaddr(w, addr, errok)){
int winselect(Window* w, char* addr, int errok) {
if (winsetaddr(w, addr, errok)) {
ctlprint(w->ctl, "dot=addr\n");
return 1;
}
return 0;
}
char*
winreadbody(Window *w, int *np) /* can't use readfile because acme doesn't report the length */
char* winreadbody(
Window* w,
int* np) /* can't use readfile because acme doesn't report the length */
{
char *s;
char* s;
int m, na, n;
if(w->body != nil)
if (w->body != nil)
winclosebody(w);
winopenbody(w, OREAD);
s = nil;
na = 0;
n = 0;
for(;;){
if(na < n+512){
for (;;) {
if (na < n + 512) {
na += 1024;
s = realloc(s, na+1);
s = realloc(s, na + 1);
}
m = fsread(w->body, s+n, na-n);
if(m <= 0)
m = fsread(w->body, s + n, na - n);
if (m <= 0)
break;
n += m;
}
@ -352,25 +305,23 @@ winreadbody(Window *w, int *np) /* can't use readfile because acme doesn't repor
return s;
}
char*
winselection(Window *w)
{
char* winselection(Window* w) {
int m, n;
char *buf;
char* buf;
char tmp[256];
CFid* fid;
fid = winopenfile1(w, "rdsel", OREAD);
if(fid == nil)
if (fid == nil)
error("can't open rdsel: %r");
n = 0;
buf = nil;
for(;;){
for (;;) {
m = fsread(fid, tmp, sizeof tmp);
if(m <= 0)
if (m <= 0)
break;
buf = erealloc(buf, n+m+1);
memmove(buf+n, tmp, m);
buf = erealloc(buf, n + m + 1);
memmove(buf + n, tmp, m);
n += m;
buf[n] = '\0';
}

BIN
mail/win.o
View file

Binary file not shown.

459
regx.c
View file

@ -13,39 +13,37 @@
#include "fns.h"
Rangeset sel;
Rune *lastregexp;
Rune* lastregexp;
/*
* Machine Information
*/
typedef struct Inst Inst;
struct Inst
{
struct Inst {
uint type; /* < OPERATOR ==> literal, otherwise action */
union {
int sid;
int subid;
int class;
Inst *other;
Inst *right;
Inst* other;
Inst* right;
} u;
union{
Inst *left;
Inst *next;
union {
Inst* left;
Inst* next;
} u1;
};
#define NPROG 1024
Inst program[NPROG];
Inst *progp;
Inst *startinst; /* First inst. of program; might not be program[0] */
Inst *bstartinst; /* same for backwards machine */
Channel *rechan; /* chan(Inst*) */
Inst* progp;
Inst* startinst; /* First inst. of program; might not be program[0] */
Inst* bstartinst; /* same for backwards machine */
Channel* rechan; /* chan(Inst*) */
typedef struct Ilist Ilist;
struct Ilist
{
Inst *inst; /* Instruction of the thread */
struct Ilist {
Inst* inst; /* Instruction of the thread */
Rangeset se;
uint startp; /* first char of match */
};
@ -53,7 +51,7 @@ struct Ilist
#define NLIST 127
Ilist *tl, *nl; /* This list, next list */
Ilist list[2][NLIST+1]; /* +1 for trailing null */
Ilist list[2][NLIST + 1]; /* +1 for trailing null */
static Rangeset sempty;
/*
@ -63,21 +61,21 @@ static Rangeset sempty;
* 0x20000xx are tokens, i.e. operands for operators
*/
#define OPERATOR 0x1000000 /* Bit set in all operators */
#define START (OPERATOR+0) /* Start, used for marker on stack */
#define RBRA (OPERATOR+1) /* Right bracket, ) */
#define LBRA (OPERATOR+2) /* Left bracket, ( */
#define OR (OPERATOR+3) /* Alternation, | */
#define CAT (OPERATOR+4) /* Concatentation, implicit operator */
#define STAR (OPERATOR+5) /* Closure, * */
#define PLUS (OPERATOR+6) /* a+ == aa* */
#define QUEST (OPERATOR+7) /* a? == a|nothing, i.e. 0 or 1 a's */
#define START (OPERATOR + 0) /* Start, used for marker on stack */
#define RBRA (OPERATOR + 1) /* Right bracket, ) */
#define LBRA (OPERATOR + 2) /* Left bracket, ( */
#define OR (OPERATOR + 3) /* Alternation, | */
#define CAT (OPERATOR + 4) /* Concatentation, implicit operator */
#define STAR (OPERATOR + 5) /* Closure, * */
#define PLUS (OPERATOR + 6) /* a+ == aa* */
#define QUEST (OPERATOR + 7) /* a? == a|nothing, i.e. 0 or 1 a's */
#define ANY 0x2000000 /* Any character but newline, . */
#define NOP (ANY+1) /* No operation, internal use only */
#define BOL (ANY+2) /* Beginning of line, ^ */
#define EOL (ANY+3) /* End of line, $ */
#define CCLASS (ANY+4) /* Character class, [] */
#define NCCLASS (ANY+5) /* Negated character class, [^] */
#define END (ANY+0x77) /* Terminate: match found */
#define NOP (ANY + 1) /* No operation, internal use only */
#define BOL (ANY + 2) /* Beginning of line, ^ */
#define EOL (ANY + 3) /* End of line, $ */
#define CCLASS (ANY + 4) /* Character class, [] */
#define NCCLASS (ANY + 5) /* Negated character class, [^] */
#define END (ANY + 0x77) /* Terminate: match found */
#define ISATOR OPERATOR
#define ISAND ANY
@ -88,36 +86,35 @@ static Rangeset sempty;
* Parser Information
*/
typedef struct Node Node;
struct Node
{
Inst *first;
Inst *last;
struct Node {
Inst* first;
Inst* last;
};
#define NSTACK 20
Node andstack[NSTACK];
Node *andp;
Node* andp;
int atorstack[NSTACK];
int *atorp;
int* atorp;
int lastwasand; /* Last token was operand */
int cursubid;
int subidstack[NSTACK];
int *subidp;
int* subidp;
int backwards;
int nbra;
Rune *exprp; /* pointer to next character in source expression */
Rune* exprp; /* pointer to next character in source expression */
#define DCLASS 10 /* allocation increment */
int nclass; /* number active */
int Nclass; /* high water mark */
Rune **class;
Rune** class;
int negateclass;
int addinst(Ilist *l, Inst *inst, Rangeset *sep);
int addinst(Ilist* l, Inst* inst, Rangeset* sep);
void newmatch(Rangeset*);
void bnewmatch(Rangeset*);
void pushand(Inst*, Inst*);
void pushator(int);
Node *popand(int);
Node* popand(int);
int popator(void);
void startlex(Rune*);
int lex(void);
@ -127,27 +124,21 @@ void evaluntil(int);
void optimize(Inst*);
void bldcclass(void);
void
rxinit(void)
{
void rxinit(void) {
rechan = chancreate(sizeof(Inst*), 0);
chansetname(rechan, "rechan");
lastregexp = runemalloc(1);
}
void
regerror(char *e)
{
void regerror(char* e) {
lastregexp[0] = 0;
warning(nil, "regexp: %s\n", e);
sendp(rechan, nil);
threadexits(nil);
}
Inst *
newinst(int t)
{
if(progp >= &program[NPROG])
Inst* newinst(int t) {
if (progp >= &program[NPROG])
regerror("expression too long");
progp->type = t;
progp->u1.left = nil;
@ -155,11 +146,9 @@ newinst(int t)
return progp++;
}
void
realcompile(void *arg)
{
void realcompile(void* arg) {
int token;
Rune *s;
Rune* s;
threadsetname("regcomp");
s = arg;
@ -170,9 +159,9 @@ realcompile(void *arg)
cursubid = 0;
lastwasand = FALSE;
/* Start with a low priority operator to prime parser */
pushator(START-1);
while((token=lex()) != END){
if((token&ISATOR) == OPERATOR)
pushator(START - 1);
while ((token = lex()) != END) {
if ((token & ISATOR) == OPERATOR)
operator(token);
else
operand(token);
@ -182,7 +171,7 @@ realcompile(void *arg)
/* Force END */
operand(END);
evaluntil(START);
if(nbra)
if (nbra)
regerror("unmatched `('");
--andp; /* points to first and only operand */
sendp(rechan, andp->first);
@ -190,17 +179,15 @@ realcompile(void *arg)
}
/* r is null terminated */
int
rxcompile(Rune *r)
{
int rxcompile(Rune* r) {
int i, nr;
Inst *oprogp;
Inst* oprogp;
nr = runestrlen(r)+1;
if(runeeq(lastregexp, runestrlen(lastregexp)+1, r, nr)==TRUE)
nr = runestrlen(r) + 1;
if (runeeq(lastregexp, runestrlen(lastregexp) + 1, r, nr) == TRUE)
return TRUE;
lastregexp[0] = 0;
for(i=0; i<nclass; i++)
for (i = 0; i < nclass; i++)
free(class[i]);
nclass = 0;
progp = program;
@ -208,14 +195,14 @@ rxcompile(Rune *r)
bstartinst = nil;
threadcreate(realcompile, r, STACK);
startinst = recvp(rechan);
if(startinst == nil)
if (startinst == nil)
return FALSE;
optimize(program);
oprogp = progp;
backwards = TRUE;
threadcreate(realcompile, r, STACK);
bstartinst = recvp(rechan);
if(bstartinst == nil)
if (bstartinst == nil)
return FALSE;
optimize(oprogp);
lastregexp = runerealloc(lastregexp, nr);
@ -223,94 +210,80 @@ rxcompile(Rune *r)
return TRUE;
}
void
operand(int t)
{
Inst *i;
if(lastwasand)
void operand(int t) {
Inst* i;
if (lastwasand)
operator(CAT); /* catenate is implicit */
i = newinst(t);
if(t == CCLASS){
if(negateclass)
if (t == CCLASS) {
if (negateclass)
i->type = NCCLASS; /* UGH */
i->u.class = nclass-1; /* UGH */
i->u.class = nclass - 1; /* UGH */
}
pushand(i, i);
lastwasand = TRUE;
}
void
operator(int t)
{
if(t==RBRA && --nbra<0)
void operator(int t) {
if (t == RBRA && --nbra < 0)
regerror("unmatched `)'");
if(t==LBRA){
if (t == LBRA) {
cursubid++; /* silently ignored */
nbra++;
if(lastwasand)
if (lastwasand)
operator(CAT);
}else
} else
evaluntil(t);
if(t!=RBRA)
if (t != RBRA)
pushator(t);
lastwasand = FALSE;
if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
if (t == STAR || t == QUEST || t == PLUS || t == RBRA)
lastwasand = TRUE; /* these look like operands */
}
void
pushand(Inst *f, Inst *l)
{
if(andp >= &andstack[NSTACK])
void pushand(Inst* f, Inst* l) {
if (andp >= &andstack[NSTACK])
error("operand stack overflow");
andp->first = f;
andp->last = l;
andp++;
}
void
pushator(int t)
{
if(atorp >= &atorstack[NSTACK])
void pushator(int t) {
if (atorp >= &atorstack[NSTACK])
error("operator stack overflow");
*atorp++=t;
if(cursubid >= NRange)
*subidp++= -1;
*atorp++ = t;
if (cursubid >= NRange)
*subidp++ = -1;
else
*subidp++=cursubid;
*subidp++ = cursubid;
}
Node *
popand(int op)
{
Node* popand(int op) {
char buf[64];
if(andp <= &andstack[0])
if(op){
if (andp <= &andstack[0])
if (op) {
sprint(buf, "missing operand for %c", op);
regerror(buf);
}else
} else
regerror("malformed regexp");
return --andp;
}
int
popator()
{
if(atorp <= &atorstack[0])
int popator() {
if (atorp <= &atorstack[0])
error("operator stack underflow");
--subidp;
return *--atorp;
}
void
evaluntil(int pri)
{
void evaluntil(int pri) {
Node *op1, *op2, *t;
Inst *inst1, *inst2;
while(pri==RBRA || atorp[-1]>=pri){
switch(popator()){
while (pri == RBRA || atorp[-1] >= pri) {
switch (popator()) {
case LBRA:
op1 = popand('(');
inst2 = newinst(RBRA);
@ -338,7 +311,7 @@ evaluntil(int pri)
case CAT:
op2 = popand(0);
op1 = popand(0);
if(backwards && op2->first->type!=END){
if (backwards && op2->first->type != END) {
t = op1;
op1 = op2;
op2 = t;
@ -373,38 +346,31 @@ evaluntil(int pri)
}
}
void
optimize(Inst *start)
{
void optimize(Inst* start) {
Inst *inst, *target;
for(inst=start; inst->type!=END; inst++){
for (inst = start; inst->type != END; inst++) {
target = inst->u1.next;
while(target->type == NOP)
while (target->type == NOP)
target = target->u1.next;
inst->u1.next = target;
}
}
void
startlex(Rune *s)
{
void startlex(Rune* s) {
exprp = s;
nbra = 0;
}
int
lex(void){
int lex(void) {
int c;
c = *exprp++;
switch(c){
switch (c) {
case '\\':
if(*exprp)
if((c= *exprp++)=='n')
c='\n';
if (*exprp)
if ((c = *exprp++) == 'n')
c = '\n';
break;
case 0:
c = END;
@ -445,79 +411,73 @@ lex(void){
return c;
}
int
nextrec(void)
{
if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
int nextrec(void) {
if (exprp[0] == 0 || (exprp[0] == '\\' && exprp[1] == 0))
regerror("malformed `[]'");
if(exprp[0] == '\\'){
if (exprp[0] == '\\') {
exprp++;
if(*exprp=='n'){
if (*exprp == 'n') {
exprp++;
return '\n';
}
return *exprp++|QUOTED;
return *exprp++ | QUOTED;
}
return *exprp++;
}
void
bldcclass(void)
{
void bldcclass(void) {
int c1, c2, n, na;
Rune *classp;
Rune* classp;
classp = runemalloc(DCLASS);
n = 0;
na = DCLASS;
/* we have already seen the '[' */
if(*exprp == '^'){
if (*exprp == '^') {
classp[n++] = '\n'; /* don't match newline in negate case */
negateclass = TRUE;
exprp++;
}else
} else
negateclass = FALSE;
while((c1 = nextrec()) != ']'){
if(c1 == '-'){
while ((c1 = nextrec()) != ']') {
if (c1 == '-') {
Error:
free(classp);
regerror("malformed `[]'");
}
if(n+4 >= na){ /* 3 runes plus NUL */
if (n + 4 >= na) { /* 3 runes plus NUL */
na += DCLASS;
classp = runerealloc(classp, na);
}
if(*exprp == '-'){
if (*exprp == '-') {
exprp++; /* eat '-' */
if((c2 = nextrec()) == ']')
if ((c2 = nextrec()) == ']')
goto Error;
classp[n+0] = Runemax;
classp[n+1] = c1;
classp[n+2] = c2;
classp[n + 0] = Runemax;
classp[n + 1] = c1;
classp[n + 2] = c2;
n += 3;
}else
} else
classp[n++] = c1 & ~QUOTED;
}
classp[n] = 0;
if(nclass == Nclass){
if (nclass == Nclass) {
Nclass += DCLASS;
class = realloc(class, Nclass*sizeof(Rune*));
class = realloc(class, Nclass * sizeof(Rune*));
}
class[nclass++] = classp;
}
int
classmatch(int classno, int c, int negate)
{
Rune *p;
int classmatch(int classno, int c, int negate) {
Rune* p;
p = class[classno];
while(*p){
if(*p == Runemax){
if(p[1]<=c && c<=p[2])
while (*p) {
if (*p == Runemax) {
if (p[1] <= c && c <= p[2])
return !negate;
p += 3;
}else if(*p++ == c)
} else if (*p++ == c)
return !negate;
}
return negate;
@ -528,37 +488,29 @@ classmatch(int classno, int c, int negate)
* *l must be pending when addinst called; if *l has been looked
* at already, the optimization is a bug.
*/
int
addinst(Ilist *l, Inst *inst, Rangeset *sep)
{
Ilist *p;
int addinst(Ilist* l, Inst* inst, Rangeset* sep) {
Ilist* p;
for(p = l; p->inst; p++){
if(p->inst==inst){
if((sep)->r[0].q0 < p->se.r[0].q0)
p->se= *sep; /* this would be bug */
for (p = l; p->inst; p++) {
if (p->inst == inst) {
if ((sep)->r[0].q0 < p->se.r[0].q0)
p->se = *sep; /* this would be bug */
return 0; /* It's already there */
}
}
p->inst = inst;
p->se= *sep;
(p+1)->inst = nil;
p->se = *sep;
(p + 1)->inst = nil;
return 1;
}
int
rxnull(void)
{
return startinst==nil || bstartinst==nil;
}
int rxnull(void) { return startinst == nil || bstartinst == nil; }
/* either t!=nil or r!=nil, and we match the string in the appropriate place */
int
rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
{
int rxexecute(Text* t, Rune* r, uint startp, uint eof, Rangeset* rp) {
int flag;
Inst *inst;
Ilist *tlp;
Inst* inst;
Ilist* tlp;
uint p;
int nnl, ntl;
int nc, c;
@ -570,24 +522,24 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
startchar = 0;
wrapped = 0;
nnl = 0;
if(startinst->type<OPERATOR)
if (startinst->type < OPERATOR)
startchar = startinst->type;
list[0][0].inst = list[1][0].inst = nil;
sel.r[0].q0 = -1;
if(t != nil)
if (t != nil)
nc = t->file->b.nc;
else
nc = runestrlen(r);
/* Execute machine once for each character */
for(;;p++){
for (;; p++) {
doloop:
if(p>=eof || p>=nc){
switch(wrapped++){
if (p >= eof || p >= nc) {
switch (wrapped++) {
case 0: /* let loop run one more click */
case 2:
break;
case 1: /* expired; wrap to beginning */
if(sel.r[0].q0>=0 || eof!=Infinity)
if (sel.r[0].q0 >= 0 || eof != Infinity)
goto Return;
list[0][0].inst = list[1][0].inst = nil;
p = 0;
@ -596,27 +548,27 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
goto Return;
}
c = 0;
}else{
if(((wrapped && p>=startp) || sel.r[0].q0>0) && nnl==0)
} else {
if (((wrapped && p >= startp) || sel.r[0].q0 > 0) && nnl == 0)
break;
if(t != nil)
if (t != nil)
c = textreadc(t, p);
else
c = r[p];
}
/* fast check for first char */
if(startchar && nnl==0 && c!=startchar)
if (startchar && nnl == 0 && c != startchar)
continue;
tl = list[flag];
nl = list[flag^=1];
nl = list[flag ^= 1];
nl->inst = nil;
ntl = nnl;
nnl = 0;
if(sel.r[0].q0<0 && (!wrapped || p<startp || startp==eof)){
if (sel.r[0].q0 < 0 && (!wrapped || p < startp || startp == eof)) {
/* Add first instruction to this list */
sempty.r[0].q0 = p;
if(addinst(tl, startinst, &sempty))
if(++ntl >= NLIST){
if (addinst(tl, startinst, &sempty))
if (++ntl >= NLIST) {
Overflow:
warning(nil, "regexp list overflow\n");
sel.r[0].q0 = -1;
@ -624,54 +576,56 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
}
}
/* Execute machine until this list is empty */
for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment = */
for (tlp = tl; inst = tlp->inst; tlp++) { /* assignment = */
Switchstmt:
switch(inst->type){
switch (inst->type) {
default: /* regular character */
if(inst->type==c){
if (inst->type == c) {
Addinst:
if(addinst(nl, inst->u1.next, &tlp->se))
if(++nnl >= NLIST)
if (addinst(nl, inst->u1.next, &tlp->se))
if (++nnl >= NLIST)
goto Overflow;
}
break;
case LBRA:
if(inst->u.subid>=0)
if (inst->u.subid >= 0)
tlp->se.r[inst->u.subid].q0 = p;
inst = inst->u1.next;
goto Switchstmt;
case RBRA:
if(inst->u.subid>=0)
if (inst->u.subid >= 0)
tlp->se.r[inst->u.subid].q1 = p;
inst = inst->u1.next;
goto Switchstmt;
case ANY:
if(c!='\n')
if (c != '\n')
goto Addinst;
break;
case BOL:
if(p==0 || (t!=nil && textreadc(t, p-1)=='\n') || (r!=nil && r[p-1]=='\n')){
if (
p == 0 || (t != nil && textreadc(t, p - 1) == '\n') ||
(r != nil && r[p - 1] == '\n')) {
Step:
inst = inst->u1.next;
goto Switchstmt;
}
break;
case EOL:
if(c == '\n')
if (c == '\n')
goto Step;
break;
case CCLASS:
if(c>=0 && classmatch(inst->u.class, c, 0))
if (c >= 0 && classmatch(inst->u.class, c, 0))
goto Addinst;
break;
case NCCLASS:
if(c>=0 && classmatch(inst->u.class, c, 1))
if (c >= 0 && classmatch(inst->u.class, c, 1))
goto Addinst;
break;
case OR:
/* evaluate right choice later */
if(addinst(tlp, inst->u.right, &tlp->se))
if(++ntl >= NLIST)
if (addinst(tlp, inst->u.right, &tlp->se))
if (++ntl >= NLIST)
goto Overflow;
/* efficiency: advance and re-evaluate */
inst = inst->u1.left;
@ -683,25 +637,22 @@ rxexecute(Text *t, Rune *r, uint startp, uint eof, Rangeset *rp)
}
}
}
Return:
Return:
*rp = sel;
return sel.r[0].q0 >= 0;
}
void
newmatch(Rangeset *sp)
{
if(sel.r[0].q0<0 || sp->r[0].q0<sel.r[0].q0 ||
(sp->r[0].q0==sel.r[0].q0 && sp->r[0].q1>sel.r[0].q1))
void newmatch(Rangeset* sp) {
if (
sel.r[0].q0 < 0 || sp->r[0].q0 < sel.r[0].q0 ||
(sp->r[0].q0 == sel.r[0].q0 && sp->r[0].q1 > sel.r[0].q1))
sel = *sp;
}
int
rxbexecute(Text *t, uint startp, Rangeset *rp)
{
int rxbexecute(Text* t, uint startp, Rangeset* rp) {
int flag;
Inst *inst;
Ilist *tlp;
Inst* inst;
Ilist* tlp;
int p;
int nnl, ntl;
int c;
@ -713,20 +664,20 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
wrapped = 0;
p = startp;
startchar = 0;
if(bstartinst->type<OPERATOR)
if (bstartinst->type < OPERATOR)
startchar = bstartinst->type;
list[0][0].inst = list[1][0].inst = nil;
sel.r[0].q0= -1;
sel.r[0].q0 = -1;
/* Execute machine once for each character, including terminal NUL */
for(;;--p){
for (;; --p) {
doloop:
if(p <= 0){
switch(wrapped++){
if (p <= 0) {
switch (wrapped++) {
case 0: /* let loop run one more click */
case 2:
break;
case 1: /* expired; wrap to end */
if(sel.r[0].q0>=0)
if (sel.r[0].q0 >= 0)
goto Return;
list[0][0].inst = list[1][0].inst = nil;
p = t->file->b.nc;
@ -736,25 +687,25 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
goto Return;
}
c = 0;
}else{
if(((wrapped && p<=startp) || sel.r[0].q0>0) && nnl==0)
} else {
if (((wrapped && p <= startp) || sel.r[0].q0 > 0) && nnl == 0)
break;
c = textreadc(t, p-1);
c = textreadc(t, p - 1);
}
/* fast check for first char */
if(startchar && nnl==0 && c!=startchar)
if (startchar && nnl == 0 && c != startchar)
continue;
tl = list[flag];
nl = list[flag^=1];
nl = list[flag ^= 1];
nl->inst = nil;
ntl = nnl;
nnl = 0;
if(sel.r[0].q0<0 && (!wrapped || p>startp)){
if (sel.r[0].q0 < 0 && (!wrapped || p > startp)) {
/* Add first instruction to this list */
/* the minus is so the optimizations in addinst work */
sempty.r[0].q0 = -p;
if(addinst(tl, bstartinst, &sempty))
if(++ntl >= NLIST){
if (addinst(tl, bstartinst, &sempty))
if (++ntl >= NLIST) {
Overflow:
warning(nil, "regexp list overflow\n");
sel.r[0].q0 = -1;
@ -762,54 +713,54 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
}
}
/* Execute machine until this list is empty */
for(tlp = tl; inst = tlp->inst; tlp++){ /* assignment = */
for (tlp = tl; inst = tlp->inst; tlp++) { /* assignment = */
Switchstmt:
switch(inst->type){
switch (inst->type) {
default: /* regular character */
if(inst->type == c){
if (inst->type == c) {
Addinst:
if(addinst(nl, inst->u1.next, &tlp->se))
if(++nnl >= NLIST)
if (addinst(nl, inst->u1.next, &tlp->se))
if (++nnl >= NLIST)
goto Overflow;
}
break;
case LBRA:
if(inst->u.subid>=0)
if (inst->u.subid >= 0)
tlp->se.r[inst->u.subid].q0 = p;
inst = inst->u1.next;
goto Switchstmt;
case RBRA:
if(inst->u.subid >= 0)
if (inst->u.subid >= 0)
tlp->se.r[inst->u.subid].q1 = p;
inst = inst->u1.next;
goto Switchstmt;
case ANY:
if(c != '\n')
if (c != '\n')
goto Addinst;
break;
case BOL:
if(c=='\n' || p==0){
if (c == '\n' || p == 0) {
Step:
inst = inst->u1.next;
goto Switchstmt;
}
break;
case EOL:
if(p<t->file->b.nc && textreadc(t, p)=='\n')
if (p < t->file->b.nc && textreadc(t, p) == '\n')
goto Step;
break;
case CCLASS:
if(c>0 && classmatch(inst->u.class, c, 0))
if (c > 0 && classmatch(inst->u.class, c, 0))
goto Addinst;
break;
case NCCLASS:
if(c>0 && classmatch(inst->u.class, c, 1))
if (c > 0 && classmatch(inst->u.class, c, 1))
goto Addinst;
break;
case OR:
/* evaluate right choice later */
if(addinst(tl, inst->u.right, &tlp->se))
if(++ntl >= NLIST)
if (addinst(tl, inst->u.right, &tlp->se))
if (++ntl >= NLIST)
goto Overflow;
/* efficiency: advance and re-evaluate */
inst = inst->u1.left;
@ -822,18 +773,18 @@ rxbexecute(Text *t, uint startp, Rangeset *rp)
}
}
}
Return:
Return:
*rp = sel;
return sel.r[0].q0 >= 0;
}
void
bnewmatch(Rangeset *sp)
{
void bnewmatch(Rangeset* sp) {
int i;
if(sel.r[0].q0<0 || sp->r[0].q0>sel.r[0].q1 || (sp->r[0].q0==sel.r[0].q1 && sp->r[0].q1<sel.r[0].q0))
for(i = 0; i<NRange; i++){ /* note the reversal; q0<=q1 */
if (
sel.r[0].q0 < 0 || sp->r[0].q0 > sel.r[0].q1 ||
(sp->r[0].q0 == sel.r[0].q1 && sp->r[0].q1 < sel.r[0].q0))
for (i = 0; i < NRange; i++) { /* note the reversal; q0<=q1 */
sel.r[i].q0 = sp->r[i].q1;
sel.r[i].q1 = sp->r[i].q0;
}

646
rows.c
View file

File diff suppressed because it is too large Load diff

114
scrl.c
View file

@ -12,77 +12,73 @@
#include "dat.h"
#include "fns.h"
static Image *scrtmp;
static Image* scrtmp;
static
Rectangle
scrpos(Rectangle r, uint p0, uint p1, uint tot)
{
static Rectangle scrpos(Rectangle r, uint p0, uint p1, uint tot) {
Rectangle q;
int h;
q = r;
h = q.max.y-q.min.y;
if(tot == 0)
h = q.max.y - q.min.y;
if (tot == 0)
return q;
if(tot > 1024*1024){
tot>>=10;
p0>>=10;
p1>>=10;
if (tot > 1024 * 1024) {
tot >>= 10;
p0 >>= 10;
p1 >>= 10;
}
if(p0 > 0)
q.min.y += h*p0/tot;
if(p1 < tot)
q.max.y -= h*(tot-p1)/tot;
if(q.max.y < q.min.y+2){
if(q.min.y+2 <= r.max.y)
q.max.y = q.min.y+2;
if (p0 > 0)
q.min.y += h * p0 / tot;
if (p1 < tot)
q.max.y -= h * (tot - p1) / tot;
if (q.max.y < q.min.y + 2) {
if (q.min.y + 2 <= r.max.y)
q.max.y = q.min.y + 2;
else
q.min.y = q.max.y-2;
q.min.y = q.max.y - 2;
}
return q;
}
void
scrlresize(void)
{
void scrlresize(void) {
freeimage(scrtmp);
scrtmp = allocimage(display, Rect(0, 0, 32, screen->r.max.y), screen->chan, 0, DNofill);
if(scrtmp == nil)
scrtmp = allocimage(
display,
Rect(0, 0, 32, screen->r.max.y),
screen->chan,
0,
DNofill);
if (scrtmp == nil)
error("scroll alloc");
}
void
textscrdraw(Text *t)
{
void textscrdraw(Text* t) {
Rectangle r, r1, r2;
Image *b;
Image* b;
if(t->w==nil || t!=&t->w->body)
if (t->w == nil || t != &t->w->body)
return;
if(scrtmp == nil)
if (scrtmp == nil)
scrlresize();
r = t->scrollr;
b = scrtmp;
r1 = r;
r1.min.x = 0;
r1.max.x = Dx(r);
r2 = scrpos(r1, t->org, t->org+t->fr.nchars, t->file->b.nc);
if(!eqrect(r2, t->lastsr)){
r2 = scrpos(r1, t->org, t->org + t->fr.nchars, t->file->b.nc);
if (!eqrect(r2, t->lastsr)) {
t->lastsr = r2;
draw(b, r1, t->fr.cols[BORD], nil, ZP);
draw(b, r2, t->fr.cols[BACK], nil, ZP);
r2.min.x = r2.max.x-1;
r2.min.x = r2.max.x - 1;
draw(b, r2, t->fr.cols[BORD], nil, ZP);
draw(t->fr.b, r, b, nil, Pt(0, r1.min.y));
/*flushimage(display, 1); // BUG? */
/*flushimage(display, 1); // BUG? */
}
}
void
scrsleep(uint dt)
{
Timer *timer;
void scrsleep(uint dt) {
Timer* timer;
static Alt alts[3];
timer = timerstart(dt);
@ -93,8 +89,8 @@ scrsleep(uint dt)
alts[1].v = &mousectl->m;
alts[1].op = CHANRCV;
alts[2].op = CHANEND;
for(;;)
switch(alt(alts)){
for (;;)
switch (alt(alts)) {
case 0:
timerstop(timer);
return;
@ -104,56 +100,54 @@ scrsleep(uint dt)
}
}
void
textscroll(Text *t, int but)
{
void textscroll(Text* t, int but) {
uint p0, oldp0;
Rectangle s;
int x, y, my, h, first;
s = insetrect(t->scrollr, 1);
h = s.max.y-s.min.y;
x = (s.min.x+s.max.x)/2;
h = s.max.y - s.min.y;
x = (s.min.x + s.max.x) / 2;
oldp0 = ~0;
first = TRUE;
do{
do {
flushimage(display, 1);
my = mouse->xy.y;
if(my < s.min.y)
if (my < s.min.y)
my = s.min.y;
if(my >= s.max.y)
if (my >= s.max.y)
my = s.max.y;
if(!eqpt(mouse->xy, Pt(x, my))){
if (!eqpt(mouse->xy, Pt(x, my))) {
moveto(mousectl, Pt(x, my));
readmouse(mousectl); /* absorb event generated by moveto() */
}
if(but == 2){
if (but == 2) {
y = my;
p0 = (vlong)t->file->b.nc*(y-s.min.y)/h;
if(p0 >= t->q1)
p0 = (vlong)t->file->b.nc * (y - s.min.y) / h;
if (p0 >= t->q1)
p0 = textbacknl(t, p0, 2);
if(oldp0 != p0)
if (oldp0 != p0)
textsetorigin(t, p0, FALSE);
oldp0 = p0;
readmouse(mousectl);
continue;
}
if(but == 1)
p0 = textbacknl(t, t->org, (my-s.min.y)/t->fr.font->height);
if (but == 1)
p0 = textbacknl(t, t->org, (my - s.min.y) / t->fr.font->height);
else
p0 = t->org+frcharofpt(&t->fr, Pt(s.max.x, my));
if(oldp0 != p0)
p0 = t->org + frcharofpt(&t->fr, Pt(s.max.x, my));
if (oldp0 != p0)
textsetorigin(t, p0, TRUE);
oldp0 = p0;
/* debounce */
if(first){
if (first) {
flushimage(display, 1);
sleep(200);
nbrecv(mousectl->c, &mousectl->m);
first = FALSE;
}
scrsleep(80);
}while(mouse->buttons & (1<<(but-1)));
while(mouse->buttons)
} while (mouse->buttons & (1 << (but - 1)));
while (mouse->buttons)
readmouse(mousectl);
}

1138
text.c
View file

File diff suppressed because it is too large Load diff

69
time.c
View file

@ -13,32 +13,18 @@
#include "fns.h"
static Channel* ctimer; /* chan(Timer*)[100] */
static Timer *timer;
static Timer* timer;
static
uint
msec(void)
{
return nsec()/1000000;
}
static uint msec(void) { return nsec() / 1000000; }
void
timerstop(Timer *t)
{
void timerstop(Timer* t) {
t->next = timer;
timer = t;
}
void
timercancel(Timer *t)
{
t->cancel = TRUE;
}
void timercancel(Timer* t) { t->cancel = TRUE; }
static
void
timerproc(void *v)
{
static void timerproc(void* v) {
int i, nt, na, dt, del;
Timer **t, *x;
uint old, new;
@ -50,68 +36,65 @@ timerproc(void *v)
na = 0;
nt = 0;
old = msec();
for(;;){
sleep(10); /* longer sleeps here delay recv on ctimer, but 10ms should not be noticeable */
for (;;) {
sleep(10); /* longer sleeps here delay recv on ctimer, but 10ms should not
be noticeable */
new = msec();
dt = new-old;
dt = new - old;
old = new;
if(dt < 0) /* timer wrapped; go around, losing a tick */
if (dt < 0) /* timer wrapped; go around, losing a tick */
continue;
for(i=0; i<nt; i++){
for (i = 0; i < nt; i++) {
x = t[i];
x->dt -= dt;
del = FALSE;
if(x->cancel){
if (x->cancel) {
timerstop(x);
del = TRUE;
}else if(x->dt <= 0){
} else if (x->dt <= 0) {
/*
* avoid possible deadlock if client is
* now sending on ctimer
*/
if(nbsendul(x->c, 0) > 0)
if (nbsendul(x->c, 0) > 0)
del = TRUE;
}
if(del){
memmove(&t[i], &t[i+1], (nt-i-1)*sizeof t[0]);
if (del) {
memmove(&t[i], &t[i + 1], (nt - i - 1) * sizeof t[0]);
--nt;
--i;
}
}
if(nt == 0){
if (nt == 0) {
x = recvp(ctimer);
gotit:
if(nt == na){
if (nt == na) {
na += 10;
t = realloc(t, na*sizeof(Timer*));
if(t == nil)
t = realloc(t, na * sizeof(Timer*));
if (t == nil)
error("timer realloc failed");
}
t[nt++] = x;
old = msec();
}
if(nbrecv(ctimer, &x) > 0)
if (nbrecv(ctimer, &x) > 0)
goto gotit;
}
}
void
timerinit(void)
{
void timerinit(void) {
ctimer = chancreate(sizeof(Timer*), 100);
chansetname(ctimer, "ctimer");
proccreate(timerproc, nil, STACK);
}
Timer*
timerstart(int dt)
{
Timer *t;
Timer* timerstart(int dt) {
Timer* t;
t = timer;
if(t)
if (t)
timer = timer->next;
else{
else {
t = emalloc(sizeof(Timer));
t->c = chancreate(sizeof(int), 0);
chansetname(t->c, "tc%p", t->c);

305
util.c
View file

@ -13,11 +13,9 @@
#include "fns.h"
static Point prevmouse;
static Window *mousew;
static Window* mousew;
Range
range(int q0, int q1)
{
Range range(int q0, int q1) {
Range r;
r.q0 = q0;
@ -25,9 +23,7 @@ range(int q0, int q1)
return r;
}
Runestr
runestr(Rune *r, uint n)
{
Runestr runestr(Rune* r, uint n) {
Runestr rs;
rs.r = r;
@ -35,11 +31,9 @@ runestr(Rune *r, uint n)
return rs;
}
void
cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
{
uchar *q;
Rune *s;
void cvttorunes(char* p, int n, Rune* r, int* nb, int* nr, int* nulls) {
uchar* q;
Rune* s;
int j, w;
/*
@ -51,80 +45,74 @@ cvttorunes(char *p, int n, Rune *r, int *nb, int *nr, int *nulls)
*/
q = (uchar*)p;
s = r;
for(j=0; j<n; j+=w){
if(*q < Runeself){
for (j = 0; j < n; j += w) {
if (*q < Runeself) {
w = 1;
*s = *q++;
}else{
} else {
w = chartorune(s, (char*)q);
q += w;
}
if(*s)
if (*s)
s++;
else if(nulls)
else if (nulls)
*nulls = TRUE;
}
*nb = (char*)q-p;
*nr = s-r;
*nb = (char*)q - p;
*nr = s - r;
}
void
error(char *s)
{
void error(char* s) {
fprint(2, "acme: %s: %r\n", s);
threadexitsall(nil);
}
Window*
errorwin1(Rune *dir, int ndir, Rune **incl, int nincl)
{
Window *w;
Rune *r;
Window* errorwin1(Rune* dir, int ndir, Rune** incl, int nincl) {
Window* w;
Rune* r;
int i, n;
static Rune Lpluserrors[] = { '+', 'E', 'r', 'r', 'o', 'r', 's', 0 };
static Rune Lpluserrors[] = {'+', 'E', 'r', 'r', 'o', 'r', 's', 0};
r = runemalloc(ndir+8);
if((n = ndir) != 0){
r = runemalloc(ndir + 8);
if ((n = ndir) != 0) {
runemove(r, dir, ndir);
r[n++] = L'/';
}
runemove(r+n, Lpluserrors, 7);
runemove(r + n, Lpluserrors, 7);
n += 7;
w = lookfile(r, n);
if(w == nil){
if(row.ncol == 0)
if(rowadd(&row, nil, -1) == nil)
if (w == nil) {
if (row.ncol == 0)
if (rowadd(&row, nil, -1) == nil)
error("can't create column to make error window");
w = coladd(row.col[row.ncol-1], nil, nil, -1);
w = coladd(row.col[row.ncol - 1], nil, nil, -1);
w->filemenu = FALSE;
winsetname(w, r, n);
xfidlog(w, "new");
}
free(r);
for(i=nincl; --i>=0; ){
for (i = nincl; --i >= 0;) {
n = runestrlen(incl[i]);
r = runemalloc(n);
runemove(r, incl[i], n);
winaddincl(w, r, n);
}
for(i=0; i<NINDENT; i++)
for (i = 0; i < NINDENT; i++)
w->indent[i] = globalindent[i];
return w;
}
/* make new window, if necessary; return with it locked */
Window*
errorwin(Mntdir *md, int owner)
{
Window *w;
Window* errorwin(Mntdir* md, int owner) {
Window* w;
for(;;){
if(md == nil)
for (;;) {
if (md == nil)
w = errorwin1(nil, 0, nil, 0);
else
w = errorwin1(md->dir, md->ndir, md->incl, md->nincl);
winlock(w, owner);
if(w->col != nil)
if (w->col != nil)
break;
/* window was deleted too fast */
winunlock(w);
@ -137,37 +125,35 @@ errorwin(Mntdir *md, int owner)
* It will be unlocked and returned window
* will be locked in its place.
*/
Window*
errorwinforwin(Window *w)
{
Window* errorwinforwin(Window* w) {
int i, n, nincl, owner;
Rune **incl;
Rune** incl;
Runestr dir;
Text *t;
Text* t;
t = &w->body;
dir = dirname(t, nil, 0);
if(dir.nr==1 && dir.r[0]=='.'){ /* sigh */
if (dir.nr == 1 && dir.r[0] == '.') { /* sigh */
free(dir.r);
dir.r = nil;
dir.nr = 0;
}
incl = nil;
nincl = w->nincl;
if(nincl > 0){
incl = emalloc(nincl*sizeof(Rune*));
for(i=0; i<nincl; i++){
if (nincl > 0) {
incl = emalloc(nincl * sizeof(Rune*));
for (i = 0; i < nincl; i++) {
n = runestrlen(w->incl[i]);
incl[i] = runemalloc(n+1);
incl[i] = runemalloc(n + 1);
runemove(incl[i], w->incl[i], n);
}
}
owner = w->owner;
winunlock(w);
for(;;){
for (;;) {
w = errorwin1(dir.r, dir.nr, incl, nincl);
winlock(w, owner);
if(w->col != nil)
if (w->col != nil)
break;
/* window deleted too fast */
winunlock(w);
@ -177,22 +163,19 @@ errorwinforwin(Window *w)
typedef struct Warning Warning;
struct Warning{
Mntdir *md;
struct Warning {
Mntdir* md;
Buffer buf;
Warning *next;
Warning* next;
};
static Warning *warnings;
static Warning* warnings;
static
void
addwarningtext(Mntdir *md, Rune *r, int nr)
{
Warning *warn;
static void addwarningtext(Mntdir* md, Rune* r, int nr) {
Warning* warn;
for(warn = warnings; warn; warn=warn->next){
if(warn->md == md){
for (warn = warnings; warn; warn = warn->next) {
if (warn->md == md) {
bufinsert(&warn->buf, warn->buf.nc, r, nr);
return;
}
@ -200,7 +183,7 @@ addwarningtext(Mntdir *md, Rune *r, int nr)
warn = emalloc(sizeof(Warning));
warn->next = warnings;
warn->md = md;
if(md)
if (md)
fsysincid(md);
warnings = warn;
bufinsert(&warn->buf, 0, r, nr);
@ -208,20 +191,18 @@ addwarningtext(Mntdir *md, Rune *r, int nr)
}
/* called while row is locked */
void
flushwarnings(void)
{
void flushwarnings(void) {
Warning *warn, *next;
Window *w;
Text *t;
Window* w;
Text* t;
int owner, nr, q0, n;
Rune *r;
Rune* r;
for(warn=warnings; warn; warn=next) {
for (warn = warnings; warn; warn = next) {
w = errorwin(warn->md, 'E');
t = &w->body;
owner = w->owner;
if(owner == 0)
if (owner == 0)
w->owner = 'E';
wincommit(w, t);
/*
@ -234,9 +215,9 @@ flushwarnings(void)
*/
r = fbufalloc();
q0 = t->file->b.nc;
for(n = 0; n < warn->buf.nc; n += nr){
for (n = 0; n < warn->buf.nc; n += nr) {
nr = warn->buf.nc - n;
if(nr > RBUFSIZE)
if (nr > RBUFSIZE)
nr = RBUFSIZE;
bufread(&warn->buf, n, r, nr);
textbsinsert(t, t->file->b.nc, r, nr, TRUE, &nr);
@ -250,117 +231,95 @@ flushwarnings(void)
winunlock(w);
bufclose(&warn->buf);
next = warn->next;
if(warn->md)
if (warn->md)
fsysdelid(warn->md);
free(warn);
}
warnings = nil;
}
void
warning(Mntdir *md, char *s, ...)
{
Rune *r;
void warning(Mntdir* md, char* s, ...) {
Rune* r;
va_list arg;
va_start(arg, s);
r = runevsmprint(s, arg);
va_end(arg);
if(r == nil)
if (r == nil)
error("runevsmprint failed");
addwarningtext(md, r, runestrlen(r));
free(r);
}
int
runeeq(Rune *s1, uint n1, Rune *s2, uint n2)
{
if(n1 != n2)
int runeeq(Rune* s1, uint n1, Rune* s2, uint n2) {
if (n1 != n2)
return FALSE;
return memcmp(s1, s2, n1*sizeof(Rune)) == 0;
return memcmp(s1, s2, n1 * sizeof(Rune)) == 0;
}
uint
min(uint a, uint b)
{
if(a < b)
uint min(uint a, uint b) {
if (a < b)
return a;
return b;
}
uint
max(uint a, uint b)
{
if(a > b)
uint max(uint a, uint b) {
if (a > b)
return a;
return b;
}
char*
runetobyte(Rune *r, int n)
{
char *s;
char* runetobyte(Rune* r, int n) {
char* s;
if(r == nil)
if (r == nil)
return nil;
s = emalloc(n*UTFmax+1);
s = emalloc(n * UTFmax + 1);
setmalloctag(s, getcallerpc(&r));
snprint(s, n*UTFmax+1, "%.*S", n, r);
snprint(s, n * UTFmax + 1, "%.*S", n, r);
return s;
}
Rune*
bytetorune(char *s, int *ip)
{
Rune *r;
Rune* bytetorune(char* s, int* ip) {
Rune* r;
int nb, nr;
nb = strlen(s);
r = runemalloc(nb+1);
r = runemalloc(nb + 1);
cvttorunes(s, nb, r, &nb, &nr, nil);
r[nr] = '\0';
*ip = nr;
return r;
}
int
isalnum(Rune c)
{
int isalnum(Rune c) {
/*
* Hard to get absolutely right. Use what we know about ASCII
* and assume anything above the Latin control characters is
* potentially an alphanumeric.
*/
if(c <= ' ')
if (c <= ' ')
return FALSE;
if(0x7F<=c && c<=0xA0)
if (0x7F <= c && c <= 0xA0)
return FALSE;
if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
if (utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
return FALSE;
return TRUE;
}
int
rgetc(void *v, uint n)
{
return ((Rune*)v)[n];
}
int rgetc(void* v, uint n) { return ((Rune*)v)[n]; }
int
tgetc(void *a, uint n)
{
Text *t;
int tgetc(void* a, uint n) {
Text* t;
t = a;
if(n >= t->file->b.nc)
if (n >= t->file->b.nc)
return 0;
return textreadc(t, n);
}
Rune*
skipbl(Rune *r, int n, int *np)
{
while(n>0 && (*r==' ' || *r=='\t' || *r=='\n')){
Rune* skipbl(Rune* r, int n, int* np) {
while (n > 0 && (*r == ' ' || *r == '\t' || *r == '\n')) {
--n;
r++;
}
@ -368,10 +327,8 @@ skipbl(Rune *r, int n, int *np)
return r;
}
Rune*
findbl(Rune *r, int n, int *np)
{
while(n>0 && *r!=' ' && *r!='\t' && *r!='\n'){
Rune* findbl(Rune* r, int n, int* np) {
while (n > 0 && *r != ' ' && *r != '\t' && *r != '\n') {
--n;
r++;
}
@ -379,20 +336,16 @@ findbl(Rune *r, int n, int *np)
return r;
}
void
savemouse(Window *w)
{
void savemouse(Window* w) {
prevmouse = mouse->xy;
mousew = w;
}
int
restoremouse(Window *w)
{
int restoremouse(Window* w) {
int did;
did = 0;
if(mousew!=nil && mousew==w) {
if (mousew != nil && mousew == w) {
moveto(mousectl, prevmouse);
did = 1;
}
@ -400,42 +353,32 @@ restoremouse(Window *w)
return did;
}
void
clearmouse()
{
mousew = nil;
}
void clearmouse() { mousew = nil; }
char*
estrdup(char *s)
{
char *t;
char* estrdup(char* s) {
char* t;
t = strdup(s);
if(t == nil)
if (t == nil)
error("strdup failed");
setmalloctag(t, getcallerpc(&s));
return t;
}
void*
emalloc(uint n)
{
void *p;
void* emalloc(uint n) {
void* p;
p = malloc(n);
if(p == nil)
if (p == nil)
error("malloc failed");
setmalloctag(p, getcallerpc(&n));
memset(p, 0, n);
return p;
}
void*
erealloc(void *p, uint n)
{
void* erealloc(void* p, uint n) {
p = realloc(p, n);
if(p == nil)
if (p == nil)
error("realloc failed");
setmalloctag(p, getcallerpc(&n));
return p;
@ -444,53 +387,53 @@ erealloc(void *p, uint n)
/*
* Heuristic city.
*/
Window*
makenewwindow(Text *t)
{
Column *c;
Window* makenewwindow(Text* t) {
Column* c;
Window *w, *bigw, *emptyw;
Text *emptyb;
Text* emptyb;
int i, y, el;
if(activecol)
if (activecol)
c = activecol;
else if(seltext && seltext->col)
else if (seltext && seltext->col)
c = seltext->col;
else if(t && t->col)
else if (t && t->col)
c = t->col;
else{
if(row.ncol==0 && rowadd(&row, nil, -1)==nil)
else {
if (row.ncol == 0 && rowadd(&row, nil, -1) == nil)
error("can't make column");
c = row.col[row.ncol-1];
c = row.col[row.ncol - 1];
}
activecol = c;
if(t==nil || t->w==nil || c->nw==0)
if (t == nil || t->w == nil || c->nw == 0)
return coladd(c, nil, nil, -1);
/* find biggest window and biggest blank spot */
emptyw = c->w[0];
bigw = emptyw;
for(i=1; i<c->nw; i++){
for (i = 1; i < c->nw; i++) {
w = c->w[i];
/* use >= to choose one near bottom of screen */
if(w->body.fr.maxlines >= bigw->body.fr.maxlines)
if (w->body.fr.maxlines >= bigw->body.fr.maxlines)
bigw = w;
if(w->body.fr.maxlines-w->body.fr.nlines >= emptyw->body.fr.maxlines-emptyw->body.fr.nlines)
if (
w->body.fr.maxlines - w->body.fr.nlines >=
emptyw->body.fr.maxlines - emptyw->body.fr.nlines)
emptyw = w;
}
emptyb = &emptyw->body;
el = emptyb->fr.maxlines-emptyb->fr.nlines;
el = emptyb->fr.maxlines - emptyb->fr.nlines;
/* if empty space is big, use it */
if(el>15 || (el>3 && el>(bigw->body.fr.maxlines-1)/2))
y = emptyb->fr.r.min.y+emptyb->fr.nlines*font->height;
else{
if (el > 15 || (el > 3 && el > (bigw->body.fr.maxlines - 1) / 2))
y = emptyb->fr.r.min.y + emptyb->fr.nlines * font->height;
else {
/* if this window is in column and isn't much smaller, split it */
if(t->col==c && Dy(t->w->r)>2*Dy(bigw->r)/3)
if (t->col == c && Dy(t->w->r) > 2 * Dy(bigw->r) / 3)
bigw = t->w;
y = (bigw->r.min.y + bigw->r.max.y)/2;
y = (bigw->r.min.y + bigw->r.max.y) / 2;
}
w = coladd(c, nil, nil, y);
if(w->body.fr.maxlines < 2)
if (w->body.fr.maxlines < 2)
colgrow(w->col, w, 1);
return w;
}

501
wind.c
View file

@ -14,13 +14,11 @@
int winid;
void
wininit(Window *w, Window *clone, Rectangle r)
{
void wininit(Window* w, Window* clone, Rectangle r) {
Rectangle r1, br;
File *f;
Reffont *rf;
Rune *rp;
File* f;
Reffont* rf;
Rune* rp;
int nc, i;
w->tag.w = w;
@ -29,7 +27,7 @@ wininit(Window *w, Window *clone, Rectangle r)
w->body.w = w;
w->id = ++winid;
incref(&w->ref);
if(globalincref)
if (globalincref)
incref(&w->ref);
w->ctlfid = ~0;
w->utflastqid = -1;
@ -37,14 +35,14 @@ wininit(Window *w, Window *clone, Rectangle r)
w->tagtop = r;
w->tagtop.max.y = r.min.y + font->height;
r1.max.y = r1.min.y + w->taglines*font->height;
r1.max.y = r1.min.y + w->taglines * font->height;
incref(&reffont.ref);
f = fileaddtext(nil, &w->tag);
textinit(&w->tag, f, r1, &reffont, tagcols);
w->tag.what = Tag;
/* tag is a copy of the contents, not a tracked image */
if(clone){
if (clone) {
textdelete(&w->tag, 0, w->tag.file->b.nc, TRUE);
nc = clone->tag.file->b.nc;
rp = runemalloc(nc);
@ -55,22 +53,22 @@ wininit(Window *w, Window *clone, Rectangle r)
textsetselect(&w->tag, nc, nc);
}
r1 = r;
r1.min.y += w->taglines*font->height + 1;
if(r1.max.y < r1.min.y)
r1.min.y += w->taglines * font->height + 1;
if (r1.max.y < r1.min.y)
r1.max.y = r1.min.y;
f = nil;
if(clone){
if (clone) {
f = clone->body.file;
w->body.org = clone->body.org;
w->isscratch = clone->isscratch;
rf = rfget(FALSE, FALSE, FALSE, clone->body.reffont->f->name);
}else
} else
rf = rfget(FALSE, FALSE, FALSE, nil);
f = fileaddtext(f, &w->body);
w->body.what = Body;
textinit(&w->body, f, r1, rf, textcols);
r1.min.y -= 1;
r1.max.y = r1.min.y+1;
r1.max.y = r1.min.y + 1;
draw(screen, r1, tagcols[BORD], nil, ZP);
textscrdraw(&w->body);
w->r = r;
@ -80,11 +78,11 @@ wininit(Window *w, Window *clone, Rectangle r)
draw(screen, br, button, nil, button->r.min);
w->filemenu = TRUE;
w->maxlines = w->body.fr.maxlines;
for(i=0; i<NINDENT; i++)
for (i = 0; i < NINDENT; i++)
w->indent[i] = globalindent[i];
if(clone){
if (clone) {
w->dirty = clone->dirty;
for(i=0; i<NINDENT; i++)
for (i = 0; i < NINDENT; i++)
w->indent[i] = clone->indent[i];
textsetselect(&w->body, clone->body.q0, clone->body.q1);
winsettag(w);
@ -94,14 +92,12 @@ wininit(Window *w, Window *clone, Rectangle r)
/*
* Draw the appropriate button.
*/
void
windrawbutton(Window *w)
{
Image *b;
void windrawbutton(Window* w) {
Image* b;
Rectangle br;
b = button;
if(!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
if (!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
b = modbutton;
br.min = w->tag.scrollr.min;
br.max.x = br.min.x + Dx(b->r);
@ -109,46 +105,42 @@ windrawbutton(Window *w)
draw(screen, br, b, nil, b->r.min);
}
int
delrunepos(Window *w)
{
int delrunepos(Window* w) {
int n;
Rune rune;
for(n=0; n<w->tag.file->b.nc; n++) {
for (n = 0; n < w->tag.file->b.nc; n++) {
bufread(&w->tag.file->b, n, &rune, 1);
if(rune == ' ')
if (rune == ' ')
break;
}
n += 2;
if(n >= w->tag.file->b.nc)
if (n >= w->tag.file->b.nc)
return -1;
return n;
}
void
movetodel(Window *w)
{
void movetodel(Window* w) {
int n;
n = delrunepos(w);
if(n < 0)
if (n < 0)
return;
moveto(mousectl, addpt(frptofchar(&w->tag.fr, n), Pt(4, w->tag.fr.font->height-4)));
moveto(
mousectl,
addpt(frptofchar(&w->tag.fr, n), Pt(4, w->tag.fr.font->height - 4)));
}
/*
* Compute number of tag lines required
* to display entire tag text.
*/
int
wintaglines(Window *w, Rectangle r)
{
int wintaglines(Window* w, Rectangle r) {
int n;
Rune rune;
Point p;
if(!w->tagexpand && !w->showdel)
if (!w->tagexpand && !w->showdel)
return 1;
w->showdel = FALSE;
w->tag.fr.noredraw = 1;
@ -156,34 +148,32 @@ wintaglines(Window *w, Rectangle r)
w->tag.fr.noredraw = 0;
w->tagsafe = FALSE;
if(!w->tagexpand) {
if (!w->tagexpand) {
/* use just as many lines as needed to show the Del */
n = delrunepos(w);
if(n < 0)
if (n < 0)
return 1;
p = subpt(frptofchar(&w->tag.fr, n), w->tag.fr.r.min);
return 1 + p.y / w->tag.fr.font->height;
}
/* can't use more than we have */
if(w->tag.fr.nlines >= w->tag.fr.maxlines)
if (w->tag.fr.nlines >= w->tag.fr.maxlines)
return w->tag.fr.maxlines;
/* if tag ends with \n, include empty line at end for typing */
n = w->tag.fr.nlines;
if(w->tag.file->b.nc > 0){
bufread(&w->tag.file->b, w->tag.file->b.nc-1, &rune, 1);
if(rune == '\n')
if (w->tag.file->b.nc > 0) {
bufread(&w->tag.file->b, w->tag.file->b.nc - 1, &rune, 1);
if (rune == '\n')
n++;
}
if(n == 0)
if (n == 0)
n = 1;
return n;
}
int
winresize(Window *w, Rectangle r, int safe, int keepextra)
{
int winresize(Window* w, Rectangle r, int safe, int keepextra) {
int oy, y, mouseintag, mouseinbody;
Point p;
Rectangle r1;
@ -193,36 +183,36 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
/* tagtop is first line of tag */
w->tagtop = r;
w->tagtop.max.y = r.min.y+font->height;
w->tagtop.max.y = r.min.y + font->height;
r1 = r;
r1.max.y = min(r.max.y, r1.min.y + w->taglines*font->height);
r1.max.y = min(r.max.y, r1.min.y + w->taglines * font->height);
/* If needed, recompute number of lines in tag. */
if(!safe || !w->tagsafe || !eqrect(w->tag.all, r1)){
if (!safe || !w->tagsafe || !eqrect(w->tag.all, r1)) {
w->taglines = wintaglines(w, r);
r1.max.y = min(r.max.y, r1.min.y + w->taglines*font->height);
r1.max.y = min(r.max.y, r1.min.y + w->taglines * font->height);
}
/* If needed, resize & redraw tag. */
y = r1.max.y;
if(!safe || !w->tagsafe || !eqrect(w->tag.all, r1)){
if (!safe || !w->tagsafe || !eqrect(w->tag.all, r1)) {
textresize(&w->tag, r1, TRUE);
y = w->tag.fr.r.max.y;
windrawbutton(w);
w->tagsafe = TRUE;
/* If mouse is in tag, pull up as tag closes. */
if(mouseintag && !ptinrect(mouse->xy, w->tag.all)){
if (mouseintag && !ptinrect(mouse->xy, w->tag.all)) {
p = mouse->xy;
p.y = w->tag.all.max.y-3;
p.y = w->tag.all.max.y - 3;
moveto(mousectl, p);
}
/* If mouse is in body, push down as tag expands. */
if(mouseinbody && ptinrect(mouse->xy, w->tag.all)){
if (mouseinbody && ptinrect(mouse->xy, w->tag.all)) {
p = mouse->xy;
p.y = w->tag.all.max.y+3;
p.y = w->tag.all.max.y + 3;
moveto(mousectl, p);
}
}
@ -230,16 +220,16 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
/* If needed, resize & redraw body. */
r1 = r;
r1.min.y = y;
if(!safe || !eqrect(w->body.all, r1)){
if (!safe || !eqrect(w->body.all, r1)) {
oy = y;
if(y+1+w->body.fr.font->height <= r.max.y){ /* room for one line */
if (y + 1 + w->body.fr.font->height <= r.max.y) { /* room for one line */
r1.min.y = y;
r1.max.y = y+1;
r1.max.y = y + 1;
draw(screen, r1, tagcols[BORD], nil, ZP);
y++;
r1.min.y = min(y, r.max.y);
r1.max.y = r.max.y;
}else{
} else {
r1.min.y = y;
r1.max.y = y;
}
@ -253,30 +243,24 @@ winresize(Window *w, Rectangle r, int safe, int keepextra)
return w->r.max.y;
}
void
winlock1(Window *w, int owner)
{
void winlock1(Window* w, int owner) {
incref(&w->ref);
qlock(&w->lk);
w->owner = owner;
}
void
winlock(Window *w, int owner)
{
void winlock(Window* w, int owner) {
int i;
File *f;
File* f;
f = w->body.file;
for(i=0; i<f->ntext; i++)
for (i = 0; i < f->ntext; i++)
winlock1(f->text[i]->w, owner);
}
void
winunlock(Window *w)
{
void winunlock(Window* w) {
int i;
File *f;
File* f;
/*
* subtle: loop runs backwards to avoid tripping over
@ -284,7 +268,7 @@ winunlock(Window *w)
* on the last iteration of the loop.
*/
f = w->body.file;
for(i=f->ntext-1; i>=0; i--){
for (i = f->ntext - 1; i >= 0; i--) {
w = f->text[i]->w;
w->owner = 0;
qunlock(&w->lk);
@ -292,21 +276,18 @@ winunlock(Window *w)
}
}
void
winmousebut(Window *w)
{
moveto(mousectl, addpt(w->tag.scrollr.min,
divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
void winmousebut(Window* w) {
moveto(
mousectl,
addpt(w->tag.scrollr.min, divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
}
void
windirfree(Window *w)
{
void windirfree(Window* w) {
int i;
Dirlist *dl;
Dirlist* dl;
if(w->isdir){
for(i=0; i<w->ndl; i++){
if (w->isdir) {
for (i = 0; i < w->ndl; i++) {
dl = w->dlp[i];
free(dl->r);
free(dl);
@ -317,19 +298,17 @@ windirfree(Window *w)
w->ndl = 0;
}
void
winclose(Window *w)
{
void winclose(Window* w) {
int i;
if(decref(&w->ref) == 0){
if (decref(&w->ref) == 0) {
xfidlog(w, "del");
windirfree(w);
textclose(&w->tag);
textclose(&w->body);
if(activewin == w)
if (activewin == w)
activewin = nil;
for(i=0; i<w->nincl; i++)
for (i = 0; i < w->nincl; i++)
free(w->incl[i]);
free(w->incl);
free(w->events);
@ -337,13 +316,11 @@ winclose(Window *w)
}
}
void
windelete(Window *w)
{
Xfid *x;
void windelete(Window* w) {
Xfid* x;
x = w->eventx;
if(x){
if (x) {
w->nevents = 0;
free(w->events);
w->events = nil;
@ -352,164 +329,183 @@ windelete(Window *w)
}
}
void
winundo(Window *w, int isundo)
{
Text *body;
void winundo(Window* w, int isundo) {
Text* body;
int i;
File *f;
Window *v;
File* f;
Window* v;
w->utflastqid = -1;
body = &w->body;
fileundo(body->file, isundo, &body->q0, &body->q1);
textshow(body, body->q0, body->q1, 1);
f = body->file;
for(i=0; i<f->ntext; i++){
for (i = 0; i < f->ntext; i++) {
v = f->text[i]->w;
v->dirty = (f->seq != v->putseq);
if(v != w){
v->body.q0 = v->body.fr.p0+v->body.org;
v->body.q1 = v->body.fr.p1+v->body.org;
if (v != w) {
v->body.q0 = v->body.fr.p0 + v->body.org;
v->body.q1 = v->body.fr.p1 + v->body.org;
}
}
winsettag(w);
}
void
winsetname(Window *w, Rune *name, int n)
{
Text *t;
Window *v;
void winsetname(Window* w, Rune* name, int n) {
Text* t;
Window* v;
int i;
static Rune Lslashguide[] = { '/', 'g', 'u', 'i', 'd', 'e', 0 };
static Rune Lpluserrors[] = { '+', 'E', 'r', 'r', 'o', 'r', 's', 0 };
static Rune Lslashguide[] = {'/', 'g', 'u', 'i', 'd', 'e', 0};
static Rune Lpluserrors[] = {'+', 'E', 'r', 'r', 'o', 'r', 's', 0};
t = &w->body;
if(runeeq(t->file->name, t->file->nname, name, n) == TRUE)
if (runeeq(t->file->name, t->file->nname, name, n) == TRUE)
return;
w->isscratch = FALSE;
if(n>=6 && runeeq(Lslashguide, 6, name+(n-6), 6))
if (n >= 6 && runeeq(Lslashguide, 6, name + (n - 6), 6))
w->isscratch = TRUE;
else if(n>=7 && runeeq(Lpluserrors, 7, name+(n-7), 7))
else if (n >= 7 && runeeq(Lpluserrors, 7, name + (n - 7), 7))
w->isscratch = TRUE;
filesetname(t->file, name, n);
for(i=0; i<t->file->ntext; i++){
for (i = 0; i < t->file->ntext; i++) {
v = t->file->text[i]->w;
winsettag(v);
v->isscratch = w->isscratch;
}
}
void
wintype(Window *w, Text *t, Rune r)
{
void wintype(Window* w, Text* t, Rune r) {
int i;
texttype(t, r);
if(t->what == Body)
for(i=0; i<t->file->ntext; i++)
if (t->what == Body)
for (i = 0; i < t->file->ntext; i++)
textscrdraw(t->file->text[i]);
winsettag(w);
}
void
wincleartag(Window *w)
{
void wincleartag(Window* w) {
int i, n;
Rune *r;
Rune* r;
/* w must be committed */
n = w->tag.file->b.nc;
r = runemalloc(n);
bufread(&w->tag.file->b, 0, r, n);
for(i=0; i<n; i++)
if(r[i]==' ' || r[i]=='\t')
r = parsetag(w, &i);
for (; i < n; i++)
if (r[i] == '|')
break;
for(; i<n; i++)
if(r[i] == '|')
break;
if(i == n)
if (i == n)
return;
i++;
textdelete(&w->tag, i, n, TRUE);
free(r);
w->tag.file->mod = FALSE;
if(w->tag.q0 > i)
if (w->tag.q0 > i)
w->tag.q0 = i;
if(w->tag.q1 > i)
if (w->tag.q1 > i)
w->tag.q1 = i;
textsetselect(&w->tag, w->tag.q0, w->tag.q1);
}
void
winsettag1(Window *w)
{
int i, j, k, n, bar, dirty, resize;
Rune *new, *old, *r;
uint q0, q1;
static Rune Ldelsnarf[] = { ' ', 'D', 'e', 'l', ' ',
'S', 'n', 'a', 'r', 'f', 0 };
static Rune Lundo[] = { ' ', 'U', 'n', 'd', 'o', 0 };
static Rune Lredo[] = { ' ', 'R', 'e', 'd', 'o', 0 };
static Rune Lget[] = { ' ', 'G', 'e', 't', 0 };
static Rune Lput[] = { ' ', 'P', 'u', 't', 0 };
static Rune Llook[] = { ' ', 'L', 'o', 'o', 'k', ' ', 0 };
static Rune Lpipe[] = { ' ', '|', 0 };
Rune* parsetag(Window* w, int* len) {
static Rune Ldelsnarf[] =
{' ', 'D', 'e', 'l', ' ', 'S', 'n', 'a', 'r', 'f', 0};
static Rune Lspacepipe[] = {' ', '|', 0};
static Rune Ltabpipe[] = {' ', '|', 0};
int i;
Rune *r, *p, *pipe;
/* there are races that get us here with stuff in the tag cache, so we take extra care to sync it */
if(w->tag.ncache!=0 || w->tag.file->mod)
wincommit(w, &w->tag); /* check file name; also guarantees we can modify tag contents */
old = runemalloc(w->tag.file->b.nc+1);
bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
old[w->tag.file->b.nc] = '\0';
for(i=0; i<w->tag.file->b.nc; i++)
if(old[i]==' ' || old[i]=='\t')
r = runemalloc(w->tag.file->b.nc + 1);
bufread(&w->tag.file->b, 0, r, w->tag.file->b.nc);
r[w->tag.file->b.nc] = '\0';
for (i = 0; i < w->tag.file->b.nc; i++)
if (r[i] == ' ' || r[i] == '\t')
break;
if(runeeq(old, i, w->body.file->name, w->body.file->nname) == FALSE){
/*
* " |" or "\t|" ends left half of tag
* If we find " Del Snarf" in the left half of the tag
* (before the pipe), that ends the file name.
*/
pipe = runestrstr(r, Lspacepipe);
if ((p = runestrstr(r, Ltabpipe)) != nil && (pipe == nil || p < pipe))
pipe = p;
if ((p = runestrstr(r, Ldelsnarf)) != nil && (pipe == nil || p < pipe))
i = p - r;
else {
for (i = 0; i < w->tag.file->b.nc; i++)
if (r[i] == ' ' || r[i] == '\t')
break;
}
*len = i;
return r;
}
void winsettag1(Window* w) {
int i, j, k, n, bar, dirty, resize;
Rune* new, *old, *r;
uint q0, q1;
static Rune Ldelsnarf[] =
{' ', 'D', 'e', 'l', ' ', 'S', 'n', 'a', 'r', 'f', 0};
static Rune Lundo[] = {' ', 'U', 'n', 'd', 'o', 0};
static Rune Lredo[] = {' ', 'R', 'e', 'd', 'o', 0};
static Rune Lget[] = {' ', 'G', 'e', 't', 0};
static Rune Lput[] = {' ', 'P', 'u', 't', 0};
static Rune Llook[] = {' ', 'L', 'o', 'o', 'k', ' ', 0};
static Rune Lpipe[] = {' ', '|', 0};
/* there are races that get us here with stuff in the tag cache, so we take
* extra care to sync it */
if (w->tag.ncache != 0 || w->tag.file->mod)
wincommit(w, &w->tag); /* check file name; also guarantees we can modify tag
contents */
old = parsetag(w, &i);
if (runeeq(old, i, w->body.file->name, w->body.file->nname) == FALSE) {
textdelete(&w->tag, 0, i, TRUE);
textinsert(&w->tag, 0, w->body.file->name, w->body.file->nname, TRUE);
free(old);
old = runemalloc(w->tag.file->b.nc+1);
old = runemalloc(w->tag.file->b.nc + 1);
bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
old[w->tag.file->b.nc] = '\0';
}
/* compute the text for the whole tag, replacing current only if it differs */
new = runemalloc(w->body.file->nname+100);
new = runemalloc(w->body.file->nname + 100);
i = 0;
runemove(new+i, w->body.file->name, w->body.file->nname);
runemove(new + i, w->body.file->name, w->body.file->nname);
i += w->body.file->nname;
runemove(new+i, Ldelsnarf, 10);
runemove(new + i, Ldelsnarf, 10);
i += 10;
if(w->filemenu){
if(w->body.needundo || w->body.file->delta.nc>0 || w->body.ncache){
runemove(new+i, Lundo, 5);
if (w->filemenu) {
if (w->body.needundo || w->body.file->delta.nc > 0 || w->body.ncache) {
runemove(new + i, Lundo, 5);
i += 5;
}
if(w->body.file->epsilon.nc > 0){
runemove(new+i, Lredo, 5);
if (w->body.file->epsilon.nc > 0) {
runemove(new + i, Lredo, 5);
i += 5;
}
dirty = w->body.file->nname && (w->body.ncache || w->body.file->seq!=w->putseq);
if(!w->isdir && dirty){
runemove(new+i, Lput, 4);
dirty =
w->body.file->nname && (w->body.ncache || w->body.file->seq != w->putseq);
if (!w->isdir && dirty) {
runemove(new + i, Lput, 4);
i += 4;
}
}
if(w->isdir){
runemove(new+i, Lget, 4);
if (w->isdir) {
runemove(new + i, Lget, 4);
i += 4;
}
runemove(new+i, Lpipe, 2);
runemove(new + i, Lpipe, 2);
i += 2;
r = runestrchr(old, '|');
if(r)
k = r-old+1;
else{
if (r)
k = r - old + 1;
else {
k = w->tag.file->b.nc;
if(w->body.file->seq == 0){
runemove(new+i, Llook, 6);
if (w->body.file->seq == 0) {
runemove(new + i, Llook, 6);
i += 6;
}
}
@ -517,80 +513,72 @@ winsettag1(Window *w)
/* replace tag if the new one is different */
resize = 0;
if(runeeq(new, i, old, k) == FALSE){
if (runeeq(new, i, old, k) == FALSE) {
resize = 1;
n = k;
if(n > i)
if (n > i)
n = i;
for(j=0; j<n; j++)
if(old[j] != new[j])
for (j = 0; j < n; j++)
if (old[j] != new[j])
break;
q0 = w->tag.q0;
q1 = w->tag.q1;
textdelete(&w->tag, j, k, TRUE);
textinsert(&w->tag, j, new+j, i-j, TRUE);
textinsert(&w->tag, j, new + j, i - j, TRUE);
/* try to preserve user selection */
r = runestrchr(old, '|');
if(r){
bar = r-old;
if(q0 > bar){
bar = (runestrchr(new, '|')-new)-bar;
w->tag.q0 = q0+bar;
w->tag.q1 = q1+bar;
if (r) {
bar = r - old;
if (q0 > bar) {
bar = (runestrchr(new, '|') - new) - bar;
w->tag.q0 = q0 + bar;
w->tag.q1 = q1 + bar;
}
}
}
free(old);
free(new);
w->tag.file->mod = FALSE;
n = w->tag.file->b.nc+w->tag.ncache;
if(w->tag.q0 > n)
n = w->tag.file->b.nc + w->tag.ncache;
if (w->tag.q0 > n)
w->tag.q0 = n;
if(w->tag.q1 > n)
if (w->tag.q1 > n)
w->tag.q1 = n;
textsetselect(&w->tag, w->tag.q0, w->tag.q1);
windrawbutton(w);
if(resize){
if (resize) {
w->tagsafe = 0;
winresize(w, w->r, TRUE, TRUE);
}
}
void
winsettag(Window *w)
{
void winsettag(Window* w) {
int i;
File *f;
Window *v;
File* f;
Window* v;
f = w->body.file;
for(i=0; i<f->ntext; i++){
for (i = 0; i < f->ntext; i++) {
v = f->text[i]->w;
if(v->col->safe || v->body.fr.maxlines>0)
if (v->col->safe || v->body.fr.maxlines > 0)
winsettag1(v);
}
}
void
wincommit(Window *w, Text *t)
{
Rune *r;
void wincommit(Window* w, Text* t) {
Rune* r;
int i;
File *f;
File* f;
textcommit(t, TRUE);
f = t->file;
if(f->ntext > 1)
for(i=0; i<f->ntext; i++)
if (f->ntext > 1)
for (i = 0; i < f->ntext; i++)
textcommit(f->text[i], FALSE); /* no-op for t */
if(t->what == Body)
if (t->what == Body)
return;
r = runemalloc(w->tag.file->b.nc);
bufread(&w->tag.file->b, 0, r, w->tag.file->b.nc);
for(i=0; i<w->tag.file->b.nc; i++)
if(r[i]==' ' || r[i]=='\t')
break;
if(runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE){
r = parsetag(w, &i);
if (runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE) {
seq++;
filemark(w->body.file);
w->body.file->mod = TRUE;
@ -601,17 +589,15 @@ wincommit(Window *w, Text *t)
free(r);
}
void
winaddincl(Window *w, Rune *r, int n)
{
char *a;
Dir *d;
void winaddincl(Window* w, Rune* r, int n) {
char* a;
Dir* d;
Runestr rs;
a = runetobyte(r, n);
d = dirstat(a);
if(d == nil){
if(a[0] == '/')
if (d == nil) {
if (a[0] == '/')
goto Rescue;
rs = dirname(&w->body, r, n);
r = rs.r;
@ -619,13 +605,13 @@ winaddincl(Window *w, Rune *r, int n)
free(a);
a = runetobyte(r, n);
d = dirstat(a);
if(d == nil)
if (d == nil)
goto Rescue;
r = runerealloc(r, n+1);
r = runerealloc(r, n + 1);
r[n] = 0;
}
free(a);
if((d->qid.type&QTDIR) == 0){
if ((d->qid.type & QTDIR) == 0) {
free(d);
warning(nil, "%s: not a directory\n", a);
free(r);
@ -633,9 +619,9 @@ winaddincl(Window *w, Rune *r, int n)
}
free(d);
w->nincl++;
w->incl = realloc(w->incl, w->nincl*sizeof(Rune*));
memmove(w->incl+1, w->incl, (w->nincl-1)*sizeof(Rune*));
w->incl[0] = runemalloc(n+1);
w->incl = realloc(w->incl, w->nincl * sizeof(Rune*));
memmove(w->incl + 1, w->incl, (w->nincl - 1) * sizeof(Rune*));
w->incl[0] = runemalloc(n + 1);
runemove(w->incl[0], r, n);
free(r);
return;
@ -647,18 +633,17 @@ Rescue:
return;
}
int
winclean(Window *w, int conservative)
{
if(w->isscratch || w->isdir) /* don't whine if it's a guide file, error window, etc. */
int winclean(Window* w, int conservative) {
if (w->isscratch || w->isdir) /* don't whine if it's a guide file, error
window, etc. */
return TRUE;
if(!conservative && w->nopen[QWevent]>0)
if (!conservative && w->nopen[QWevent] > 0)
return TRUE;
if(w->dirty){
if(w->body.file->nname)
if (w->dirty) {
if (w->body.file->nname)
warning(nil, "%.*S modified\n", w->body.file->nname, w->body.file->name);
else{
if(w->body.file->b.nc < 100) /* don't whine if it's too small */
else {
if (w->body.file->b.nc < 100) /* don't whine if it's too small */
return TRUE;
warning(nil, "unnamed file modified\n");
}
@ -668,42 +653,48 @@ winclean(Window *w, int conservative)
return TRUE;
}
char*
winctlprint(Window *w, char *buf, int fonts)
{
sprint(buf, "%11d %11d %11d %11d %11d ", w->id, w->tag.file->b.nc,
w->body.file->b.nc, w->isdir, w->dirty);
if(fonts)
return smprint("%s%11d %q %11d ", buf, Dx(w->body.fr.r),
w->body.reffont->f->name, w->body.fr.maxtab);
char* winctlprint(Window* w, char* buf, int fonts) {
sprint(
buf,
"%11d %11d %11d %11d %11d ",
w->id,
w->tag.file->b.nc,
w->body.file->b.nc,
w->isdir,
w->dirty);
if (fonts)
return smprint(
"%s%11d %q %11d ",
buf,
Dx(w->body.fr.r),
w->body.reffont->f->name,
w->body.fr.maxtab);
return buf;
}
void
winevent(Window *w, char *fmt, ...)
{
void winevent(Window* w, char* fmt, ...) {
int n;
char *b;
Xfid *x;
char* b;
Xfid* x;
va_list arg;
if(w->nopen[QWevent] == 0)
if (w->nopen[QWevent] == 0)
return;
if(w->owner == 0)
if (w->owner == 0)
error("no window owner");
va_start(arg, fmt);
b = vsmprint(fmt, arg);
va_end(arg);
if(b == nil)
if (b == nil)
error("vsmprint failed");
n = strlen(b);
w->events = erealloc(w->events, w->nevents+1+n);
w->events = erealloc(w->events, w->nevents + 1 + n);
w->events[w->nevents++] = w->owner;
memmove(w->events+w->nevents, b, n);
memmove(w->events + w->nevents, b, n);
free(b);
w->nevents += n;
x = w->eventx;
if(x){
if (x) {
w->eventx = nil;
sendp(x->c, nil);
}

605
xfid.c
View file

File diff suppressed because it is too large Load diff