static void*
block(void* handle, void* data, size_t size)
{
register Env_t* env = (Env_t*)handle;
if (data || (size = roundof(size, ALIGN_BOUND2)) > (env->buf + env->size - env->cur))
return 0;
data = (void*)env->cur;
env->cur += size;
return data;
}
static int
tp_getdata(Pax_t* pax, register Paxarchive_t* ap, register Paxfile_t* f, int fd)
{
Sfio_t* sp;
off_t skip;
ssize_t n;
int r;
if (!(n = f->st->st_size))
return 1;
skip = roundof(f->st->st_size, TP_BLOCK);
r = -1;
if (fd < 0)
r = 1;
else if (sp = paxpart(pax, ap, f->st->st_size))
for (;;)
{
if ((n = sfread(sp, pax->buf, sizeof(pax->buf))) < 0)
{
(*pax->errorf)(NiL, pax, 2, "%s: %s: unexpected EOF", ap->name, f->name);
break;
}
else if (n == 0)
{
r = 1;
break;
}
skip -= n;
if (paxdata(pax, ap, f, fd, pax->buf, n))
break;
}
if (skip && paxread(pax, ap, NiL, skip, 0, 0) != skip)
{
(*pax->errorf)(NiL, pax, 2, "%s: %s: cannot skip past %s format data", ap->name, f->name, ap->format->name);
r = -1;
}
return r;
}
void*
_vm_resize(register Vmalloc_t* vp, void* o, unsigned long size)
{
char* p;
unsigned long n;
unsigned long z;
z = vp->last;
vp->last = size;
if (o && size < z)
return o;
if ((o ? (size - z) : size) > vp->size)
{
n = (size > sizeof(vp->current->data)) ? (size - sizeof(vp->current->data)) : 0;
if (!(vp->current->next = newof(0, Vmchunk_t, 1, n)))
return 0;
vp->current = vp->current->next;
vp->data = vp->current->data;
vp->size = n ? 0 : sizeof(vp->current->data);
if (o)
{
memcpy(vp->data, o, z);
o = (void*)vp->data;
}
}
else if (o)
size -= z;
p = vp->data;
size = roundof(size, VM_ALIGN);
if (size >= vp->size)
vp->size = 0;
else
{
vp->size -= size;
vp->data += size;
}
return p;
}
ssize_t
getdents(int fd, void* buf, size_t siz)
{
struct stat st;
if (siz < DIRBLKSIZ)
{
errno = EINVAL;
return(-1);
}
if (fstat(fd, &st)) return(-1);
if (!S_ISDIR(st.st_mode))
{
#ifdef ENOTDIR
errno = ENOTDIR;
#else
errno = EBADF;
#endif
return(-1);
}
#if _lib_getdirentries
{
long off;
return(getdirentries(fd, buf, siz, &off));
}
#else
#if _lib_dirread
{
register char* sp; /* system */
register struct dirent* up; /* user */
char* u;
int n;
int m;
int i;
m = (siz * 6) / 10;
m = roundof(m, 8);
sp = (char*)buf + siz - m - 1;
if (!(n = dirread(fd, sp, m))) return(0);
if (n > 0)
{
up = (struct dirent*)buf;
sp[n] = 0;
while (sp < (char*)buf + siz - m + n)
{
i = 0;
while (*sp >= '0' && *sp <= '9')
i = 10 * i + *sp++ - '0';
while (*sp && *sp != '\t') sp++;
if (*sp++)
{
up->d_fileno = i;
u = up->d_name;
while ((*u = *sp++) && u < up->d_name + MAXNAMLEN) u++;
*u = 0;
up->d_reclen = sizeof(struct dirent) - sizeof(up->d_name) + (up->d_namlen = u - up->d_name) + 1;
up->d_reclen = roundof(up->d_reclen, 8);
up = (struct dirent*)((char*)up + up->d_reclen);
}
}
return((char*)up - (char*)buf);
}
}
#else
#if _mem_d_reclen_direct
return(read(fd, buf, siz));
#else
{
#define MAXREC roundof(sizeof(*up)-sizeof(up->d_name)+sizeof(sp->d_name)+1,8)
register struct direct* sp; /* system */
register struct dirent* up; /* user */
register char* s;
register char* u;
int n;
int m;
char tmp[sizeof(sp->d_name) + 1];
/*
* we assume sizeof(struct dirent) > sizeof(struct direct)
*/
up = (struct dirent*)buf;
n = (siz / MAXREC) * sizeof(struct direct);
if ((!(m = n & ~511) || m < MAXREC) && (!(m = n & ~255) || m < MAXREC)) m = n;
do
{
if ((n = read(fd, (char*)buf + siz - m, m)) <= 0) break;
sp = (struct direct*)((char*)buf + siz - m);
while (sp < (struct direct*)((char*)buf + siz - m + n))
{
if (sp->d_ino)
{
up->d_fileno = sp->d_ino;
s = sp->d_name;
u = tmp;
while (s < sp->d_name + sizeof(sp->d_name) && *s)
*u++ = *s++;
*u = 0;
strcpy(up->d_name, tmp);
up->d_reclen = sizeof(struct dirent) - sizeof(up->d_name) + (up->d_namlen = u - tmp) + 1;
up->d_reclen = roundof(up->d_reclen, 8);
up = (struct dirent*)((char*)up + up->d_reclen);
}
sp++;
}
} while (up == (struct dirent*)buf);
return((char*)up - (char*)buf);
}
#endif
#endif
#endif
}
main()
{
register int i;
register int j;
register int k;
int align0;
int align1;
int align2;
unsigned long bit1;
unsigned long bit2;
unsigned long bits0;
unsigned long bits1;
unsigned long bits2;
union _u_ u;
union _u_ v;
u.u2 = u.u4;
v.u2 = u.u2 + 1;
bit1 = u.u1 ^ v.u1;
v.u2 = u.u2 + 2;
bit2 = u.u1 ^ v.u1;
align0 = sizeof(struct _s_) - sizeof(union _u_);
bits0 = 0;
k = 0;
for (j = 0; j < align0; j++)
{
u.u2 = u.u4 + j;
bits1 = 0;
for (i = 0; i < align0; i++)
{
v.u2 = u.u2 + i;
bits1 |= u.u1 ^ v.u1;
}
if (!bits0 || bits1 < bits0)
{
bits0 = bits1;
k = j;
}
}
align1 = roundof(align0, 2);
u.u2 = u.u4 + k;
for (bits1 = bits0; i < align1; i++)
{
v.u2 = u.u2 + i;
bits1 |= u.u1 ^ v.u1;
}
align2 = roundof(align0, 4);
for (bits2 = bits1; i < align2; i++)
{
v.u2 = u.u2 + i;
bits2 |= u.u1 ^ v.u1;
}
printf("typedef unsigned %s ALIGN_INTEGRAL;\n", sizeof(char*) >= sizeof(long) ? "long" : sizeof(char*) >= sizeof(int) ? "int" : "short");
printf("\n");
printf("#define ALIGN_CHUNK %d\n", sizeof(char*) >= 4 ? 8192 : 1024);
printf("#define ALIGN_INTEGRAL %s\n", sizeof(char*) >= sizeof(long) ? "long" : sizeof(char*) >= sizeof(int) ? "int" : "short");
printf("#define ALIGN_INTEGER(x) ((ALIGN_INTEGRAL)(x))\n");
printf("#define ALIGN_POINTER(x) ((char*)(x))\n");
if (bits2 == (align2 - 1)) printf("#define ALIGN_ROUND(x,y) ALIGN_POINTER(ALIGN_INTEGER((x)+(y)-1)&~((y)-1))\n");
else printf("#define ALIGN_ROUND(x,y) ALIGN_POINTER(ALIGN_INTEGER(ALIGN_ALIGN(x)+(((y)+%d)/%d)-1)&~((((y)+%d)/%d)-1))\n", align0, align0, align0, align0);
printf("\n");
if (align0 == align2)
{
printf("#define ALIGN_BOUND ALIGN_BOUND2\n");
printf("#define ALIGN_ALIGN(x) ALIGN_ALIGN2(x)\n");
printf("#define ALIGN_TRUNC(x) ALIGN_TRUNC2(x)\n");
}
else if (align0 == align1)
{
printf("#define ALIGN_BOUND ALIGN_BOUND1\n");
printf("#define ALIGN_ALIGN(x) ALIGN_ALIGN1(x)\n");
printf("#define ALIGN_TRUNC(x) ALIGN_TRUNC1(x)\n");
}
else
{
printf("#define ALIGN_BOUND 1\n");
printf("#define ALIGN_ALIGN(x) ALIGN_POINTER(x)\n");
printf("#define ALIGN_TRUNC(x) ALIGN_POINTER(x)\n");
}
printf("\n");
printf("#define ALIGN_BIT1 0x%lx\n", bit1);
if (align1 == align2)
{
printf("#define ALIGN_BOUND1 ALIGN_BOUND2\n");
printf("#define ALIGN_ALIGN1(x) ALIGN_ALIGN2(x)\n");
printf("#define ALIGN_TRUNC1(x) ALIGN_TRUNC2(x)\n");
}
else
{
printf("#define ALIGN_BOUND1 %d\n", align1);
printf("#define ALIGN_ALIGN1(x) ALIGN_TRUNC1((x)+%d)\n", align1 - 1);
printf("#define ALIGN_TRUNC1(x) ALIGN_POINTER(ALIGN_INTEGER((x)+%d)&0x%lx)\n", align1 - 1, ~(bits0|bits1));
}
printf("#define ALIGN_CLRBIT1(x) ALIGN_POINTER(ALIGN_INTEGER(x)&0x%lx)\n", ~bit1);
printf("#define ALIGN_SETBIT1(x) ALIGN_POINTER(ALIGN_INTEGER(x)|0x%lx)\n", bit1);
printf("#define ALIGN_TSTBIT1(x) ALIGN_POINTER(ALIGN_INTEGER(x)&0x%lx)\n", bit1);
printf("\n");
printf("#define ALIGN_BIT2 0x%lx\n", bit2);
printf("#define ALIGN_BOUND2 %d\n", align2);
printf("#define ALIGN_ALIGN2(x) ALIGN_TRUNC2((x)+%d)\n", align2 - 1);
printf("#define ALIGN_TRUNC2(x) ALIGN_POINTER(ALIGN_INTEGER(x)&0x%lx)\n", ~(bits0|bits1|bits2));
printf("#define ALIGN_CLRBIT2(x) ALIGN_POINTER(ALIGN_INTEGER(x)&0x%lx)\n", ~bit2);
printf("#define ALIGN_SETBIT2(x) ALIGN_POINTER(ALIGN_INTEGER(x)|0x%lx)\n", bit2);
printf("#define ALIGN_TSTBIT2(x) ALIGN_POINTER(ALIGN_INTEGER(x)&0x%lx)\n", bit2);
printf("\n");
return(0);
}
static int
dofmt(Fmt_t* fp)
{
register int c;
int b;
int x;
int splice;
char* cp;
char* dp;
char* ep;
char* lp;
char* tp;
char buf[8192];
cp = 0;
while (cp || (cp = sfgetr(fp->in, '\n', 0)) && !(splice = 0) && (lp = cp + sfvalue(fp->in) - 1) || (cp = sfgetr(fp->in, '\n', SF_LASTR)) && (splice = 1) && (lp = cp + sfvalue(fp->in)))
{
if (isoption(fp, 'o'))
{
if (!isoption(fp, 'i'))
{
setoption(fp, 'i');
b = 0;
while (cp < lp)
{
if (*cp == ' ')
b += 1;
else if (*cp == '\t')
b += INDENT;
else
break;
cp++;
}
fp->indent = roundof(b, INDENT);
}
else
while (cp < lp && (*cp == ' ' || *cp == '\t'))
cp++;
if (!isoption(fp, 'q') && cp < lp)
{
setoption(fp, 'q');
if (*cp == '"')
{
ep = lp;
while (--ep > cp)
if (*ep == '"')
{
fp->quote = 1;
break;
}
else if (*ep != ' ' && *ep != '\t')
break;
}
}
}
again:
dp = buf;
ep = 0;
for (b = 1;; b = 0)
{
if (cp >= lp)
{
cp = 0;
break;
}
c = *cp++;
if (isoption(fp, 'o'))
{
if (c == '\\')
{
x = 0;
c = ' ';
cp--;
while (cp < lp)
{
if (*cp == '\\')
{
cp++;
if ((lp - cp) < 1)
{
c = '\\';
break;
}
if (*cp == 'n')
{
cp++;
c = '\n';
if ((lp - cp) > 2)
{
if (*cp == ']' || *cp == '@' && *(cp + 1) == '(')
{
*dp++ = '\\';
*dp++ = 'n';
c = *cp++;
break;
}
if (*cp == '\\' && *(cp + 1) == 'n')
{
cp += 2;
*dp++ = '\n';
break;
}
}
}
else if (*cp == 't' || *cp == ' ')
{
cp++;
x = 1;
c = ' ';
}
else
{
if (x && dp != buf && *(dp - 1) != ' ')
*dp++ = ' ';
*dp++ = '\\';
c = *cp++;
break;
}
}
else if (*cp == ' ' || *cp == '\t')
{
cp++;
c = ' ';
x = 1;
}
else
{
if (x && c != '\n' && dp != buf && *(dp - 1) != ' ')
*dp++ = ' ';
break;
}
}
if (c == '\n')
{
c = 0;
goto flush;
}
if (c == ' ' && (dp == buf || *(dp - 1) == ' '))
continue;
}
else if (c == '"')
{
if (b || cp >= lp)
{
if (fp->quote)
continue;
fp->section = 0;
}
}
else if (c == '\a')
{
*dp++ = '\\';
c = 'a';
}
else if (c == '\b')
{
*dp++ = '\\';
c = 'b';
}
else if (c == '\f')
{
*dp++ = '\\';
c = 'f';
}
else if (c == '\v')
{
*dp++ = '\\';
c = 'v';
}
else if (c == ']' && (cp >= lp || *cp != ':' && *cp != '#' && *cp != '!'))
{
if (cp < lp && *cp == ']')
{
cp++;
*dp++ = c;
}
else
{
fp->section = 1;
fp->retain = 0;
flush:
*dp++ = c;
*dp = 0;
split(fp, buf, 0);
outline(fp);
goto again;
}
}
else if (fp->section)
{
if (c == '[')
{
if (b)
fp->retain = 1;
else
{
cp--;
c = 0;
goto flush;
}
fp->section = 0;
}
else if (c == '{')
{
x = 1;
for (tp = cp; tp < lp; tp++)
{
if (*tp == '[' || *tp == '\n')
break;
if (*tp == ' ' || *tp == '\t' || *tp == '"')
continue;
if (*tp == '\\' && (lp - tp) > 1)
{
if (*++tp == 'n')
break;
if (*tp == 't' || *tp == '\n')
continue;
}
x = 0;
break;
}
if (x)
{
if (fp->endbuf > (fp->outbuf + fp->indent + 2*INDENT))
fp->nextdent = 2*INDENT;
goto flush;
}
else
fp->section = 0;
}
else if (c == '}')
{
if (fp->indent && (b || *(cp - 2) != 'f'))
{
if (b)
{
fp->indent -= 2*INDENT;
fp->endbuf += 2*INDENT;
}
else
{
cp--;
c = 0;
}
goto flush;
}
else
fp->section = 0;
}
else if (c == ' ' || c == '\t')
continue;
else
fp->section = 0;
}
else if (c == '?' && (cp >= lp || *cp != '?'))
{
if (fp->retain)
{
cp--;
while (cp < lp && *cp != ' ' && *cp != '\t' && *cp != ']' && dp < &buf[sizeof(buf)-3])
*dp++ = *cp++;
if (cp < lp && (*cp == ' ' || *cp == '\t'))
*dp++ = *cp++;
*dp = 0;
split(fp, buf, 0);
dp = buf;
ep = 0;
fp->retain = 0;
if (fp->outp >= fp->endbuf)
outline(fp);
continue;
}
}
else if (c == ' ' || c == '\t')
for (c = ' '; *cp == ' ' || *cp == '\t'; cp++);
}
else if (c == '\b')
{
if (dp > buf)
{
dp--;
if (ep)
ep--;
}
continue;
}
else if (c == '\t')
{
/*
* expand tabs
*/
if (!ep)
ep = dp;
c = isoption(fp, 'o') ? 1 : TABSZ - (dp - buf) % TABSZ;
if (dp >= &buf[sizeof(buf) - c - 3])
{
cp--;
break;
}
while (c-- > 0)
*dp++ = ' ';
continue;
}
else if (!isprint(c))
continue;
if (dp >= &buf[sizeof(buf) - 3])
{
tp = dp;
while (--tp > buf)
if (isspace(*tp))
{
cp -= dp - tp;
dp = tp;
break;
}
ep = 0;
break;
}
if (c != ' ')
ep = 0;
else if (!ep)
ep = dp;
*dp++ = c;
}
if (ep)
*ep = 0;
else
*dp = 0;
split(fp, buf, splice);
}
return 0;
}
